Annotation of embedaddon/php/ext/reflection/php_reflection.c, revision 1.1.1.1
1.1 misho 1: /*
2: +----------------------------------------------------------------------+
3: | PHP Version 5 |
4: +----------------------------------------------------------------------+
5: | Copyright (c) 1997-2012 The PHP Group |
6: +----------------------------------------------------------------------+
7: | This source file is subject to version 3.01 of the PHP 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.php.net/license/3_01.txt |
11: | If you did not receive a copy of the PHP license and are unable to |
12: | obtain it through the world-wide-web, please send a note to |
13: | license@php.net so we can mail you a copy immediately. |
14: +----------------------------------------------------------------------+
15: | Authors: Timm Friebe <thekid@thekid.de> |
16: | George Schlossnagle <george@omniti.com> |
17: | Andrei Zmievski <andrei@gravitonic.com> |
18: | Marcus Boerger <helly@php.net> |
19: | Johannes Schlueter <johannes@php.net> |
20: +----------------------------------------------------------------------+
21: */
22:
23: /* $Id: php_reflection.c 321634 2012-01-01 13:15:04Z felipe $ */
24:
25: #ifdef HAVE_CONFIG_H
26: #include "config.h"
27: #endif
28:
29: #include "php.h"
30: #include "php_ini.h"
31: #include "php_reflection.h"
32: #include "ext/standard/info.h"
33:
34: #include "zend.h"
35: #include "zend_API.h"
36: #include "zend_exceptions.h"
37: #include "zend_operators.h"
38: #include "zend_constants.h"
39: #include "zend_ini.h"
40: #include "zend_interfaces.h"
41: #include "zend_closures.h"
42:
43: /* Undefine "getParameters" macro defined in "main/php3_compat.h" */
44: #ifdef getParameters
45: # undef getParameters
46: #endif
47:
48: /* Class entry pointers */
49: PHPAPI zend_class_entry *reflector_ptr;
50: PHPAPI zend_class_entry *reflection_exception_ptr;
51: PHPAPI zend_class_entry *reflection_ptr;
52: PHPAPI zend_class_entry *reflection_function_abstract_ptr;
53: PHPAPI zend_class_entry *reflection_function_ptr;
54: PHPAPI zend_class_entry *reflection_parameter_ptr;
55: PHPAPI zend_class_entry *reflection_class_ptr;
56: PHPAPI zend_class_entry *reflection_object_ptr;
57: PHPAPI zend_class_entry *reflection_method_ptr;
58: PHPAPI zend_class_entry *reflection_property_ptr;
59: PHPAPI zend_class_entry *reflection_extension_ptr;
60:
61: #if MBO_0
62: ZEND_BEGIN_MODULE_GLOBALS(reflection)
63: int dummy;
64: ZEND_END_MODULE_GLOBALS(reflection)
65:
66: #ifdef ZTS
67: # define REFLECTION_G(v) \
68: TSRMG(reflection_globals_id, zend_reflection_globals*, v)
69: extern int reflection_globals_id;
70: #else
71: # define REFLECTION_G(v) (reflection_globals.v)
72: extern zend_reflection_globals reflectionglobals;
73: #endif
74:
75: ZEND_DECLARE_MODULE_GLOBALS(reflection)
76: #endif /* MBO_0 */
77:
78: /* Method macros */
79:
80: #define METHOD_NOTSTATIC(ce) \
81: if (!this_ptr || !instanceof_function(Z_OBJCE_P(this_ptr), ce TSRMLS_CC)) { \
82: php_error_docref(NULL TSRMLS_CC, E_ERROR, "%s() cannot be called statically", get_active_function_name(TSRMLS_C)); \
83: return; \
84: } \
85:
86: /* Exception throwing macro */
87: #define _DO_THROW(msg) \
88: zend_throw_exception(reflection_exception_ptr, msg, 0 TSRMLS_CC); \
89: return; \
90:
91: #define RETURN_ON_EXCEPTION \
92: if (EG(exception) && Z_OBJCE_P(EG(exception)) == reflection_exception_ptr) { \
93: return; \
94: }
95:
96: #define GET_REFLECTION_OBJECT_PTR(target) \
97: intern = (reflection_object *) zend_object_store_get_object(getThis() TSRMLS_CC); \
98: if (intern == NULL || intern->ptr == NULL) { \
99: RETURN_ON_EXCEPTION \
100: php_error_docref(NULL TSRMLS_CC, E_ERROR, "Internal error: Failed to retrieve the reflection object"); \
101: } \
102: target = intern->ptr; \
103:
104: /* Class constants */
105: #define REGISTER_REFLECTION_CLASS_CONST_LONG(class_name, const_name, value) \
106: zend_declare_class_constant_long(reflection_ ## class_name ## _ptr, const_name, sizeof(const_name)-1, (long)value TSRMLS_CC);
107:
108: /* {{{ Smart string functions */
109: typedef struct _string {
110: char *string;
111: int len;
112: int alloced;
113: } string;
114:
115: static void string_init(string *str)
116: {
117: str->string = (char *) emalloc(1024);
118: str->len = 1;
119: str->alloced = 1024;
120: *str->string = '\0';
121: }
122:
123: static string *string_printf(string *str, const char *format, ...)
124: {
125: int len;
126: va_list arg;
127: char *s_tmp;
128:
129: va_start(arg, format);
130: len = zend_vspprintf(&s_tmp, 0, format, arg);
131: if (len) {
132: register int nlen = (str->len + len + (1024 - 1)) & ~(1024 - 1);
133: if (str->alloced < nlen) {
134: str->alloced = nlen;
135: str->string = erealloc(str->string, str->alloced);
136: }
137: memcpy(str->string + str->len - 1, s_tmp, len + 1);
138: str->len += len;
139: }
140: efree(s_tmp);
141: va_end(arg);
142: return str;
143: }
144:
145: static string *string_write(string *str, char *buf, int len)
146: {
147: register int nlen = (str->len + len + (1024 - 1)) & ~(1024 - 1);
148: if (str->alloced < nlen) {
149: str->alloced = nlen;
150: str->string = erealloc(str->string, str->alloced);
151: }
152: memcpy(str->string + str->len - 1, buf, len);
153: str->len += len;
154: str->string[str->len - 1] = '\0';
155: return str;
156: }
157:
158: static string *string_append(string *str, string *append)
159: {
160: if (append->len > 1) {
161: string_write(str, append->string, append->len - 1);
162: }
163: return str;
164: }
165:
166: static void string_free(string *str)
167: {
168: efree(str->string);
169: str->len = 0;
170: str->alloced = 0;
171: str->string = NULL;
172: }
173: /* }}} */
174:
175: /* Struct for properties */
176: typedef struct _property_reference {
177: zend_class_entry *ce;
178: zend_property_info prop;
179: } property_reference;
180:
181: /* Struct for parameters */
182: typedef struct _parameter_reference {
183: zend_uint offset;
184: zend_uint required;
185: struct _zend_arg_info *arg_info;
186: zend_function *fptr;
187: } parameter_reference;
188:
189: typedef enum {
190: REF_TYPE_OTHER, /* Must be 0 */
191: REF_TYPE_FUNCTION,
192: REF_TYPE_PARAMETER,
193: REF_TYPE_PROPERTY,
194: REF_TYPE_DYNAMIC_PROPERTY
195: } reflection_type_t;
196:
197: /* Struct for reflection objects */
198: typedef struct {
199: zend_object zo;
200: void *ptr;
201: reflection_type_t ref_type;
202: zval *obj;
203: zend_class_entry *ce;
204: unsigned int ignore_visibility:1;
205: } reflection_object;
206:
207: static zend_object_handlers reflection_object_handlers;
208:
209: static void _default_get_entry(zval *object, char *name, int name_len, zval *return_value TSRMLS_DC)
210: {
211: zval **value;
212:
213: if (zend_hash_find(Z_OBJPROP_P(object), name, name_len, (void **) &value) == FAILURE) {
214: RETURN_FALSE;
215: }
216:
217: MAKE_COPY_ZVAL(value, return_value);
218: }
219:
220: #ifdef ilia_0
221: static void _default_lookup_entry(zval *object, char *name, int name_len, zval **return_value TSRMLS_DC) /* {{{ */
222: {
223: zval **value;
224:
225: if (zend_hash_find(Z_OBJPROP_P(object), name, name_len, (void **) &value) == FAILURE) {
226: *return_value = NULL;
227: } else {
228: *return_value = *value;
229: }
230: }
231: /* }}} */
232: #endif
233:
234: static void reflection_register_implement(zend_class_entry *class_entry, zend_class_entry *interface_entry TSRMLS_DC)
235: {
236: zend_uint num_interfaces = ++class_entry->num_interfaces;
237:
238: class_entry->interfaces = (zend_class_entry **) realloc(class_entry->interfaces, sizeof(zend_class_entry *) * num_interfaces);
239: class_entry->interfaces[num_interfaces - 1] = interface_entry;
240: }
241:
242: static zend_function *_copy_function(zend_function *fptr TSRMLS_DC) /* {{{ */
243: {
244: if (fptr
245: && fptr->type == ZEND_INTERNAL_FUNCTION
246: && (fptr->internal_function.fn_flags & ZEND_ACC_CALL_VIA_HANDLER) != 0)
247: {
248: zend_function *copy_fptr;
249: copy_fptr = emalloc(sizeof(zend_function));
250: memcpy(copy_fptr, fptr, sizeof(zend_function));
251: copy_fptr->internal_function.function_name = estrdup(fptr->internal_function.function_name);
252: return copy_fptr;
253: } else {
254: /* no copy needed */
255: return fptr;
256: }
257: }
258: /* }}} */
259:
260: static void _free_function(zend_function *fptr TSRMLS_DC) /* {{{ */
261: {
262: if (fptr
263: && fptr->type == ZEND_INTERNAL_FUNCTION
264: && (fptr->internal_function.fn_flags & ZEND_ACC_CALL_VIA_HANDLER) != 0)
265: {
266: efree(fptr->internal_function.function_name);
267: efree(fptr);
268: }
269: }
270: /* }}} */
271:
272: static void reflection_free_objects_storage(void *object TSRMLS_DC)
273: {
274: reflection_object *intern = (reflection_object *) object;
275: parameter_reference *reference;
276: property_reference *prop_reference;
277:
278: if (intern->ptr) {
279: switch (intern->ref_type) {
280: case REF_TYPE_PARAMETER:
281: reference = (parameter_reference*)intern->ptr;
282: _free_function(reference->fptr TSRMLS_CC);
283: efree(intern->ptr);
284: break;
285: case REF_TYPE_FUNCTION:
286: _free_function(intern->ptr TSRMLS_CC);
287: break;
288: case REF_TYPE_PROPERTY:
289: efree(intern->ptr);
290: break;
291: case REF_TYPE_DYNAMIC_PROPERTY:
292: prop_reference = (property_reference*)intern->ptr;
293: efree(prop_reference->prop.name);
294: efree(intern->ptr);
295: break;
296: case REF_TYPE_OTHER:
297: break;
298: }
299: }
300: intern->ptr = NULL;
301: if (intern->obj) {
302: zval_ptr_dtor(&intern->obj);
303: }
304: zend_objects_free_object_storage(object TSRMLS_CC);
305: }
306:
307: static zend_object_value reflection_objects_new(zend_class_entry *class_type TSRMLS_DC)
308: {
309: zval tmp;
310: zend_object_value retval;
311: reflection_object *intern;
312:
313: intern = ecalloc(1, sizeof(reflection_object));
314: intern->zo.ce = class_type;
315:
316: zend_object_std_init(&intern->zo, class_type TSRMLS_CC);
317: zend_hash_copy(intern->zo.properties, &class_type->default_properties, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
318: retval.handle = zend_objects_store_put(intern, NULL, reflection_free_objects_storage, NULL TSRMLS_CC);
319: retval.handlers = &reflection_object_handlers;
320: return retval;
321: }
322:
323: static zval * reflection_instantiate(zend_class_entry *pce, zval *object TSRMLS_DC)
324: {
325: if (!object) {
326: ALLOC_ZVAL(object);
327: }
328: Z_TYPE_P(object) = IS_OBJECT;
329: object_init_ex(object, pce);
330: Z_SET_REFCOUNT_P(object, 1);
331: Z_SET_ISREF_P(object);
332: return object;
333: }
334:
335: static void _const_string(string *str, char *name, zval *value, char *indent TSRMLS_DC);
336: static void _function_string(string *str, zend_function *fptr, zend_class_entry *scope, char *indent TSRMLS_DC);
337: static void _property_string(string *str, zend_property_info *prop, char *prop_name, char* indent TSRMLS_DC);
338: static void _class_string(string *str, zend_class_entry *ce, zval *obj, char *indent TSRMLS_DC);
339: static void _extension_string(string *str, zend_module_entry *module, char *indent TSRMLS_DC);
340:
341: /* {{{ _class_string */
342: static void _class_string(string *str, zend_class_entry *ce, zval *obj, char *indent TSRMLS_DC)
343: {
344: int count, count_static_props = 0, count_static_funcs = 0, count_shadow_props = 0;
345: string sub_indent;
346:
347: string_init(&sub_indent);
348: string_printf(&sub_indent, "%s ", indent);
349:
350: /* TBD: Repair indenting of doc comment (or is this to be done in the parser?) */
351: if (ce->type == ZEND_USER_CLASS && ce->doc_comment) {
352: string_printf(str, "%s%s", indent, ce->doc_comment);
353: string_write(str, "\n", 1);
354: }
355:
356: if (obj) {
357: string_printf(str, "%sObject of class [ ", indent);
358: } else {
359: string_printf(str, "%s%s [ ", indent, (ce->ce_flags & ZEND_ACC_INTERFACE) ? "Interface" : "Class");
360: }
361: string_printf(str, (ce->type == ZEND_USER_CLASS) ? "<user" : "<internal");
362: if (ce->module) {
363: string_printf(str, ":%s", ce->module->name);
364: }
365: string_printf(str, "> ");
366: if (ce->get_iterator != NULL) {
367: string_printf(str, "<iterateable> ");
368: }
369: if (ce->ce_flags & ZEND_ACC_INTERFACE) {
370: string_printf(str, "interface ");
371: } else {
372: if (ce->ce_flags & (ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) {
373: string_printf(str, "abstract ");
374: }
375: if (ce->ce_flags & ZEND_ACC_FINAL_CLASS) {
376: string_printf(str, "final ");
377: }
378: string_printf(str, "class ");
379: }
380: string_printf(str, "%s", ce->name);
381: if (ce->parent) {
382: string_printf(str, " extends %s", ce->parent->name);
383: }
384:
385: if (ce->num_interfaces) {
386: zend_uint i;
387:
388: if (ce->ce_flags & ZEND_ACC_INTERFACE) {
389: string_printf(str, " extends %s", ce->interfaces[0]->name);
390: } else {
391: string_printf(str, " implements %s", ce->interfaces[0]->name);
392: }
393: for (i = 1; i < ce->num_interfaces; ++i) {
394: string_printf(str, ", %s", ce->interfaces[i]->name);
395: }
396: }
397: string_printf(str, " ] {\n");
398:
399: /* The information where a class is declared is only available for user classes */
400: if (ce->type == ZEND_USER_CLASS) {
401: string_printf(str, "%s @@ %s %d-%d\n", indent, ce->filename,
402: ce->line_start, ce->line_end);
403: }
404:
405: /* Constants */
406: if (&ce->constants_table) {
407: zend_hash_apply_with_argument(&ce->constants_table, (apply_func_arg_t) zval_update_constant, (void*)1 TSRMLS_CC);
408: string_printf(str, "\n");
409: count = zend_hash_num_elements(&ce->constants_table);
410: string_printf(str, "%s - Constants [%d] {\n", indent, count);
411: if (count > 0) {
412: HashPosition pos;
413: zval **value;
414: char *key;
415: uint key_len;
416: ulong num_index;
417:
418: zend_hash_internal_pointer_reset_ex(&ce->constants_table, &pos);
419:
420: while (zend_hash_get_current_data_ex(&ce->constants_table, (void **) &value, &pos) == SUCCESS) {
421: zend_hash_get_current_key_ex(&ce->constants_table, &key, &key_len, &num_index, 0, &pos);
422:
423: _const_string(str, key, *value, indent TSRMLS_CC);
424: zend_hash_move_forward_ex(&ce->constants_table, &pos);
425: }
426: }
427: string_printf(str, "%s }\n", indent);
428: }
429:
430: /* Static properties */
431: if (&ce->properties_info) {
432: /* counting static properties */
433: count = zend_hash_num_elements(&ce->properties_info);
434: if (count > 0) {
435: HashPosition pos;
436: zend_property_info *prop;
437:
438: zend_hash_internal_pointer_reset_ex(&ce->properties_info, &pos);
439:
440: while (zend_hash_get_current_data_ex(&ce->properties_info, (void **) &prop, &pos) == SUCCESS) {
441: if(prop->flags & ZEND_ACC_SHADOW) {
442: count_shadow_props++;
443: } else if (prop->flags & ZEND_ACC_STATIC) {
444: count_static_props++;
445: }
446: zend_hash_move_forward_ex(&ce->properties_info, &pos);
447: }
448: }
449:
450: /* static properties */
451: string_printf(str, "\n%s - Static properties [%d] {\n", indent, count_static_props);
452: if (count_static_props > 0) {
453: HashPosition pos;
454: zend_property_info *prop;
455:
456: zend_hash_internal_pointer_reset_ex(&ce->properties_info, &pos);
457:
458: while (zend_hash_get_current_data_ex(&ce->properties_info, (void **) &prop, &pos) == SUCCESS) {
459: if ((prop->flags & ZEND_ACC_STATIC) && !(prop->flags & ZEND_ACC_SHADOW)) {
460: _property_string(str, prop, NULL, sub_indent.string TSRMLS_CC);
461: }
462:
463: zend_hash_move_forward_ex(&ce->properties_info, &pos);
464: }
465: }
466: string_printf(str, "%s }\n", indent);
467: }
468:
469: /* Static methods */
470: if (&ce->function_table) {
471: /* counting static methods */
472: count = zend_hash_num_elements(&ce->function_table);
473: if (count > 0) {
474: HashPosition pos;
475: zend_function *mptr;
476:
477: zend_hash_internal_pointer_reset_ex(&ce->function_table, &pos);
478:
479: while (zend_hash_get_current_data_ex(&ce->function_table, (void **) &mptr, &pos) == SUCCESS) {
480: if (mptr->common.fn_flags & ZEND_ACC_STATIC
481: && ((mptr->common.fn_flags & ZEND_ACC_PRIVATE) == 0 || mptr->common.scope == ce))
482: {
483: count_static_funcs++;
484: }
485: zend_hash_move_forward_ex(&ce->function_table, &pos);
486: }
487: }
488:
489: /* static methods */
490: string_printf(str, "\n%s - Static methods [%d] {", indent, count_static_funcs);
491: if (count_static_funcs > 0) {
492: HashPosition pos;
493: zend_function *mptr;
494:
495: zend_hash_internal_pointer_reset_ex(&ce->function_table, &pos);
496:
497: while (zend_hash_get_current_data_ex(&ce->function_table, (void **) &mptr, &pos) == SUCCESS) {
498: if (mptr->common.fn_flags & ZEND_ACC_STATIC
499: && ((mptr->common.fn_flags & ZEND_ACC_PRIVATE) == 0 || mptr->common.scope == ce))
500: {
501: string_printf(str, "\n");
502: _function_string(str, mptr, ce, sub_indent.string TSRMLS_CC);
503: }
504: zend_hash_move_forward_ex(&ce->function_table, &pos);
505: }
506: } else {
507: string_printf(str, "\n");
508: }
509: string_printf(str, "%s }\n", indent);
510: }
511:
512: /* Default/Implicit properties */
513: if (&ce->properties_info) {
514: count = zend_hash_num_elements(&ce->properties_info) - count_static_props - count_shadow_props;
515: string_printf(str, "\n%s - Properties [%d] {\n", indent, count);
516: if (count > 0) {
517: HashPosition pos;
518: zend_property_info *prop;
519:
520: zend_hash_internal_pointer_reset_ex(&ce->properties_info, &pos);
521:
522: while (zend_hash_get_current_data_ex(&ce->properties_info, (void **) &prop, &pos) == SUCCESS) {
523: if (!(prop->flags & (ZEND_ACC_STATIC|ZEND_ACC_SHADOW))) {
524: _property_string(str, prop, NULL, sub_indent.string TSRMLS_CC);
525: }
526: zend_hash_move_forward_ex(&ce->properties_info, &pos);
527: }
528: }
529: string_printf(str, "%s }\n", indent);
530: }
531:
532: if (obj && Z_OBJ_HT_P(obj)->get_properties) {
533: string dyn;
534: HashTable *properties = Z_OBJ_HT_P(obj)->get_properties(obj TSRMLS_CC);
535: HashPosition pos;
536: zval **prop;
537:
538: string_init(&dyn);
539: count = 0;
540:
541: if (properties && zend_hash_num_elements(properties)) {
542: zend_hash_internal_pointer_reset_ex(properties, &pos);
543:
544: while (zend_hash_get_current_data_ex(properties, (void **) &prop, &pos) == SUCCESS) {
545: char *prop_name;
546: uint prop_name_size;
547: ulong index;
548:
549: if (zend_hash_get_current_key_ex(properties, &prop_name, &prop_name_size, &index, 1, &pos) == HASH_KEY_IS_STRING) {
550: if (prop_name_size && prop_name[0]) { /* skip all private and protected properties */
551: if (!zend_hash_quick_exists(&ce->properties_info, prop_name, prop_name_size, zend_get_hash_value(prop_name, prop_name_size))) {
552: count++;
553: _property_string(&dyn, NULL, prop_name, sub_indent.string TSRMLS_CC);
554: }
555: }
556: efree(prop_name);
557: }
558: zend_hash_move_forward_ex(properties, &pos);
559: }
560: }
561:
562: string_printf(str, "\n%s - Dynamic properties [%d] {\n", indent, count);
563: string_append(str, &dyn);
564: string_printf(str, "%s }\n", indent);
565: string_free(&dyn);
566: }
567:
568: /* Non static methods */
569: if (&ce->function_table) {
570: count = zend_hash_num_elements(&ce->function_table) - count_static_funcs;
571: if (count > 0) {
572: HashPosition pos;
573: zend_function *mptr;
574: string dyn;
575:
576: count = 0;
577: string_init(&dyn);
578: zend_hash_internal_pointer_reset_ex(&ce->function_table, &pos);
579:
580: while (zend_hash_get_current_data_ex(&ce->function_table, (void **) &mptr, &pos) == SUCCESS) {
581: if ((mptr->common.fn_flags & ZEND_ACC_STATIC) == 0
582: && ((mptr->common.fn_flags & ZEND_ACC_PRIVATE) == 0 || mptr->common.scope == ce))
583: {
584: char *key;
585: uint key_len;
586: ulong num_index;
587: uint len = strlen(mptr->common.function_name);
588:
589: /* Do not display old-style inherited constructors */
590: if ((mptr->common.fn_flags & ZEND_ACC_CTOR) == 0
591: || mptr->common.scope == ce
592: || zend_hash_get_current_key_ex(&ce->function_table, &key, &key_len, &num_index, 0, &pos) != HASH_KEY_IS_STRING
593: || zend_binary_strcasecmp(key, key_len-1, mptr->common.function_name, len) == 0)
594: {
595: zend_function *closure;
596: /* see if this is a closure */
597: if (ce == zend_ce_closure && obj && (len == sizeof(ZEND_INVOKE_FUNC_NAME)-1)
598: && memcmp(mptr->common.function_name, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1) == 0
599: && (closure = zend_get_closure_invoke_method(obj TSRMLS_CC)) != NULL)
600: {
601: mptr = closure;
602: } else {
603: closure = NULL;
604: }
605: string_printf(&dyn, "\n");
606: _function_string(&dyn, mptr, ce, sub_indent.string TSRMLS_CC);
607: count++;
608: _free_function(closure TSRMLS_CC);
609: }
610: }
611: zend_hash_move_forward_ex(&ce->function_table, &pos);
612: }
613: string_printf(str, "\n%s - Methods [%d] {", indent, count);
614: if (!count) {
615: string_printf(str, "\n");
616: }
617: string_append(str, &dyn);
618: string_free(&dyn);
619: } else {
620: string_printf(str, "\n%s - Methods [0] {\n", indent);
621: }
622: string_printf(str, "%s }\n", indent);
623: }
624:
625: string_printf(str, "%s}\n", indent);
626: string_free(&sub_indent);
627: }
628: /* }}} */
629:
630: /* {{{ _const_string */
631: static void _const_string(string *str, char *name, zval *value, char *indent TSRMLS_DC)
632: {
633: char *type;
634: zval value_copy;
635: int use_copy;
636:
637: type = zend_zval_type_name(value);
638:
639: zend_make_printable_zval(value, &value_copy, &use_copy);
640: if (use_copy) {
641: value = &value_copy;
642: }
643:
644: string_printf(str, "%s Constant [ %s %s ] { %s }\n",
645: indent, type, name, Z_STRVAL_P(value));
646:
647: if (use_copy) {
648: zval_dtor(value);
649: }
650: }
651: /* }}} */
652:
653: /* {{{ _get_recv_opcode */
654: static zend_op* _get_recv_op(zend_op_array *op_array, zend_uint offset)
655: {
656: zend_op *op = op_array->opcodes;
657: zend_op *end = op + op_array->last;
658:
659: ++offset;
660: while (op < end) {
661: if ((op->opcode == ZEND_RECV || op->opcode == ZEND_RECV_INIT)
662: && op->op1.u.constant.value.lval == (long)offset)
663: {
664: return op;
665: }
666: ++op;
667: }
668: return NULL;
669: }
670: /* }}} */
671:
672: /* {{{ _parameter_string */
673: static void _parameter_string(string *str, zend_function *fptr, struct _zend_arg_info *arg_info, zend_uint offset, zend_uint required, char* indent TSRMLS_DC)
674: {
675: string_printf(str, "Parameter #%d [ ", offset);
676: if (offset >= required) {
677: string_printf(str, "<optional> ");
678: } else {
679: string_printf(str, "<required> ");
680: }
681: if (arg_info->class_name) {
682: string_printf(str, "%s ", arg_info->class_name);
683: if (arg_info->allow_null) {
684: string_printf(str, "or NULL ");
685: }
686: } else if (arg_info->array_type_hint) {
687: string_printf(str, "array ");
688: if (arg_info->allow_null) {
689: string_printf(str, "or NULL ");
690: }
691: }
692: if (arg_info->pass_by_reference) {
693: string_write(str, "&", sizeof("&")-1);
694: }
695: if (arg_info->name) {
696: string_printf(str, "$%s", arg_info->name);
697: } else {
698: string_printf(str, "$param%d", offset);
699: }
700: if (fptr->type == ZEND_USER_FUNCTION && offset >= required) {
701: zend_op *precv = _get_recv_op((zend_op_array*)fptr, offset);
702: if (precv && precv->opcode == ZEND_RECV_INIT && precv->op2.op_type != IS_UNUSED) {
703: zval *zv, zv_copy;
704: int use_copy;
705: string_write(str, " = ", sizeof(" = ")-1);
706: ALLOC_ZVAL(zv);
707: *zv = precv->op2.u.constant;
708: zval_copy_ctor(zv);
709: INIT_PZVAL(zv);
710: zval_update_constant_ex(&zv, (void*)1, fptr->common.scope TSRMLS_CC);
711: if (Z_TYPE_P(zv) == IS_BOOL) {
712: if (Z_LVAL_P(zv)) {
713: string_write(str, "true", sizeof("true")-1);
714: } else {
715: string_write(str, "false", sizeof("false")-1);
716: }
717: } else if (Z_TYPE_P(zv) == IS_NULL) {
718: string_write(str, "NULL", sizeof("NULL")-1);
719: } else if (Z_TYPE_P(zv) == IS_STRING) {
720: string_write(str, "'", sizeof("'")-1);
721: string_write(str, Z_STRVAL_P(zv), MIN(Z_STRLEN_P(zv), 15));
722: if (Z_STRLEN_P(zv) > 15) {
723: string_write(str, "...", sizeof("...")-1);
724: }
725: string_write(str, "'", sizeof("'")-1);
726: } else {
727: zend_make_printable_zval(zv, &zv_copy, &use_copy);
728: string_write(str, Z_STRVAL(zv_copy), Z_STRLEN(zv_copy));
729: if (use_copy) {
730: zval_dtor(&zv_copy);
731: }
732: }
733: zval_ptr_dtor(&zv);
734: }
735: }
736: string_write(str, " ]", sizeof(" ]")-1);
737: }
738: /* }}} */
739:
740: /* {{{ _function_parameter_string */
741: static void _function_parameter_string(string *str, zend_function *fptr, char* indent TSRMLS_DC)
742: {
743: struct _zend_arg_info *arg_info = fptr->common.arg_info;
744: zend_uint i, required = fptr->common.required_num_args;
745:
746: if (!arg_info) {
747: return;
748: }
749:
750: string_printf(str, "\n");
751: string_printf(str, "%s- Parameters [%d] {\n", indent, fptr->common.num_args);
752: for (i = 0; i < fptr->common.num_args; i++) {
753: string_printf(str, "%s ", indent);
754: _parameter_string(str, fptr, arg_info, i, required, indent TSRMLS_CC);
755: string_write(str, "\n", sizeof("\n")-1);
756: arg_info++;
757: }
758: string_printf(str, "%s}\n", indent);
759: }
760: /* }}} */
761:
762: /* {{{ _function_closure_string */
763: static void _function_closure_string(string *str, zend_function *fptr, char* indent TSRMLS_DC)
764: {
765: zend_uint i, count;
766: ulong num_index;
767: char *key;
768: uint key_len;
769: HashTable *static_variables;
770: HashPosition pos;
771:
772: if (fptr->type != ZEND_USER_FUNCTION || !fptr->op_array.static_variables) {
773: return;
774: }
775:
776: static_variables = fptr->op_array.static_variables;
777: count = zend_hash_num_elements(static_variables);
778:
779: if (!count) {
780: return;
781: }
782:
783: string_printf(str, "\n");
784: string_printf(str, "%s- Bound Variables [%d] {\n", indent, zend_hash_num_elements(static_variables));
785: zend_hash_internal_pointer_reset_ex(static_variables, &pos);
786: i = 0;
787: while (i < count) {
788: zend_hash_get_current_key_ex(static_variables, &key, &key_len, &num_index, 0, &pos);
789: string_printf(str, "%s Variable #%d [ $%s ]\n", indent, i++, key);
790: zend_hash_move_forward_ex(static_variables, &pos);
791: }
792: string_printf(str, "%s}\n", indent);
793: }
794: /* }}} */
795:
796: /* {{{ _function_string */
797: static void _function_string(string *str, zend_function *fptr, zend_class_entry *scope, char* indent TSRMLS_DC)
798: {
799: string param_indent;
800: zend_function *overwrites;
801: char *lc_name;
802: unsigned int lc_name_len;
803:
804: /* TBD: Repair indenting of doc comment (or is this to be done in the parser?)
805: * What's "wrong" is that any whitespace before the doc comment start is
806: * swallowed, leading to an unaligned comment.
807: */
808: if (fptr->type == ZEND_USER_FUNCTION && fptr->op_array.doc_comment) {
809: string_printf(str, "%s%s\n", indent, fptr->op_array.doc_comment);
810: }
811:
812: string_write(str, indent, strlen(indent));
813: string_printf(str, fptr->common.fn_flags & ZEND_ACC_CLOSURE ? "Closure [ " : (fptr->common.scope ? "Method [ " : "Function [ "));
814: string_printf(str, (fptr->type == ZEND_USER_FUNCTION) ? "<user" : "<internal");
815: if (fptr->common.fn_flags & ZEND_ACC_DEPRECATED) {
816: string_printf(str, ", deprecated");
817: }
818: if (fptr->type == ZEND_INTERNAL_FUNCTION && ((zend_internal_function*)fptr)->module) {
819: string_printf(str, ":%s", ((zend_internal_function*)fptr)->module->name);
820: }
821:
822: if (scope && fptr->common.scope) {
823: if (fptr->common.scope != scope) {
824: string_printf(str, ", inherits %s", fptr->common.scope->name);
825: } else if (fptr->common.scope->parent) {
826: lc_name_len = strlen(fptr->common.function_name);
827: lc_name = zend_str_tolower_dup(fptr->common.function_name, lc_name_len);
828: if (zend_hash_find(&fptr->common.scope->parent->function_table, lc_name, lc_name_len + 1, (void**) &overwrites) == SUCCESS) {
829: if (fptr->common.scope != overwrites->common.scope) {
830: string_printf(str, ", overwrites %s", overwrites->common.scope->name);
831: }
832: }
833: efree(lc_name);
834: }
835: }
836: if (fptr->common.prototype && fptr->common.prototype->common.scope) {
837: string_printf(str, ", prototype %s", fptr->common.prototype->common.scope->name);
838: }
839: if (fptr->common.fn_flags & ZEND_ACC_CTOR) {
840: string_printf(str, ", ctor");
841: }
842: if (fptr->common.fn_flags & ZEND_ACC_DTOR) {
843: string_printf(str, ", dtor");
844: }
845: string_printf(str, "> ");
846:
847: if (fptr->common.fn_flags & ZEND_ACC_ABSTRACT) {
848: string_printf(str, "abstract ");
849: }
850: if (fptr->common.fn_flags & ZEND_ACC_FINAL) {
851: string_printf(str, "final ");
852: }
853: if (fptr->common.fn_flags & ZEND_ACC_STATIC) {
854: string_printf(str, "static ");
855: }
856:
857: if (fptr->common.scope) {
858: /* These are mutually exclusive */
859: switch (fptr->common.fn_flags & ZEND_ACC_PPP_MASK) {
860: case ZEND_ACC_PUBLIC:
861: string_printf(str, "public ");
862: break;
863: case ZEND_ACC_PRIVATE:
864: string_printf(str, "private ");
865: break;
866: case ZEND_ACC_PROTECTED:
867: string_printf(str, "protected ");
868: break;
869: default:
870: string_printf(str, "<visibility error> ");
871: break;
872: }
873: string_printf(str, "method ");
874: } else {
875: string_printf(str, "function ");
876: }
877:
878: if (fptr->op_array.return_reference) {
879: string_printf(str, "&");
880: }
881: string_printf(str, "%s ] {\n", fptr->common.function_name);
882: /* The information where a function is declared is only available for user classes */
883: if (fptr->type == ZEND_USER_FUNCTION) {
884: string_printf(str, "%s @@ %s %d - %d\n", indent,
885: fptr->op_array.filename,
886: fptr->op_array.line_start,
887: fptr->op_array.line_end);
888: }
889: string_init(¶m_indent);
890: string_printf(¶m_indent, "%s ", indent);
891: if (fptr->common.fn_flags & ZEND_ACC_CLOSURE) {
892: _function_closure_string(str, fptr, param_indent.string TSRMLS_CC);
893: }
894: _function_parameter_string(str, fptr, param_indent.string TSRMLS_CC);
895: string_free(¶m_indent);
896: string_printf(str, "%s}\n", indent);
897: }
898: /* }}} */
899:
900: /* {{{ _property_string */
901: static void _property_string(string *str, zend_property_info *prop, char *prop_name, char* indent TSRMLS_DC)
902: {
903: char *class_name;
904:
905: string_printf(str, "%sProperty [ ", indent);
906: if (!prop) {
907: string_printf(str, "<dynamic> public $%s", prop_name);
908: } else {
909: if (!(prop->flags & ZEND_ACC_STATIC)) {
910: if (prop->flags & ZEND_ACC_IMPLICIT_PUBLIC) {
911: string_write(str, "<implicit> ", sizeof("<implicit> ") - 1);
912: } else {
913: string_write(str, "<default> ", sizeof("<default> ") - 1);
914: }
915: }
916:
917: /* These are mutually exclusive */
918: switch (prop->flags & ZEND_ACC_PPP_MASK) {
919: case ZEND_ACC_PUBLIC:
920: string_printf(str, "public ");
921: break;
922: case ZEND_ACC_PRIVATE:
923: string_printf(str, "private ");
924: break;
925: case ZEND_ACC_PROTECTED:
926: string_printf(str, "protected ");
927: break;
928: }
929: if(prop->flags & ZEND_ACC_STATIC) {
930: string_printf(str, "static ");
931: }
932:
933: zend_unmangle_property_name(prop->name, prop->name_length, &class_name, &prop_name);
934: string_printf(str, "$%s", prop_name);
935: }
936:
937: string_printf(str, " ]\n");
938: }
939: /* }}} */
940:
941: static int _extension_ini_string(zend_ini_entry *ini_entry TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
942: {
943: string *str = va_arg(args, string *);
944: char *indent = va_arg(args, char *);
945: int number = va_arg(args, int);
946: char *comma = "";
947:
948: if (number == ini_entry->module_number) {
949: string_printf(str, " %sEntry [ %s <", indent, ini_entry->name);
950: if (ini_entry->modifiable == ZEND_INI_ALL) {
951: string_printf(str, "ALL");
952: } else {
953: if (ini_entry->modifiable & ZEND_INI_USER) {
954: string_printf(str, "USER");
955: comma = ",";
956: }
957: if (ini_entry->modifiable & ZEND_INI_PERDIR) {
958: string_printf(str, "%sPERDIR", comma);
959: comma = ",";
960: }
961: if (ini_entry->modifiable & ZEND_INI_SYSTEM) {
962: string_printf(str, "%sSYSTEM", comma);
963: }
964: }
965:
966: string_printf(str, "> ]\n");
967: string_printf(str, " %s Current = '%s'\n", indent, ini_entry->value ? ini_entry->value : "");
968: if (ini_entry->modified) {
969: string_printf(str, " %s Default = '%s'\n", indent, ini_entry->orig_value ? ini_entry->orig_value : "");
970: }
971: string_printf(str, " %s}\n", indent);
972: }
973: return ZEND_HASH_APPLY_KEEP;
974: }
975:
976: static int _extension_class_string(zend_class_entry **pce TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
977: {
978: string *str = va_arg(args, string *);
979: char *indent = va_arg(args, char *);
980: struct _zend_module_entry *module = va_arg(args, struct _zend_module_entry*);
981: int *num_classes = va_arg(args, int*);
982:
983: if ((*pce)->module && !strcasecmp((*pce)->module->name, module->name)) {
984: string_printf(str, "\n");
985: _class_string(str, *pce, NULL, indent TSRMLS_CC);
986: (*num_classes)++;
987: }
988: return ZEND_HASH_APPLY_KEEP;
989: }
990:
991: static int _extension_const_string(zend_constant *constant TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
992: {
993: string *str = va_arg(args, string *);
994: char *indent = va_arg(args, char *);
995: struct _zend_module_entry *module = va_arg(args, struct _zend_module_entry*);
996: int *num_classes = va_arg(args, int*);
997:
998: if (constant->module_number == module->module_number) {
999: _const_string(str, constant->name, &constant->value, indent TSRMLS_CC);
1000: (*num_classes)++;
1001: }
1002: return ZEND_HASH_APPLY_KEEP;
1003: }
1004:
1005: /* {{{ _extension_string */
1006: static void _extension_string(string *str, zend_module_entry *module, char *indent TSRMLS_DC)
1007: {
1008: string_printf(str, "%sExtension [ ", indent);
1009: if (module->type == MODULE_PERSISTENT) {
1010: string_printf(str, "<persistent>");
1011: }
1012: if (module->type == MODULE_TEMPORARY) {
1013: string_printf(str, "<temporary>" );
1014: }
1015: string_printf(str, " extension #%d %s version %s ] {\n",
1016: module->module_number, module->name,
1017: (module->version == NO_VERSION_YET) ? "<no_version>" : module->version);
1018:
1019: if (module->deps) {
1020: const zend_module_dep* dep = module->deps;
1021:
1022: string_printf(str, "\n - Dependencies {\n");
1023:
1024: while(dep->name) {
1025: string_printf(str, "%s Dependency [ %s (", indent, dep->name);
1026:
1027: switch(dep->type) {
1028: case MODULE_DEP_REQUIRED:
1029: string_write(str, "Required", sizeof("Required") - 1);
1030: break;
1031: case MODULE_DEP_CONFLICTS:
1032: string_write(str, "Conflicts", sizeof("Conflicts") - 1);
1033: break;
1034: case MODULE_DEP_OPTIONAL:
1035: string_write(str, "Optional", sizeof("Optional") - 1);
1036: break;
1037: default:
1038: string_write(str, "Error", sizeof("Error") - 1); /* shouldn't happen */
1039: break;
1040: }
1041:
1042: if (dep->rel) {
1043: string_printf(str, " %s", dep->rel);
1044: }
1045: if (dep->version) {
1046: string_printf(str, " %s", dep->version);
1047: }
1048: string_write(str, ") ]\n", sizeof(") ]\n") - 1);
1049: dep++;
1050: }
1051: string_printf(str, "%s }\n", indent);
1052: }
1053:
1054: {
1055: string str_ini;
1056: string_init(&str_ini);
1057: zend_hash_apply_with_arguments(EG(ini_directives) TSRMLS_CC, (apply_func_args_t) _extension_ini_string, 3, &str_ini, indent, module->module_number);
1058: if (str_ini.len > 1) {
1059: string_printf(str, "\n - INI {\n");
1060: string_append(str, &str_ini);
1061: string_printf(str, "%s }\n", indent);
1062: }
1063: string_free(&str_ini);
1064: }
1065:
1066: {
1067: string str_constants;
1068: int num_constants = 0;
1069:
1070: string_init(&str_constants);
1071: zend_hash_apply_with_arguments(EG(zend_constants) TSRMLS_CC, (apply_func_args_t) _extension_const_string, 4, &str_constants, indent, module, &num_constants);
1072: if (num_constants) {
1073: string_printf(str, "\n - Constants [%d] {\n", num_constants);
1074: string_append(str, &str_constants);
1075: string_printf(str, "%s }\n", indent);
1076: }
1077: string_free(&str_constants);
1078: }
1079:
1080: if (module->functions && module->functions->fname) {
1081: zend_function *fptr;
1082: const zend_function_entry *func = module->functions;
1083:
1084: string_printf(str, "\n - Functions {\n");
1085:
1086: /* Is there a better way of doing this? */
1087: while (func->fname) {
1088: int fname_len = strlen(func->fname);
1089: char *lc_name = zend_str_tolower_dup(func->fname, fname_len);
1090:
1091: if (zend_hash_find(EG(function_table), lc_name, fname_len+1, (void**) &fptr) == FAILURE) {
1092: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Internal error: Cannot find extension function %s in global function table", func->fname);
1093: func++;
1094: efree(lc_name);
1095: continue;
1096: }
1097:
1098: _function_string(str, fptr, NULL, " " TSRMLS_CC);
1099: efree(lc_name);
1100: func++;
1101: }
1102: string_printf(str, "%s }\n", indent);
1103: }
1104:
1105: {
1106: string str_classes;
1107: string sub_indent;
1108: int num_classes = 0;
1109:
1110: string_init(&sub_indent);
1111: string_printf(&sub_indent, "%s ", indent);
1112: string_init(&str_classes);
1113: zend_hash_apply_with_arguments(EG(class_table) TSRMLS_CC, (apply_func_args_t) _extension_class_string, 4, &str_classes, sub_indent.string, module, &num_classes);
1114: if (num_classes) {
1115: string_printf(str, "\n - Classes [%d] {", num_classes);
1116: string_append(str, &str_classes);
1117: string_printf(str, "%s }\n", indent);
1118: }
1119: string_free(&str_classes);
1120: string_free(&sub_indent);
1121: }
1122:
1123: string_printf(str, "%s}\n", indent);
1124: }
1125: /* }}} */
1126:
1127: /* {{{ _function_check_flag */
1128: static void _function_check_flag(INTERNAL_FUNCTION_PARAMETERS, int mask)
1129: {
1130: reflection_object *intern;
1131: zend_function *mptr;
1132:
1133: if (zend_parse_parameters_none() == FAILURE) {
1134: return;
1135: }
1136: GET_REFLECTION_OBJECT_PTR(mptr);
1137: RETURN_BOOL(mptr->common.fn_flags & mask);
1138: }
1139: /* }}} */
1140:
1141: /* {{{ zend_reflection_class_factory */
1142: PHPAPI void zend_reflection_class_factory(zend_class_entry *ce, zval *object TSRMLS_DC)
1143: {
1144: reflection_object *intern;
1145: zval *name;
1146:
1147: MAKE_STD_ZVAL(name);
1148: ZVAL_STRINGL(name, ce->name, ce->name_length, 1);
1149: reflection_instantiate(reflection_class_ptr, object TSRMLS_CC);
1150: intern = (reflection_object *) zend_object_store_get_object(object TSRMLS_CC);
1151: intern->ptr = ce;
1152: intern->ref_type = REF_TYPE_OTHER;
1153: intern->ce = ce;
1154: zend_hash_update(Z_OBJPROP_P(object), "name", sizeof("name"), (void **) &name, sizeof(zval *), NULL);
1155: }
1156: /* }}} */
1157:
1158: /* {{{ reflection_extension_factory */
1159: static void reflection_extension_factory(zval *object, const char *name_str TSRMLS_DC)
1160: {
1161: reflection_object *intern;
1162: zval *name;
1163: int name_len = strlen(name_str);
1164: char *lcname;
1165: struct _zend_module_entry *module;
1166: ALLOCA_FLAG(use_heap)
1167:
1168: lcname = do_alloca(name_len + 1, use_heap);
1169: zend_str_tolower_copy(lcname, name_str, name_len);
1170: if (zend_hash_find(&module_registry, lcname, name_len + 1, (void **)&module) == FAILURE) {
1171: free_alloca(lcname, use_heap);
1172: return;
1173: }
1174: free_alloca(lcname, use_heap);
1175:
1176: reflection_instantiate(reflection_extension_ptr, object TSRMLS_CC);
1177: intern = (reflection_object *) zend_object_store_get_object(object TSRMLS_CC);
1178: MAKE_STD_ZVAL(name);
1179: ZVAL_STRINGL(name, module->name, name_len, 1);
1180: intern->ptr = module;
1181: intern->ref_type = REF_TYPE_OTHER;
1182: intern->ce = NULL;
1183: zend_hash_update(Z_OBJPROP_P(object), "name", sizeof("name"), (void **) &name, sizeof(zval *), NULL);
1184: }
1185: /* }}} */
1186:
1187: /* {{{ reflection_parameter_factory */
1188: static void reflection_parameter_factory(zend_function *fptr, zval *closure_object, struct _zend_arg_info *arg_info, zend_uint offset, zend_uint required, zval *object TSRMLS_DC)
1189: {
1190: reflection_object *intern;
1191: parameter_reference *reference;
1192: zval *name;
1193:
1194: if (closure_object) {
1195: Z_ADDREF_P(closure_object);
1196: }
1197: MAKE_STD_ZVAL(name);
1198: if (arg_info->name) {
1199: ZVAL_STRINGL(name, arg_info->name, arg_info->name_len, 1);
1200: } else {
1201: ZVAL_NULL(name);
1202: }
1203: reflection_instantiate(reflection_parameter_ptr, object TSRMLS_CC);
1204: intern = (reflection_object *) zend_object_store_get_object(object TSRMLS_CC);
1205: reference = (parameter_reference*) emalloc(sizeof(parameter_reference));
1206: reference->arg_info = arg_info;
1207: reference->offset = offset;
1208: reference->required = required;
1209: reference->fptr = fptr;
1210: intern->ptr = reference;
1211: intern->ref_type = REF_TYPE_PARAMETER;
1212: intern->ce = fptr->common.scope;
1213: intern->obj = closure_object;
1214: zend_hash_update(Z_OBJPROP_P(object), "name", sizeof("name"), (void **) &name, sizeof(zval *), NULL);
1215: }
1216: /* }}} */
1217:
1218: /* {{{ reflection_function_factory */
1219: static void reflection_function_factory(zend_function *function, zval *closure_object, zval *object TSRMLS_DC)
1220: {
1221: reflection_object *intern;
1222: zval *name;
1223:
1224: if (closure_object) {
1225: Z_ADDREF_P(closure_object);
1226: }
1227: MAKE_STD_ZVAL(name);
1228: ZVAL_STRING(name, function->common.function_name, 1);
1229:
1230: reflection_instantiate(reflection_function_ptr, object TSRMLS_CC);
1231: intern = (reflection_object *) zend_object_store_get_object(object TSRMLS_CC);
1232: intern->ptr = function;
1233: intern->ref_type = REF_TYPE_FUNCTION;
1234: intern->ce = NULL;
1235: intern->obj = closure_object;
1236: zend_hash_update(Z_OBJPROP_P(object), "name", sizeof("name"), (void **) &name, sizeof(zval *), NULL);
1237: }
1238: /* }}} */
1239:
1240: /* {{{ reflection_method_factory */
1241: static void reflection_method_factory(zend_class_entry *ce, zend_function *method, zval *closure_object, zval *object TSRMLS_DC)
1242: {
1243: reflection_object *intern;
1244: zval *name;
1245: zval *classname;
1246:
1247: if (closure_object) {
1248: Z_ADDREF_P(closure_object);
1249: }
1250: MAKE_STD_ZVAL(name);
1251: MAKE_STD_ZVAL(classname);
1252: ZVAL_STRING(name, method->common.function_name, 1);
1253: ZVAL_STRINGL(classname, method->common.scope->name, method->common.scope->name_length, 1);
1254: reflection_instantiate(reflection_method_ptr, object TSRMLS_CC);
1255: intern = (reflection_object *) zend_object_store_get_object(object TSRMLS_CC);
1256: intern->ptr = method;
1257: intern->ref_type = REF_TYPE_FUNCTION;
1258: intern->ce = ce;
1259: intern->obj = closure_object;
1260: zend_hash_update(Z_OBJPROP_P(object), "name", sizeof("name"), (void **) &name, sizeof(zval *), NULL);
1261: zend_hash_update(Z_OBJPROP_P(object), "class", sizeof("class"), (void **) &classname, sizeof(zval *), NULL);
1262: }
1263: /* }}} */
1264:
1265: /* {{{ reflection_property_factory */
1266: static void reflection_property_factory(zend_class_entry *ce, zend_property_info *prop, zval *object TSRMLS_DC)
1267: {
1268: reflection_object *intern;
1269: zval *name;
1270: zval *classname;
1271: property_reference *reference;
1272: char *class_name, *prop_name;
1273:
1274: zend_unmangle_property_name(prop->name, prop->name_length, &class_name, &prop_name);
1275:
1276: if (!(prop->flags & ZEND_ACC_PRIVATE)) {
1277: /* we have to search the class hierarchy for this (implicit) public or protected property */
1278: zend_class_entry *tmp_ce = ce, *store_ce = ce;
1279: zend_property_info *tmp_info = NULL;
1280:
1281: while (tmp_ce && zend_hash_find(&tmp_ce->properties_info, prop_name, strlen(prop_name) + 1, (void **) &tmp_info) != SUCCESS) {
1282: ce = tmp_ce;
1283: tmp_ce = tmp_ce->parent;
1284: }
1285:
1286: if (tmp_info && !(tmp_info->flags & ZEND_ACC_SHADOW)) { /* found something and it's not a parent's private */
1287: prop = tmp_info;
1288: } else { /* not found, use initial value */
1289: ce = store_ce;
1290: }
1291: }
1292:
1293: MAKE_STD_ZVAL(name);
1294: MAKE_STD_ZVAL(classname);
1295: ZVAL_STRING(name, prop_name, 1);
1296: ZVAL_STRINGL(classname, prop->ce->name, prop->ce->name_length, 1);
1297:
1298: reflection_instantiate(reflection_property_ptr, object TSRMLS_CC);
1299: intern = (reflection_object *) zend_object_store_get_object(object TSRMLS_CC);
1300: reference = (property_reference*) emalloc(sizeof(property_reference));
1301: reference->ce = ce;
1302: reference->prop = *prop;
1303: intern->ptr = reference;
1304: intern->ref_type = REF_TYPE_PROPERTY;
1305: intern->ce = ce;
1306: intern->ignore_visibility = 0;
1307: zend_hash_update(Z_OBJPROP_P(object), "name", sizeof("name"), (void **) &name, sizeof(zval *), NULL);
1308: zend_hash_update(Z_OBJPROP_P(object), "class", sizeof("class"), (void **) &classname, sizeof(zval *), NULL);
1309: }
1310: /* }}} */
1311:
1312: /* {{{ _reflection_export */
1313: static void _reflection_export(INTERNAL_FUNCTION_PARAMETERS, zend_class_entry *ce_ptr, int ctor_argc)
1314: {
1315: zval *reflector_ptr;
1316: zval output, *output_ptr = &output;
1317: zval *argument_ptr, *argument2_ptr;
1318: zval *retval_ptr, **params[2];
1319: int result;
1320: int return_output = 0;
1321: zend_fcall_info fci;
1322: zend_fcall_info_cache fcc;
1323: zval fname;
1324:
1325: if (ctor_argc == 1) {
1326: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|b", &argument_ptr, &return_output) == FAILURE) {
1327: return;
1328: }
1329: } else {
1330: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|b", &argument_ptr, &argument2_ptr, &return_output) == FAILURE) {
1331: return;
1332: }
1333: }
1334:
1335: INIT_PZVAL(&output);
1336:
1337: /* Create object */
1338: MAKE_STD_ZVAL(reflector_ptr);
1339: if (object_and_properties_init(reflector_ptr, ce_ptr, NULL) == FAILURE) {
1340: _DO_THROW("Could not create reflector");
1341: }
1342:
1343: /* Call __construct() */
1344: params[0] = &argument_ptr;
1345: params[1] = &argument2_ptr;
1346:
1347: fci.size = sizeof(fci);
1348: fci.function_table = NULL;
1349: fci.function_name = NULL;
1350: fci.symbol_table = NULL;
1351: fci.object_ptr = reflector_ptr;
1352: fci.retval_ptr_ptr = &retval_ptr;
1353: fci.param_count = ctor_argc;
1354: fci.params = params;
1355: fci.no_separation = 1;
1356:
1357: fcc.initialized = 1;
1358: fcc.function_handler = ce_ptr->constructor;
1359: fcc.calling_scope = ce_ptr;
1360: fcc.called_scope = Z_OBJCE_P(reflector_ptr);
1361: fcc.object_ptr = reflector_ptr;
1362:
1363: result = zend_call_function(&fci, &fcc TSRMLS_CC);
1364:
1365: if (retval_ptr) {
1366: zval_ptr_dtor(&retval_ptr);
1367: }
1368:
1369: if (EG(exception)) {
1370: zval_ptr_dtor(&reflector_ptr);
1371: return;
1372: }
1373: if (result == FAILURE) {
1374: zval_ptr_dtor(&reflector_ptr);
1375: _DO_THROW("Could not create reflector");
1376: }
1377:
1378: /* Call static reflection::export */
1379: ZVAL_BOOL(&output, return_output);
1380: params[0] = &reflector_ptr;
1381: params[1] = &output_ptr;
1382:
1383: ZVAL_STRINGL(&fname, "reflection::export", sizeof("reflection::export") - 1, 0);
1384: fci.function_table = &reflection_ptr->function_table;
1385: fci.function_name = &fname;
1386: fci.object_ptr = NULL;
1387: fci.retval_ptr_ptr = &retval_ptr;
1388: fci.param_count = 2;
1389: fci.params = params;
1390: fci.no_separation = 1;
1391:
1392: result = zend_call_function(&fci, NULL TSRMLS_CC);
1393:
1394: if (result == FAILURE && EG(exception) == NULL) {
1395: zval_ptr_dtor(&reflector_ptr);
1396: zval_ptr_dtor(&retval_ptr);
1397: _DO_THROW("Could not execute reflection::export()");
1398: }
1399:
1400: if (return_output) {
1401: COPY_PZVAL_TO_ZVAL(*return_value, retval_ptr);
1402: } else {
1403: zval_ptr_dtor(&retval_ptr);
1404: }
1405:
1406: /* Destruct reflector which is no longer needed */
1407: zval_ptr_dtor(&reflector_ptr);
1408: }
1409: /* }}} */
1410:
1411: /* {{{ Preventing __clone from being called */
1412: ZEND_METHOD(reflection, __clone)
1413: {
1414: /* Should never be executable */
1415: _DO_THROW("Cannot clone object using __clone()");
1416: }
1417: /* }}} */
1418:
1419: /* {{{ proto public static mixed Reflection::export(Reflector r [, bool return])
1420: Exports a reflection object. Returns the output if TRUE is specified for return, printing it otherwise. */
1421: ZEND_METHOD(reflection, export)
1422: {
1423: zval *object, fname, *retval_ptr;
1424: int result;
1425: zend_bool return_output = 0;
1426:
1427: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|b", &object, reflector_ptr, &return_output) == FAILURE) {
1428: return;
1429: }
1430:
1431: /* Invoke the __toString() method */
1432: ZVAL_STRINGL(&fname, "__tostring", sizeof("__tostring") - 1, 1);
1433: result= call_user_function_ex(NULL, &object, &fname, &retval_ptr, 0, NULL, 0, NULL TSRMLS_CC);
1434: zval_dtor(&fname);
1435:
1436: if (result == FAILURE) {
1437: _DO_THROW("Invocation of method __toString() failed");
1438: /* Returns from this function */
1439: }
1440:
1441: if (!retval_ptr) {
1442: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::__toString() did not return anything", Z_OBJCE_P(object)->name);
1443: RETURN_FALSE;
1444: }
1445:
1446: if (return_output) {
1447: COPY_PZVAL_TO_ZVAL(*return_value, retval_ptr);
1448: } else {
1449: /* No need for _r variant, return of __toString should always be a string */
1450: zend_print_zval(retval_ptr, 0);
1451: zend_printf("\n");
1452: zval_ptr_dtor(&retval_ptr);
1453: }
1454: }
1455: /* }}} */
1456:
1457: /* {{{ proto public static array Reflection::getModifierNames(int modifiers)
1458: Returns an array of modifier names */
1459: ZEND_METHOD(reflection, getModifierNames)
1460: {
1461: long modifiers;
1462:
1463: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &modifiers) == FAILURE) {
1464: return;
1465: }
1466:
1467: array_init(return_value);
1468:
1469: if (modifiers & (ZEND_ACC_ABSTRACT | ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) {
1470: add_next_index_stringl(return_value, "abstract", sizeof("abstract")-1, 1);
1471: }
1472: if (modifiers & (ZEND_ACC_FINAL | ZEND_ACC_FINAL_CLASS)) {
1473: add_next_index_stringl(return_value, "final", sizeof("final")-1, 1);
1474: }
1475: if (modifiers & ZEND_ACC_IMPLICIT_PUBLIC) {
1476: add_next_index_stringl(return_value, "public", sizeof("public")-1, 1);
1477: }
1478:
1479: /* These are mutually exclusive */
1480: switch (modifiers & ZEND_ACC_PPP_MASK) {
1481: case ZEND_ACC_PUBLIC:
1482: add_next_index_stringl(return_value, "public", sizeof("public")-1, 1);
1483: break;
1484: case ZEND_ACC_PRIVATE:
1485: add_next_index_stringl(return_value, "private", sizeof("private")-1, 1);
1486: break;
1487: case ZEND_ACC_PROTECTED:
1488: add_next_index_stringl(return_value, "protected", sizeof("protected")-1, 1);
1489: break;
1490: }
1491:
1492: if (modifiers & ZEND_ACC_STATIC) {
1493: add_next_index_stringl(return_value, "static", sizeof("static")-1, 1);
1494: }
1495: }
1496: /* }}} */
1497:
1498: /* {{{ proto public static mixed ReflectionFunction::export(string name [, bool return])
1499: Exports a reflection object. Returns the output if TRUE is specified for return, printing it otherwise. */
1500: ZEND_METHOD(reflection_function, export)
1501: {
1502: _reflection_export(INTERNAL_FUNCTION_PARAM_PASSTHRU, reflection_function_ptr, 1);
1503: }
1504: /* }}} */
1505:
1506: /* {{{ proto public void ReflectionFunction::__construct(string name)
1507: Constructor. Throws an Exception in case the given function does not exist */
1508: ZEND_METHOD(reflection_function, __construct)
1509: {
1510: zval *name;
1511: zval *object;
1512: zval *closure = NULL;
1513: char *lcname;
1514: reflection_object *intern;
1515: zend_function *fptr;
1516: char *name_str;
1517: int name_len;
1518:
1519: object = getThis();
1520: intern = (reflection_object *) zend_object_store_get_object(object TSRMLS_CC);
1521: if (intern == NULL) {
1522: return;
1523: }
1524:
1525: if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "O", &closure, zend_ce_closure) == SUCCESS) {
1526: fptr = (zend_function*)zend_get_closure_method_def(closure TSRMLS_CC);
1527: Z_ADDREF_P(closure);
1528: } else if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name_str, &name_len) == SUCCESS) {
1529: char *nsname;
1530:
1531: lcname = zend_str_tolower_dup(name_str, name_len);
1532:
1533: /* Ignore leading "\" */
1534: nsname = lcname;
1535: if (lcname[0] == '\\') {
1536: nsname = &lcname[1];
1537: name_len--;
1538: }
1539:
1540: if (zend_hash_find(EG(function_table), nsname, name_len + 1, (void **)&fptr) == FAILURE) {
1541: efree(lcname);
1542: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
1543: "Function %s() does not exist", name_str);
1544: return;
1545: }
1546: efree(lcname);
1547: } else {
1548: return;
1549: }
1550:
1551: MAKE_STD_ZVAL(name);
1552: ZVAL_STRING(name, fptr->common.function_name, 1);
1553: zend_hash_update(Z_OBJPROP_P(object), "name", sizeof("name"), (void **) &name, sizeof(zval *), NULL);
1554: intern->ptr = fptr;
1555: intern->ref_type = REF_TYPE_FUNCTION;
1556: intern->obj = closure;
1557: intern->ce = NULL;
1558: }
1559: /* }}} */
1560:
1561: /* {{{ proto public string ReflectionFunction::__toString()
1562: Returns a string representation */
1563: ZEND_METHOD(reflection_function, __toString)
1564: {
1565: reflection_object *intern;
1566: zend_function *fptr;
1567: string str;
1568:
1569: if (zend_parse_parameters_none() == FAILURE) {
1570: return;
1571: }
1572: GET_REFLECTION_OBJECT_PTR(fptr);
1573: string_init(&str);
1574: _function_string(&str, fptr, intern->ce, "" TSRMLS_CC);
1575: RETURN_STRINGL(str.string, str.len - 1, 0);
1576: }
1577: /* }}} */
1578:
1579: /* {{{ proto public string ReflectionFunction::getName()
1580: Returns this function's name */
1581: ZEND_METHOD(reflection_function, getName)
1582: {
1583: if (zend_parse_parameters_none() == FAILURE) {
1584: return;
1585: }
1586: _default_get_entry(getThis(), "name", sizeof("name"), return_value TSRMLS_CC);
1587: }
1588: /* }}} */
1589:
1590: /* {{{ proto public bool ReflectionFunction::isClosure()
1591: Returns whether this is a closure */
1592: ZEND_METHOD(reflection_function, isClosure)
1593: {
1594: reflection_object *intern;
1595: zend_function *fptr;
1596:
1597: if (zend_parse_parameters_none() == FAILURE) {
1598: return;
1599: }
1600: GET_REFLECTION_OBJECT_PTR(fptr);
1601: RETURN_BOOL(fptr->common.fn_flags & ZEND_ACC_CLOSURE);
1602: }
1603: /* }}} */
1604:
1605: /* {{{ proto public bool ReflectionFunction::isInternal()
1606: Returns whether this is an internal function */
1607: ZEND_METHOD(reflection_function, isInternal)
1608: {
1609: reflection_object *intern;
1610: zend_function *fptr;
1611:
1612: if (zend_parse_parameters_none() == FAILURE) {
1613: return;
1614: }
1615: GET_REFLECTION_OBJECT_PTR(fptr);
1616: RETURN_BOOL(fptr->type == ZEND_INTERNAL_FUNCTION);
1617: }
1618: /* }}} */
1619:
1620: /* {{{ proto public bool ReflectionFunction::isUserDefined()
1621: Returns whether this is an user-defined function */
1622: ZEND_METHOD(reflection_function, isUserDefined)
1623: {
1624: reflection_object *intern;
1625: zend_function *fptr;
1626:
1627: if (zend_parse_parameters_none() == FAILURE) {
1628: return;
1629: }
1630: GET_REFLECTION_OBJECT_PTR(fptr);
1631: RETURN_BOOL(fptr->type == ZEND_USER_FUNCTION);
1632: }
1633: /* }}} */
1634:
1635: /* {{{ proto public bool ReflectionFunction::isDisabled()
1636: Returns whether this function has been disabled or not */
1637: ZEND_METHOD(reflection_function, isDisabled)
1638: {
1639: reflection_object *intern;
1640: zend_function *fptr;
1641:
1642: METHOD_NOTSTATIC(reflection_function_ptr);
1643: GET_REFLECTION_OBJECT_PTR(fptr);
1644: RETURN_BOOL(fptr->type == ZEND_INTERNAL_FUNCTION && fptr->internal_function.handler == zif_display_disabled_function);
1645: }
1646: /* }}} */
1647:
1648: /* {{{ proto public string ReflectionFunction::getFileName()
1649: Returns the filename of the file this function was declared in */
1650: ZEND_METHOD(reflection_function, getFileName)
1651: {
1652: reflection_object *intern;
1653: zend_function *fptr;
1654:
1655: if (zend_parse_parameters_none() == FAILURE) {
1656: return;
1657: }
1658: GET_REFLECTION_OBJECT_PTR(fptr);
1659: if (fptr->type == ZEND_USER_FUNCTION) {
1660: RETURN_STRING(fptr->op_array.filename, 1);
1661: }
1662: RETURN_FALSE;
1663: }
1664: /* }}} */
1665:
1666: /* {{{ proto public int ReflectionFunction::getStartLine()
1667: Returns the line this function's declaration starts at */
1668: ZEND_METHOD(reflection_function, getStartLine)
1669: {
1670: reflection_object *intern;
1671: zend_function *fptr;
1672:
1673: if (zend_parse_parameters_none() == FAILURE) {
1674: return;
1675: }
1676: GET_REFLECTION_OBJECT_PTR(fptr);
1677: if (fptr->type == ZEND_USER_FUNCTION) {
1678: RETURN_LONG(fptr->op_array.line_start);
1679: }
1680: RETURN_FALSE;
1681: }
1682: /* }}} */
1683:
1684: /* {{{ proto public int ReflectionFunction::getEndLine()
1685: Returns the line this function's declaration ends at */
1686: ZEND_METHOD(reflection_function, getEndLine)
1687: {
1688: reflection_object *intern;
1689: zend_function *fptr;
1690:
1691: if (zend_parse_parameters_none() == FAILURE) {
1692: return;
1693: }
1694: GET_REFLECTION_OBJECT_PTR(fptr);
1695: if (fptr->type == ZEND_USER_FUNCTION) {
1696: RETURN_LONG(fptr->op_array.line_end);
1697: }
1698: RETURN_FALSE;
1699: }
1700: /* }}} */
1701:
1702: /* {{{ proto public string ReflectionFunction::getDocComment()
1703: Returns the doc comment for this function */
1704: ZEND_METHOD(reflection_function, getDocComment)
1705: {
1706: reflection_object *intern;
1707: zend_function *fptr;
1708:
1709: if (zend_parse_parameters_none() == FAILURE) {
1710: return;
1711: }
1712: GET_REFLECTION_OBJECT_PTR(fptr);
1713: if (fptr->type == ZEND_USER_FUNCTION && fptr->op_array.doc_comment) {
1714: RETURN_STRINGL(fptr->op_array.doc_comment, fptr->op_array.doc_comment_len, 1);
1715: }
1716: RETURN_FALSE;
1717: }
1718: /* }}} */
1719:
1720: /* {{{ proto public array ReflectionFunction::getStaticVariables()
1721: Returns an associative array containing this function's static variables and their values */
1722: ZEND_METHOD(reflection_function, getStaticVariables)
1723: {
1724: zval *tmp_copy;
1725: reflection_object *intern;
1726: zend_function *fptr;
1727:
1728: if (zend_parse_parameters_none() == FAILURE) {
1729: return;
1730: }
1731: GET_REFLECTION_OBJECT_PTR(fptr);
1732:
1733: /* Return an empty array in case no static variables exist */
1734: array_init(return_value);
1735: if (fptr->type == ZEND_USER_FUNCTION && fptr->op_array.static_variables != NULL) {
1736: zend_hash_apply_with_argument(fptr->op_array.static_variables, (apply_func_arg_t) zval_update_constant, (void*)1 TSRMLS_CC);
1737: zend_hash_copy(Z_ARRVAL_P(return_value), fptr->op_array.static_variables, (copy_ctor_func_t) zval_add_ref, (void *) &tmp_copy, sizeof(zval *));
1738: }
1739: }
1740: /* }}} */
1741:
1742: /* {{{ proto public mixed ReflectionFunction::invoke([mixed* args])
1743: Invokes the function */
1744: ZEND_METHOD(reflection_function, invoke)
1745: {
1746: zval *retval_ptr;
1747: zval ***params = NULL;
1748: int result, num_args = 0;
1749: zend_fcall_info fci;
1750: zend_fcall_info_cache fcc;
1751: reflection_object *intern;
1752: zend_function *fptr;
1753:
1754: METHOD_NOTSTATIC(reflection_function_ptr);
1755: GET_REFLECTION_OBJECT_PTR(fptr);
1756:
1757: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "*", ¶ms, &num_args) == FAILURE) {
1758: return;
1759: }
1760:
1761: fci.size = sizeof(fci);
1762: fci.function_table = NULL;
1763: fci.function_name = NULL;
1764: fci.symbol_table = NULL;
1765: fci.object_ptr = NULL;
1766: fci.retval_ptr_ptr = &retval_ptr;
1767: fci.param_count = num_args;
1768: fci.params = params;
1769: fci.no_separation = 1;
1770:
1771: fcc.initialized = 1;
1772: fcc.function_handler = fptr;
1773: fcc.calling_scope = EG(scope);
1774: fcc.called_scope = NULL;
1775: fcc.object_ptr = NULL;
1776:
1777: result = zend_call_function(&fci, &fcc TSRMLS_CC);
1778:
1779: if (num_args) {
1780: efree(params);
1781: }
1782:
1783: if (result == FAILURE) {
1784: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
1785: "Invocation of function %s() failed", fptr->common.function_name);
1786: return;
1787: }
1788:
1789: if (retval_ptr) {
1790: COPY_PZVAL_TO_ZVAL(*return_value, retval_ptr);
1791: }
1792: }
1793: /* }}} */
1794:
1795: static int _zval_array_to_c_array(zval **arg, zval ****params TSRMLS_DC) /* {{{ */
1796: {
1797: *(*params)++ = arg;
1798: return ZEND_HASH_APPLY_KEEP;
1799: } /* }}} */
1800:
1801: /* {{{ proto public mixed ReflectionFunction::invokeArgs(array args)
1802: Invokes the function and pass its arguments as array. */
1803: ZEND_METHOD(reflection_function, invokeArgs)
1804: {
1805: zval *retval_ptr;
1806: zval ***params;
1807: int result;
1808: int argc;
1809: zend_fcall_info fci;
1810: zend_fcall_info_cache fcc;
1811: reflection_object *intern;
1812: zend_function *fptr;
1813: zval *param_array;
1814:
1815: METHOD_NOTSTATIC(reflection_function_ptr);
1816: GET_REFLECTION_OBJECT_PTR(fptr);
1817:
1818: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", ¶m_array) == FAILURE) {
1819: return;
1820: }
1821:
1822: argc = zend_hash_num_elements(Z_ARRVAL_P(param_array));
1823:
1824: params = safe_emalloc(sizeof(zval **), argc, 0);
1825: zend_hash_apply_with_argument(Z_ARRVAL_P(param_array), (apply_func_arg_t)_zval_array_to_c_array, ¶ms TSRMLS_CC);
1826: params -= argc;
1827:
1828: fci.size = sizeof(fci);
1829: fci.function_table = NULL;
1830: fci.function_name = NULL;
1831: fci.symbol_table = NULL;
1832: fci.object_ptr = NULL;
1833: fci.retval_ptr_ptr = &retval_ptr;
1834: fci.param_count = argc;
1835: fci.params = params;
1836: fci.no_separation = 1;
1837:
1838: fcc.initialized = 1;
1839: fcc.function_handler = fptr;
1840: fcc.calling_scope = EG(scope);
1841: fcc.called_scope = NULL;
1842: fcc.object_ptr = NULL;
1843:
1844: result = zend_call_function(&fci, &fcc TSRMLS_CC);
1845:
1846: efree(params);
1847:
1848: if (result == FAILURE) {
1849: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
1850: "Invocation of function %s() failed", fptr->common.function_name);
1851: return;
1852: }
1853:
1854: if (retval_ptr) {
1855: COPY_PZVAL_TO_ZVAL(*return_value, retval_ptr);
1856: }
1857: }
1858: /* }}} */
1859:
1860: /* {{{ proto public bool ReflectionFunction::returnsReference()
1861: Gets whether this function returns a reference */
1862: ZEND_METHOD(reflection_function, returnsReference)
1863: {
1864: reflection_object *intern;
1865: zend_function *fptr;
1866:
1867: METHOD_NOTSTATIC(reflection_function_abstract_ptr);
1868: GET_REFLECTION_OBJECT_PTR(fptr);
1869:
1870: RETURN_BOOL(fptr->op_array.return_reference);
1871: }
1872: /* }}} */
1873:
1874: /* {{{ proto public bool ReflectionFunction::getNumberOfParameters()
1875: Gets the number of required parameters */
1876: ZEND_METHOD(reflection_function, getNumberOfParameters)
1877: {
1878: reflection_object *intern;
1879: zend_function *fptr;
1880:
1881: METHOD_NOTSTATIC(reflection_function_abstract_ptr);
1882: GET_REFLECTION_OBJECT_PTR(fptr);
1883:
1884: RETURN_LONG(fptr->common.num_args);
1885: }
1886: /* }}} */
1887:
1888: /* {{{ proto public bool ReflectionFunction::getNumberOfRequiredParameters()
1889: Gets the number of required parameters */
1890: ZEND_METHOD(reflection_function, getNumberOfRequiredParameters)
1891: {
1892: reflection_object *intern;
1893: zend_function *fptr;
1894:
1895: METHOD_NOTSTATIC(reflection_function_abstract_ptr);
1896: GET_REFLECTION_OBJECT_PTR(fptr);
1897:
1898: RETURN_LONG(fptr->common.required_num_args);
1899: }
1900: /* }}} */
1901:
1902: /* {{{ proto public ReflectionParameter[] ReflectionFunction::getParameters()
1903: Returns an array of parameter objects for this function */
1904: ZEND_METHOD(reflection_function, getParameters)
1905: {
1906: reflection_object *intern;
1907: zend_function *fptr;
1908: zend_uint i;
1909: struct _zend_arg_info *arg_info;
1910:
1911: METHOD_NOTSTATIC(reflection_function_abstract_ptr);
1912: GET_REFLECTION_OBJECT_PTR(fptr);
1913:
1914: arg_info= fptr->common.arg_info;
1915:
1916: array_init(return_value);
1917: for (i = 0; i < fptr->common.num_args; i++) {
1918: zval *parameter;
1919:
1920: ALLOC_ZVAL(parameter);
1921: reflection_parameter_factory(_copy_function(fptr TSRMLS_CC), intern->obj, arg_info, i, fptr->common.required_num_args, parameter TSRMLS_CC);
1922: add_next_index_zval(return_value, parameter);
1923:
1924: arg_info++;
1925: }
1926: }
1927: /* }}} */
1928:
1929: /* {{{ proto public ReflectionExtension|NULL ReflectionFunction::getExtension()
1930: Returns NULL or the extension the function belongs to */
1931: ZEND_METHOD(reflection_function, getExtension)
1932: {
1933: reflection_object *intern;
1934: zend_function *fptr;
1935: zend_internal_function *internal;
1936:
1937: METHOD_NOTSTATIC(reflection_function_abstract_ptr);
1938: GET_REFLECTION_OBJECT_PTR(fptr);
1939:
1940: if (fptr->type != ZEND_INTERNAL_FUNCTION) {
1941: RETURN_NULL();
1942: }
1943:
1944: internal = (zend_internal_function *)fptr;
1945: if (internal->module) {
1946: reflection_extension_factory(return_value, internal->module->name TSRMLS_CC);
1947: } else {
1948: RETURN_NULL();
1949: }
1950: }
1951: /* }}} */
1952:
1953: /* {{{ proto public string|false ReflectionFunction::getExtensionName()
1954: Returns false or the name of the extension the function belongs to */
1955: ZEND_METHOD(reflection_function, getExtensionName)
1956: {
1957: reflection_object *intern;
1958: zend_function *fptr;
1959: zend_internal_function *internal;
1960:
1961: METHOD_NOTSTATIC(reflection_function_abstract_ptr);
1962: GET_REFLECTION_OBJECT_PTR(fptr);
1963:
1964: if (fptr->type != ZEND_INTERNAL_FUNCTION) {
1965: RETURN_FALSE;
1966: }
1967:
1968: internal = (zend_internal_function *)fptr;
1969: if (internal->module) {
1970: RETURN_STRING(internal->module->name, 1);
1971: } else {
1972: RETURN_FALSE;
1973: }
1974: }
1975: /* }}} */
1976:
1977: /* {{{ proto public static mixed ReflectionParameter::export(mixed function, mixed parameter [, bool return]) throws ReflectionException
1978: Exports a reflection object. Returns the output if TRUE is specified for return, printing it otherwise. */
1979: ZEND_METHOD(reflection_parameter, export)
1980: {
1981: _reflection_export(INTERNAL_FUNCTION_PARAM_PASSTHRU, reflection_parameter_ptr, 2);
1982: }
1983: /* }}} */
1984:
1985: /* {{{ proto public void ReflectionParameter::__construct(mixed function, mixed parameter)
1986: Constructor. Throws an Exception in case the given method does not exist */
1987: ZEND_METHOD(reflection_parameter, __construct)
1988: {
1989: parameter_reference *ref;
1990: zval *reference, **parameter;
1991: zval *object;
1992: zval *name;
1993: reflection_object *intern;
1994: zend_function *fptr;
1995: struct _zend_arg_info *arg_info;
1996: int position;
1997: zend_class_entry *ce = NULL;
1998: zend_bool is_closure = 0;
1999:
2000: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zZ", &reference, ¶meter) == FAILURE) {
2001: return;
2002: }
2003:
2004: object = getThis();
2005: intern = (reflection_object *) zend_object_store_get_object(object TSRMLS_CC);
2006: if (intern == NULL) {
2007: return;
2008: }
2009:
2010: /* First, find the function */
2011: switch (Z_TYPE_P(reference)) {
2012: case IS_STRING: {
2013: unsigned int lcname_len;
2014: char *lcname;
2015:
2016: lcname_len = Z_STRLEN_P(reference);
2017: lcname = zend_str_tolower_dup(Z_STRVAL_P(reference), lcname_len);
2018: if (zend_hash_find(EG(function_table), lcname, lcname_len + 1, (void**) &fptr) == FAILURE) {
2019: efree(lcname);
2020: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
2021: "Function %s() does not exist", Z_STRVAL_P(reference));
2022: return;
2023: }
2024: efree(lcname);
2025: }
2026: ce = fptr->common.scope;
2027: break;
2028:
2029: case IS_ARRAY: {
2030: zval **classref;
2031: zval **method;
2032: zend_class_entry **pce;
2033: unsigned int lcname_len;
2034: char *lcname;
2035:
2036: if ((zend_hash_index_find(Z_ARRVAL_P(reference), 0, (void **) &classref) == FAILURE)
2037: || (zend_hash_index_find(Z_ARRVAL_P(reference), 1, (void **) &method) == FAILURE))
2038: {
2039: _DO_THROW("Expected array($object, $method) or array($classname, $method)");
2040: /* returns out of this function */
2041: }
2042:
2043: if (Z_TYPE_PP(classref) == IS_OBJECT) {
2044: ce = Z_OBJCE_PP(classref);
2045: } else {
2046: convert_to_string_ex(classref);
2047: if (zend_lookup_class(Z_STRVAL_PP(classref), Z_STRLEN_PP(classref), &pce TSRMLS_CC) == FAILURE) {
2048: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
2049: "Class %s does not exist", Z_STRVAL_PP(classref));
2050: return;
2051: }
2052: ce = *pce;
2053: }
2054:
2055: convert_to_string_ex(method);
2056: lcname_len = Z_STRLEN_PP(method);
2057: lcname = zend_str_tolower_dup(Z_STRVAL_PP(method), lcname_len);
2058: if (ce == zend_ce_closure && Z_TYPE_PP(classref) == IS_OBJECT
2059: && (lcname_len == sizeof(ZEND_INVOKE_FUNC_NAME)-1)
2060: && memcmp(lcname, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1) == 0
2061: && (fptr = zend_get_closure_invoke_method(*classref TSRMLS_CC)) != NULL)
2062: {
2063: /* nothign to do. don't set is_closure since is the invoke handler,
2064: not the closure itself */
2065: } else if (zend_hash_find(&ce->function_table, lcname, lcname_len + 1, (void **) &fptr) == FAILURE) {
2066: efree(lcname);
2067: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
2068: "Method %s::%s() does not exist", ce->name, Z_STRVAL_PP(method));
2069: return;
2070: }
2071: efree(lcname);
2072: }
2073: break;
2074:
2075: case IS_OBJECT: {
2076: ce = Z_OBJCE_P(reference);
2077:
2078: if (instanceof_function(ce, zend_ce_closure TSRMLS_CC)) {
2079: fptr = (zend_function *)zend_get_closure_method_def(reference TSRMLS_CC);
2080: Z_ADDREF_P(reference);
2081: is_closure = 1;
2082: } else if (zend_hash_find(&ce->function_table, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME), (void **)&fptr) == FAILURE) {
2083: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
2084: "Method %s::%s() does not exist", ce->name, ZEND_INVOKE_FUNC_NAME);
2085: return;
2086: }
2087: }
2088: break;
2089:
2090: default:
2091: _DO_THROW("The parameter class is expected to be either a string, an array(class, method) or a callable object");
2092: /* returns out of this function */
2093: }
2094:
2095: /* Now, search for the parameter */
2096: arg_info = fptr->common.arg_info;
2097: if (Z_TYPE_PP(parameter) == IS_LONG) {
2098: position= Z_LVAL_PP(parameter);
2099: if (position < 0 || (zend_uint)position >= fptr->common.num_args) {
2100: if (fptr->common.fn_flags & ZEND_ACC_CALL_VIA_HANDLER) {
2101: if (fptr->type != ZEND_OVERLOADED_FUNCTION) {
2102: efree(fptr->common.function_name);
2103: }
2104: efree(fptr);
2105: }
2106: if (is_closure) {
2107: zval_ptr_dtor(&reference);
2108: }
2109: _DO_THROW("The parameter specified by its offset could not be found");
2110: /* returns out of this function */
2111: }
2112: } else {
2113: zend_uint i;
2114:
2115: position= -1;
2116: convert_to_string_ex(parameter);
2117: for (i = 0; i < fptr->common.num_args; i++) {
2118: if (arg_info[i].name && strcmp(arg_info[i].name, Z_STRVAL_PP(parameter)) == 0) {
2119: position= i;
2120: break;
2121: }
2122: }
2123: if (position == -1) {
2124: if (fptr->common.fn_flags & ZEND_ACC_CALL_VIA_HANDLER) {
2125: if (fptr->type != ZEND_OVERLOADED_FUNCTION) {
2126: efree(fptr->common.function_name);
2127: }
2128: efree(fptr);
2129: }
2130: if (is_closure) {
2131: zval_ptr_dtor(&reference);
2132: }
2133: _DO_THROW("The parameter specified by its name could not be found");
2134: /* returns out of this function */
2135: }
2136: }
2137:
2138: MAKE_STD_ZVAL(name);
2139: if (arg_info[position].name) {
2140: ZVAL_STRINGL(name, arg_info[position].name, arg_info[position].name_len, 1);
2141: } else {
2142: ZVAL_NULL(name);
2143: }
2144: zend_hash_update(Z_OBJPROP_P(object), "name", sizeof("name"), (void **) &name, sizeof(zval *), NULL);
2145:
2146: ref = (parameter_reference*) emalloc(sizeof(parameter_reference));
2147: ref->arg_info = &arg_info[position];
2148: ref->offset = (zend_uint)position;
2149: ref->required = fptr->common.required_num_args;
2150: ref->fptr = fptr;
2151: /* TODO: copy fptr */
2152: intern->ptr = ref;
2153: intern->ref_type = REF_TYPE_PARAMETER;
2154: intern->ce = ce;
2155: if (reference && is_closure) {
2156: intern->obj = reference;
2157: }
2158: }
2159: /* }}} */
2160:
2161: /* {{{ proto public string ReflectionParameter::__toString()
2162: Returns a string representation */
2163: ZEND_METHOD(reflection_parameter, __toString)
2164: {
2165: reflection_object *intern;
2166: parameter_reference *param;
2167: string str;
2168:
2169: if (zend_parse_parameters_none() == FAILURE) {
2170: return;
2171: }
2172: GET_REFLECTION_OBJECT_PTR(param);
2173: string_init(&str);
2174: _parameter_string(&str, param->fptr, param->arg_info, param->offset, param->required, "" TSRMLS_CC);
2175: RETURN_STRINGL(str.string, str.len - 1, 0);
2176: }
2177: /* }}} */
2178:
2179: /* {{{ proto public string ReflectionParameter::getName()
2180: Returns this parameters's name */
2181: ZEND_METHOD(reflection_parameter, getName)
2182: {
2183: if (zend_parse_parameters_none() == FAILURE) {
2184: return;
2185: }
2186: _default_get_entry(getThis(), "name", sizeof("name"), return_value TSRMLS_CC);
2187: }
2188: /* }}} */
2189:
2190: /* {{{ proto public ReflectionFunction ReflectionParameter::getDeclaringFunction()
2191: Returns the ReflectionFunction for the function of this parameter */
2192: ZEND_METHOD(reflection_parameter, getDeclaringFunction)
2193: {
2194: reflection_object *intern;
2195: parameter_reference *param;
2196:
2197: if (zend_parse_parameters_none() == FAILURE) {
2198: return;
2199: }
2200: GET_REFLECTION_OBJECT_PTR(param);
2201:
2202: if (!param->fptr->common.scope) {
2203: reflection_function_factory(_copy_function(param->fptr TSRMLS_CC), intern->obj, return_value TSRMLS_CC);
2204: } else {
2205: reflection_method_factory(param->fptr->common.scope, _copy_function(param->fptr TSRMLS_CC), intern->obj, return_value TSRMLS_CC);
2206: }
2207: }
2208: /* }}} */
2209:
2210: /* {{{ proto public ReflectionClass|NULL ReflectionParameter::getDeclaringClass()
2211: Returns in which class this parameter is defined (not the typehint of the parameter) */
2212: ZEND_METHOD(reflection_parameter, getDeclaringClass)
2213: {
2214: reflection_object *intern;
2215: parameter_reference *param;
2216:
2217: if (zend_parse_parameters_none() == FAILURE) {
2218: return;
2219: }
2220: GET_REFLECTION_OBJECT_PTR(param);
2221:
2222: if (param->fptr->common.scope) {
2223: zend_reflection_class_factory(param->fptr->common.scope, return_value TSRMLS_CC);
2224: }
2225: }
2226: /* }}} */
2227:
2228: /* {{{ proto public ReflectionClass|NULL ReflectionParameter::getClass()
2229: Returns this parameters's class hint or NULL if there is none */
2230: ZEND_METHOD(reflection_parameter, getClass)
2231: {
2232: reflection_object *intern;
2233: parameter_reference *param;
2234: zend_class_entry **pce, *ce;
2235:
2236: if (zend_parse_parameters_none() == FAILURE) {
2237: return;
2238: }
2239: GET_REFLECTION_OBJECT_PTR(param);
2240:
2241: if (param->arg_info->class_name) {
2242: /* Class name is stored as a string, we might also get "self" or "parent"
2243: * - For "self", simply use the function scope. If scope is NULL then
2244: * the function is global and thus self does not make any sense
2245: *
2246: * - For "parent", use the function scope's parent. If scope is NULL then
2247: * the function is global and thus parent does not make any sense.
2248: * If the parent is NULL then the class does not extend anything and
2249: * thus parent does not make any sense, either.
2250: *
2251: * TODO: Think about moving these checks to the compiler or some sort of
2252: * lint-mode.
2253: */
2254: if (0 == strncmp(param->arg_info->class_name, "self", sizeof("self")- 1)) {
2255: ce = param->fptr->common.scope;
2256: if (!ce) {
2257: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
2258: "Parameter uses 'self' as type hint but function is not a class member!");
2259: return;
2260: }
2261: pce= &ce;
2262: } else if (0 == strncmp(param->arg_info->class_name, "parent", sizeof("parent")- 1)) {
2263: ce = param->fptr->common.scope;
2264: if (!ce) {
2265: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
2266: "Parameter uses 'parent' as type hint but function is not a class member!");
2267: return;
2268: }
2269: if (!ce->parent) {
2270: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
2271: "Parameter uses 'parent' as type hint although class does not have a parent!");
2272: return;
2273: }
2274: pce= &ce->parent;
2275: } else if (zend_lookup_class(param->arg_info->class_name, param->arg_info->class_name_len, &pce TSRMLS_CC) == FAILURE) {
2276: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
2277: "Class %s does not exist", param->arg_info->class_name);
2278: return;
2279: }
2280: zend_reflection_class_factory(*pce, return_value TSRMLS_CC);
2281: }
2282: }
2283: /* }}} */
2284:
2285: /* {{{ proto public bool ReflectionParameter::isArray()
2286: Returns whether parameter MUST be an array */
2287: ZEND_METHOD(reflection_parameter, isArray)
2288: {
2289: reflection_object *intern;
2290: parameter_reference *param;
2291:
2292: if (zend_parse_parameters_none() == FAILURE) {
2293: return;
2294: }
2295: GET_REFLECTION_OBJECT_PTR(param);
2296:
2297: RETVAL_BOOL(param->arg_info->array_type_hint);
2298: }
2299: /* }}} */
2300:
2301: /* {{{ proto public bool ReflectionParameter::allowsNull()
2302: Returns whether NULL is allowed as this parameters's value */
2303: ZEND_METHOD(reflection_parameter, allowsNull)
2304: {
2305: reflection_object *intern;
2306: parameter_reference *param;
2307:
2308: if (zend_parse_parameters_none() == FAILURE) {
2309: return;
2310: }
2311: GET_REFLECTION_OBJECT_PTR(param);
2312:
2313: RETVAL_BOOL(param->arg_info->allow_null);
2314: }
2315: /* }}} */
2316:
2317: /* {{{ proto public bool ReflectionParameter::isPassedByReference()
2318: Returns whether this parameters is passed to by reference */
2319: ZEND_METHOD(reflection_parameter, isPassedByReference)
2320: {
2321: reflection_object *intern;
2322: parameter_reference *param;
2323:
2324: if (zend_parse_parameters_none() == FAILURE) {
2325: return;
2326: }
2327: GET_REFLECTION_OBJECT_PTR(param);
2328:
2329: RETVAL_BOOL(param->arg_info->pass_by_reference);
2330: }
2331: /* }}} */
2332:
2333: /* {{{ proto public bool ReflectionParameter::getPosition()
2334: Returns whether this parameter is an optional parameter */
2335: ZEND_METHOD(reflection_parameter, getPosition)
2336: {
2337: reflection_object *intern;
2338: parameter_reference *param;
2339:
2340: if (zend_parse_parameters_none() == FAILURE) {
2341: return;
2342: }
2343: GET_REFLECTION_OBJECT_PTR(param);
2344:
2345: RETVAL_LONG(param->offset);
2346: }
2347: /* }}} */
2348:
2349: /* {{{ proto public bool ReflectionParameter::isOptional()
2350: Returns whether this parameter is an optional parameter */
2351: ZEND_METHOD(reflection_parameter, isOptional)
2352: {
2353: reflection_object *intern;
2354: parameter_reference *param;
2355:
2356: if (zend_parse_parameters_none() == FAILURE) {
2357: return;
2358: }
2359: GET_REFLECTION_OBJECT_PTR(param);
2360:
2361: RETVAL_BOOL(param->offset >= param->required);
2362: }
2363: /* }}} */
2364:
2365: /* {{{ proto public bool ReflectionParameter::isDefaultValueAvailable()
2366: Returns whether the default value of this parameter is available */
2367: ZEND_METHOD(reflection_parameter, isDefaultValueAvailable)
2368: {
2369: reflection_object *intern;
2370: parameter_reference *param;
2371: zend_op *precv;
2372:
2373: if (zend_parse_parameters_none() == FAILURE) {
2374: return;
2375: }
2376: GET_REFLECTION_OBJECT_PTR(param);
2377:
2378: if (param->fptr->type != ZEND_USER_FUNCTION)
2379: {
2380: RETURN_FALSE;
2381: }
2382: if (param->offset < param->required) {
2383: RETURN_FALSE;
2384: }
2385: precv = _get_recv_op((zend_op_array*)param->fptr, param->offset);
2386: if (!precv || precv->opcode != ZEND_RECV_INIT || precv->op2.op_type == IS_UNUSED) {
2387: RETURN_FALSE;
2388: }
2389: RETURN_TRUE;
2390: }
2391: /* }}} */
2392:
2393: /* {{{ proto public bool ReflectionParameter::getDefaultValue()
2394: Returns the default value of this parameter or throws an exception */
2395: ZEND_METHOD(reflection_parameter, getDefaultValue)
2396: {
2397: reflection_object *intern;
2398: parameter_reference *param;
2399: zend_op *precv;
2400:
2401: if (zend_parse_parameters_none() == FAILURE) {
2402: return;
2403: }
2404: GET_REFLECTION_OBJECT_PTR(param);
2405:
2406: if (param->fptr->type != ZEND_USER_FUNCTION)
2407: {
2408: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC, "Cannot determine default value for internal functions");
2409: return;
2410: }
2411: if (param->offset < param->required) {
2412: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC, "Parameter is not optional");
2413: return;
2414: }
2415: precv = _get_recv_op((zend_op_array*)param->fptr, param->offset);
2416: if (!precv || precv->opcode != ZEND_RECV_INIT || precv->op2.op_type == IS_UNUSED) {
2417: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC, "Internal error");
2418: return;
2419: }
2420:
2421: *return_value = precv->op2.u.constant;
2422: INIT_PZVAL(return_value);
2423: if (Z_TYPE_P(return_value) != IS_CONSTANT && Z_TYPE_P(return_value) != IS_CONSTANT_ARRAY) {
2424: zval_copy_ctor(return_value);
2425: }
2426: zval_update_constant_ex(&return_value, (void*)0, param->fptr->common.scope TSRMLS_CC);
2427: }
2428: /* }}} */
2429:
2430: /* {{{ proto public static mixed ReflectionMethod::export(mixed class, string name [, bool return]) throws ReflectionException
2431: Exports a reflection object. Returns the output if TRUE is specified for return, printing it otherwise. */
2432: ZEND_METHOD(reflection_method, export)
2433: {
2434: _reflection_export(INTERNAL_FUNCTION_PARAM_PASSTHRU, reflection_method_ptr, 2);
2435: }
2436: /* }}} */
2437:
2438: /* {{{ proto public void ReflectionMethod::__construct(mixed class_or_method [, string name])
2439: Constructor. Throws an Exception in case the given method does not exist */
2440: ZEND_METHOD(reflection_method, __construct)
2441: {
2442: zval *name, *classname;
2443: zval *object, *orig_obj;
2444: reflection_object *intern;
2445: char *lcname;
2446: zend_class_entry **pce;
2447: zend_class_entry *ce;
2448: zend_function *mptr;
2449: char *name_str, *tmp;
2450: int name_len, tmp_len;
2451: zval ztmp;
2452:
2453: if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "zs", &classname, &name_str, &name_len) == FAILURE) {
2454: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name_str, &name_len) == FAILURE) {
2455: return;
2456: }
2457: if ((tmp = strstr(name_str, "::")) == NULL) {
2458: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC, "Invalid method name %s", name_str);
2459: return;
2460: }
2461: classname = &ztmp;
2462: tmp_len = tmp - name_str;
2463: ZVAL_STRINGL(classname, name_str, tmp_len, 1);
2464: name_len = name_len - (tmp_len + 2);
2465: name_str = tmp + 2;
2466: orig_obj = NULL;
2467: } else if (Z_TYPE_P(classname) == IS_OBJECT) {
2468: orig_obj = classname;
2469: } else {
2470: orig_obj = NULL;
2471: }
2472:
2473: object = getThis();
2474: intern = (reflection_object *) zend_object_store_get_object(object TSRMLS_CC);
2475: if (intern == NULL) {
2476: return;
2477: }
2478:
2479: /* Find the class entry */
2480: switch (Z_TYPE_P(classname)) {
2481: case IS_STRING:
2482: if (zend_lookup_class(Z_STRVAL_P(classname), Z_STRLEN_P(classname), &pce TSRMLS_CC) == FAILURE) {
2483: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
2484: "Class %s does not exist", Z_STRVAL_P(classname));
2485: if (classname == &ztmp) {
2486: zval_dtor(&ztmp);
2487: }
2488: return;
2489: }
2490: ce = *pce;
2491: break;
2492:
2493: case IS_OBJECT:
2494: ce = Z_OBJCE_P(classname);
2495: break;
2496:
2497: default:
2498: if (classname == &ztmp) {
2499: zval_dtor(&ztmp);
2500: }
2501: _DO_THROW("The parameter class is expected to be either a string or an object");
2502: /* returns out of this function */
2503: }
2504:
2505: if (classname == &ztmp) {
2506: zval_dtor(&ztmp);
2507: }
2508:
2509: lcname = zend_str_tolower_dup(name_str, name_len);
2510:
2511: if (ce == zend_ce_closure && orig_obj && (name_len == sizeof(ZEND_INVOKE_FUNC_NAME)-1)
2512: && memcmp(lcname, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1) == 0
2513: && (mptr = zend_get_closure_invoke_method(orig_obj TSRMLS_CC)) != NULL)
2514: {
2515: /* do nothing, mptr already set */
2516: } else if (zend_hash_find(&ce->function_table, lcname, name_len + 1, (void **) &mptr) == FAILURE) {
2517: efree(lcname);
2518: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
2519: "Method %s::%s() does not exist", ce->name, name_str);
2520: return;
2521: }
2522: efree(lcname);
2523:
2524: MAKE_STD_ZVAL(classname);
2525: ZVAL_STRINGL(classname, mptr->common.scope->name, mptr->common.scope->name_length, 1);
2526:
2527: zend_hash_update(Z_OBJPROP_P(object), "class", sizeof("class"), (void **) &classname, sizeof(zval *), NULL);
2528:
2529: MAKE_STD_ZVAL(name);
2530: ZVAL_STRING(name, mptr->common.function_name, 1);
2531: zend_hash_update(Z_OBJPROP_P(object), "name", sizeof("name"), (void **) &name, sizeof(zval *), NULL);
2532: intern->ptr = mptr;
2533: intern->ref_type = REF_TYPE_FUNCTION;
2534: intern->ce = ce;
2535: }
2536: /* }}} */
2537:
2538: /* {{{ proto public string ReflectionMethod::__toString()
2539: Returns a string representation */
2540: ZEND_METHOD(reflection_method, __toString)
2541: {
2542: reflection_object *intern;
2543: zend_function *mptr;
2544: string str;
2545:
2546: if (zend_parse_parameters_none() == FAILURE) {
2547: return;
2548: }
2549: GET_REFLECTION_OBJECT_PTR(mptr);
2550: string_init(&str);
2551: _function_string(&str, mptr, intern->ce, "" TSRMLS_CC);
2552: RETURN_STRINGL(str.string, str.len - 1, 0);
2553: }
2554: /* }}} */
2555:
2556: /* {{{ proto public mixed ReflectionMethod::invoke(mixed object, mixed* args)
2557: Invokes the method. */
2558: ZEND_METHOD(reflection_method, invoke)
2559: {
2560: zval *retval_ptr;
2561: zval ***params = NULL;
2562: zval *object_ptr;
2563: reflection_object *intern;
2564: zend_function *mptr;
2565: int result, num_args = 0;
2566: zend_fcall_info fci;
2567: zend_fcall_info_cache fcc;
2568: zend_class_entry *obj_ce;
2569:
2570: METHOD_NOTSTATIC(reflection_method_ptr);
2571:
2572: GET_REFLECTION_OBJECT_PTR(mptr);
2573:
2574: if ((!(mptr->common.fn_flags & ZEND_ACC_PUBLIC)
2575: || (mptr->common.fn_flags & ZEND_ACC_ABSTRACT))
2576: && intern->ignore_visibility == 0)
2577: {
2578: if (mptr->common.fn_flags & ZEND_ACC_ABSTRACT) {
2579: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
2580: "Trying to invoke abstract method %s::%s()",
2581: mptr->common.scope->name, mptr->common.function_name);
2582: } else {
2583: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
2584: "Trying to invoke %s method %s::%s() from scope %s",
2585: mptr->common.fn_flags & ZEND_ACC_PROTECTED ? "protected" : "private",
2586: mptr->common.scope->name, mptr->common.function_name,
2587: Z_OBJCE_P(getThis())->name);
2588: }
2589: return;
2590: }
2591:
2592: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "+", ¶ms, &num_args) == FAILURE) {
2593: return;
2594: }
2595:
2596: /* In case this is a static method, we should'nt pass an object_ptr
2597: * (which is used as calling context aka $this). We can thus ignore the
2598: * first parameter.
2599: *
2600: * Else, we verify that the given object is an instance of the class.
2601: */
2602: if (mptr->common.fn_flags & ZEND_ACC_STATIC) {
2603: object_ptr = NULL;
2604: obj_ce = mptr->common.scope;
2605: } else {
2606: if (Z_TYPE_PP(params[0]) != IS_OBJECT) {
2607: efree(params);
2608: _DO_THROW("Non-object passed to Invoke()");
2609: /* Returns from this function */
2610: }
2611:
2612: obj_ce = Z_OBJCE_PP(params[0]);
2613:
2614: if (!instanceof_function(obj_ce, mptr->common.scope TSRMLS_CC)) {
2615: if (params) {
2616: efree(params);
2617: }
2618: _DO_THROW("Given object is not an instance of the class this method was declared in");
2619: /* Returns from this function */
2620: }
2621:
2622: object_ptr = *params[0];
2623: }
2624:
2625: fci.size = sizeof(fci);
2626: fci.function_table = NULL;
2627: fci.function_name = NULL;
2628: fci.symbol_table = NULL;
2629: fci.object_ptr = object_ptr;
2630: fci.retval_ptr_ptr = &retval_ptr;
2631: fci.param_count = num_args - 1;
2632: fci.params = params + 1;
2633: fci.no_separation = 1;
2634:
2635: fcc.initialized = 1;
2636: fcc.function_handler = mptr;
2637: fcc.calling_scope = obj_ce;
2638: fcc.called_scope = intern->ce;
2639: fcc.object_ptr = object_ptr;
2640:
2641: result = zend_call_function(&fci, &fcc TSRMLS_CC);
2642:
2643: if (params) {
2644: efree(params);
2645: }
2646:
2647: if (result == FAILURE) {
2648: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
2649: "Invocation of method %s::%s() failed", mptr->common.scope->name, mptr->common.function_name);
2650: return;
2651: }
2652:
2653: if (retval_ptr) {
2654: COPY_PZVAL_TO_ZVAL(*return_value, retval_ptr);
2655: }
2656: }
2657: /* }}} */
2658:
2659: /* {{{ proto public mixed ReflectionMethod::invokeArgs(mixed object, array args)
2660: Invokes the function and pass its arguments as array. */
2661: ZEND_METHOD(reflection_method, invokeArgs)
2662: {
2663: zval *retval_ptr;
2664: zval ***params;
2665: zval *object;
2666: reflection_object *intern;
2667: zend_function *mptr;
2668: int argc;
2669: int result;
2670: zend_fcall_info fci;
2671: zend_fcall_info_cache fcc;
2672: zend_class_entry *obj_ce;
2673: zval *param_array;
2674:
2675: METHOD_NOTSTATIC(reflection_method_ptr);
2676:
2677: GET_REFLECTION_OBJECT_PTR(mptr);
2678:
2679: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o!a", &object, ¶m_array) == FAILURE) {
2680: return;
2681: }
2682:
2683: if ((!(mptr->common.fn_flags & ZEND_ACC_PUBLIC)
2684: || (mptr->common.fn_flags & ZEND_ACC_ABSTRACT))
2685: && intern->ignore_visibility == 0)
2686: {
2687: if (mptr->common.fn_flags & ZEND_ACC_ABSTRACT) {
2688: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
2689: "Trying to invoke abstract method %s::%s()",
2690: mptr->common.scope->name, mptr->common.function_name);
2691: } else {
2692: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
2693: "Trying to invoke %s method %s::%s() from scope %s",
2694: mptr->common.fn_flags & ZEND_ACC_PROTECTED ? "protected" : "private",
2695: mptr->common.scope->name, mptr->common.function_name,
2696: Z_OBJCE_P(getThis())->name);
2697: }
2698: return;
2699: }
2700:
2701: argc = zend_hash_num_elements(Z_ARRVAL_P(param_array));
2702:
2703: params = safe_emalloc(sizeof(zval **), argc, 0);
2704: zend_hash_apply_with_argument(Z_ARRVAL_P(param_array), (apply_func_arg_t)_zval_array_to_c_array, ¶ms TSRMLS_CC);
2705: params -= argc;
2706:
2707: /* In case this is a static method, we should'nt pass an object_ptr
2708: * (which is used as calling context aka $this). We can thus ignore the
2709: * first parameter.
2710: *
2711: * Else, we verify that the given object is an instance of the class.
2712: */
2713: if (mptr->common.fn_flags & ZEND_ACC_STATIC) {
2714: object = NULL;
2715: obj_ce = mptr->common.scope;
2716: } else {
2717: if (!object) {
2718: efree(params);
2719: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
2720: "Trying to invoke non static method %s::%s() without an object",
2721: mptr->common.scope->name, mptr->common.function_name);
2722: return;
2723: }
2724:
2725: obj_ce = Z_OBJCE_P(object);
2726:
2727: if (!instanceof_function(obj_ce, mptr->common.scope TSRMLS_CC)) {
2728: efree(params);
2729: _DO_THROW("Given object is not an instance of the class this method was declared in");
2730: /* Returns from this function */
2731: }
2732: }
2733:
2734: fci.size = sizeof(fci);
2735: fci.function_table = NULL;
2736: fci.function_name = NULL;
2737: fci.symbol_table = NULL;
2738: fci.object_ptr = object;
2739: fci.retval_ptr_ptr = &retval_ptr;
2740: fci.param_count = argc;
2741: fci.params = params;
2742: fci.no_separation = 1;
2743:
2744: fcc.initialized = 1;
2745: fcc.function_handler = mptr;
2746: fcc.calling_scope = obj_ce;
2747: fcc.called_scope = obj_ce;
2748: fcc.object_ptr = object;
2749:
2750: result = zend_call_function(&fci, &fcc TSRMLS_CC);
2751:
2752: efree(params);
2753:
2754: if (result == FAILURE) {
2755: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
2756: "Invocation of method %s::%s() failed", mptr->common.scope->name, mptr->common.function_name);
2757: return;
2758: }
2759:
2760: if (retval_ptr) {
2761: COPY_PZVAL_TO_ZVAL(*return_value, retval_ptr);
2762: }
2763: }
2764: /* }}} */
2765:
2766: /* {{{ proto public bool ReflectionMethod::isFinal()
2767: Returns whether this method is final */
2768: ZEND_METHOD(reflection_method, isFinal)
2769: {
2770: _function_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_FINAL);
2771: }
2772: /* }}} */
2773:
2774: /* {{{ proto public bool ReflectionMethod::isAbstract()
2775: Returns whether this method is abstract */
2776: ZEND_METHOD(reflection_method, isAbstract)
2777: {
2778: _function_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_ABSTRACT);
2779: }
2780: /* }}} */
2781:
2782: /* {{{ proto public bool ReflectionMethod::isPublic()
2783: Returns whether this method is public */
2784: ZEND_METHOD(reflection_method, isPublic)
2785: {
2786: _function_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_PUBLIC);
2787: }
2788: /* }}} */
2789:
2790: /* {{{ proto public bool ReflectionMethod::isPrivate()
2791: Returns whether this method is private */
2792: ZEND_METHOD(reflection_method, isPrivate)
2793: {
2794: _function_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_PRIVATE);
2795: }
2796: /* }}} */
2797:
2798: /* {{{ proto public bool ReflectionMethod::isProtected()
2799: Returns whether this method is protected */
2800: ZEND_METHOD(reflection_method, isProtected)
2801: {
2802: _function_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_PROTECTED);
2803: }
2804: /* }}} */
2805:
2806: /* {{{ proto public bool ReflectionMethod::isStatic()
2807: Returns whether this method is static */
2808: ZEND_METHOD(reflection_method, isStatic)
2809: {
2810: _function_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_STATIC);
2811: }
2812: /* }}} */
2813:
2814: /* {{{ proto public bool ReflectionFunction::isDeprecated()
2815: Returns whether this function is deprecated */
2816: ZEND_METHOD(reflection_function, isDeprecated)
2817: {
2818: _function_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_DEPRECATED);
2819: }
2820: /* }}} */
2821:
2822: /* {{{ proto public bool ReflectionFunction::inNamespace()
2823: Returns whether this function is defined in namespace */
2824: ZEND_METHOD(reflection_function, inNamespace)
2825: {
2826: zval **name;
2827: char *colon;
2828:
2829: if (zend_parse_parameters_none() == FAILURE) {
2830: return;
2831: }
2832: if (zend_hash_find(Z_OBJPROP_P(getThis()), "name", sizeof("name"), (void **) &name) == FAILURE) {
2833: RETURN_FALSE;
2834: }
2835: if (Z_TYPE_PP(name) == IS_STRING
2836: && (colon = zend_memrchr(Z_STRVAL_PP(name), '\\', Z_STRLEN_PP(name)))
2837: && colon > Z_STRVAL_PP(name))
2838: {
2839: RETURN_TRUE;
2840: }
2841: RETURN_FALSE;
2842: }
2843: /* }}} */
2844:
2845: /* {{{ proto public string ReflectionFunction::getNamespaceName()
2846: Returns the name of namespace where this function is defined */
2847: ZEND_METHOD(reflection_function, getNamespaceName)
2848: {
2849: zval **name;
2850: char *backslash;
2851:
2852: if (zend_parse_parameters_none() == FAILURE) {
2853: return;
2854: }
2855: if (zend_hash_find(Z_OBJPROP_P(getThis()), "name", sizeof("name"), (void **) &name) == FAILURE) {
2856: RETURN_FALSE;
2857: }
2858: if (Z_TYPE_PP(name) == IS_STRING
2859: && (backslash = zend_memrchr(Z_STRVAL_PP(name), '\\', Z_STRLEN_PP(name)))
2860: && backslash > Z_STRVAL_PP(name))
2861: {
2862: RETURN_STRINGL(Z_STRVAL_PP(name), backslash - Z_STRVAL_PP(name), 1);
2863: }
2864: RETURN_EMPTY_STRING();
2865: }
2866: /* }}} */
2867:
2868: /* {{{ proto public string ReflectionFunction::getShortName()
2869: Returns the short name of the function (without namespace part) */
2870: ZEND_METHOD(reflection_function, getShortName)
2871: {
2872: zval **name;
2873: char *backslash;
2874:
2875: if (zend_parse_parameters_none() == FAILURE) {
2876: return;
2877: }
2878: if (zend_hash_find(Z_OBJPROP_P(getThis()), "name", sizeof("name"), (void **) &name) == FAILURE) {
2879: RETURN_FALSE;
2880: }
2881: if (Z_TYPE_PP(name) == IS_STRING
2882: && (backslash = zend_memrchr(Z_STRVAL_PP(name), '\\', Z_STRLEN_PP(name)))
2883: && backslash > Z_STRVAL_PP(name))
2884: {
2885: RETURN_STRINGL(backslash + 1, Z_STRLEN_PP(name) - (backslash - Z_STRVAL_PP(name) + 1), 1);
2886: }
2887: RETURN_ZVAL(*name, 1, 0);
2888: }
2889: /* }}} */
2890:
2891: /* {{{ proto public bool ReflectionMethod::isConstructor()
2892: Returns whether this method is the constructor */
2893: ZEND_METHOD(reflection_method, isConstructor)
2894: {
2895: reflection_object *intern;
2896: zend_function *mptr;
2897:
2898: if (zend_parse_parameters_none() == FAILURE) {
2899: return;
2900: }
2901: GET_REFLECTION_OBJECT_PTR(mptr);
2902: /* we need to check if the ctor is the ctor of the class level we we
2903: * looking at since we might be looking at an inherited old style ctor
2904: * defined in base class. */
2905: RETURN_BOOL(mptr->common.fn_flags & ZEND_ACC_CTOR && intern->ce->constructor && intern->ce->constructor->common.scope == mptr->common.scope);
2906: }
2907: /* }}} */
2908:
2909: /* {{{ proto public bool ReflectionMethod::isDestructor()
2910: Returns whether this method is static */
2911: ZEND_METHOD(reflection_method, isDestructor)
2912: {
2913: reflection_object *intern;
2914: zend_function *mptr;
2915:
2916: if (zend_parse_parameters_none() == FAILURE) {
2917: return;
2918: }
2919: GET_REFLECTION_OBJECT_PTR(mptr);
2920: RETURN_BOOL(mptr->common.fn_flags & ZEND_ACC_DTOR);
2921: }
2922: /* }}} */
2923:
2924: /* {{{ proto public int ReflectionMethod::getModifiers()
2925: Returns a bitfield of the access modifiers for this method */
2926: ZEND_METHOD(reflection_method, getModifiers)
2927: {
2928: reflection_object *intern;
2929: zend_function *mptr;
2930:
2931: if (zend_parse_parameters_none() == FAILURE) {
2932: return;
2933: }
2934: GET_REFLECTION_OBJECT_PTR(mptr);
2935:
2936: RETURN_LONG(mptr->common.fn_flags);
2937: }
2938: /* }}} */
2939:
2940: /* {{{ proto public ReflectionClass ReflectionMethod::getDeclaringClass()
2941: Get the declaring class */
2942: ZEND_METHOD(reflection_method, getDeclaringClass)
2943: {
2944: reflection_object *intern;
2945: zend_function *mptr;
2946:
2947: METHOD_NOTSTATIC(reflection_method_ptr);
2948: GET_REFLECTION_OBJECT_PTR(mptr);
2949:
2950: if (zend_parse_parameters_none() == FAILURE) {
2951: return;
2952: }
2953:
2954: zend_reflection_class_factory(mptr->common.scope, return_value TSRMLS_CC);
2955: }
2956: /* }}} */
2957:
2958: /* {{{ proto public ReflectionClass ReflectionMethod::getPrototype()
2959: Get the prototype */
2960: ZEND_METHOD(reflection_method, getPrototype)
2961: {
2962: reflection_object *intern;
2963: zend_function *mptr;
2964:
2965: METHOD_NOTSTATIC(reflection_method_ptr);
2966: GET_REFLECTION_OBJECT_PTR(mptr);
2967:
2968: if (zend_parse_parameters_none() == FAILURE) {
2969: return;
2970: }
2971:
2972: if (!mptr->common.prototype) {
2973: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
2974: "Method %s::%s does not have a prototype", intern->ce->name, mptr->common.function_name);
2975: return;
2976: }
2977:
2978: reflection_method_factory(mptr->common.prototype->common.scope, mptr->common.prototype, NULL, return_value TSRMLS_CC);
2979: }
2980: /* }}} */
2981:
2982: /* {{{ proto public void ReflectionMethod::setAccessible(bool visible)
2983: Sets whether non-public methods can be invoked */
2984: ZEND_METHOD(reflection_method, setAccessible)
2985: {
2986: reflection_object *intern;
2987: zend_bool visible;
2988:
2989: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "b", &visible) == FAILURE) {
2990: return;
2991: }
2992:
2993: intern = (reflection_object *) zend_object_store_get_object(getThis() TSRMLS_CC);
2994:
2995: if (intern == NULL) {
2996: return;
2997: }
2998:
2999: intern->ignore_visibility = visible;
3000: }
3001: /* }}} */
3002:
3003: /* {{{ proto public static mixed ReflectionClass::export(mixed argument [, bool return]) throws ReflectionException
3004: Exports a reflection object. Returns the output if TRUE is specified for return, printing it otherwise. */
3005: ZEND_METHOD(reflection_class, export)
3006: {
3007: _reflection_export(INTERNAL_FUNCTION_PARAM_PASSTHRU, reflection_class_ptr, 1);
3008: }
3009: /* }}} */
3010:
3011: /* {{{ reflection_class_object_ctor */
3012: static void reflection_class_object_ctor(INTERNAL_FUNCTION_PARAMETERS, int is_object)
3013: {
3014: zval *argument;
3015: zval *object;
3016: zval *classname;
3017: reflection_object *intern;
3018: zend_class_entry **ce;
3019:
3020: if (is_object) {
3021: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &argument) == FAILURE) {
3022: return;
3023: }
3024: } else {
3025: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z/", &argument) == FAILURE) {
3026: return;
3027: }
3028: }
3029:
3030: object = getThis();
3031: intern = (reflection_object *) zend_object_store_get_object(object TSRMLS_CC);
3032: if (intern == NULL) {
3033: return;
3034: }
3035:
3036: if (Z_TYPE_P(argument) == IS_OBJECT) {
3037: MAKE_STD_ZVAL(classname);
3038: ZVAL_STRINGL(classname, Z_OBJCE_P(argument)->name, Z_OBJCE_P(argument)->name_length, 1);
3039: zend_hash_update(Z_OBJPROP_P(object), "name", sizeof("name"), (void **) &classname, sizeof(zval *), NULL);
3040: intern->ptr = Z_OBJCE_P(argument);
3041: if (is_object) {
3042: intern->obj = argument;
3043: zval_add_ref(&argument);
3044: }
3045: } else {
3046: convert_to_string_ex(&argument);
3047: if (zend_lookup_class(Z_STRVAL_P(argument), Z_STRLEN_P(argument), &ce TSRMLS_CC) == FAILURE) {
3048: if (!EG(exception)) {
3049: zend_throw_exception_ex(reflection_exception_ptr, -1 TSRMLS_CC, "Class %s does not exist", Z_STRVAL_P(argument));
3050: }
3051: return;
3052: }
3053:
3054: MAKE_STD_ZVAL(classname);
3055: ZVAL_STRINGL(classname, (*ce)->name, (*ce)->name_length, 1);
3056: zend_hash_update(Z_OBJPROP_P(object), "name", sizeof("name"), (void **) &classname, sizeof(zval *), NULL);
3057:
3058: intern->ptr = *ce;
3059: }
3060: intern->ref_type = REF_TYPE_OTHER;
3061: }
3062: /* }}} */
3063:
3064: /* {{{ proto public void ReflectionClass::__construct(mixed argument) throws ReflectionException
3065: Constructor. Takes a string or an instance as an argument */
3066: ZEND_METHOD(reflection_class, __construct)
3067: {
3068: reflection_class_object_ctor(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
3069: }
3070: /* }}} */
3071:
3072: /* {{{ proto public array ReflectionClass::getStaticProperties()
3073: Returns an associative array containing all static property values of the class */
3074: ZEND_METHOD(reflection_class, getStaticProperties)
3075: {
3076: reflection_object *intern;
3077: zend_class_entry *ce;
3078: HashPosition pos;
3079: zval **value;
3080:
3081: if (zend_parse_parameters_none() == FAILURE) {
3082: return;
3083: }
3084:
3085: GET_REFLECTION_OBJECT_PTR(ce);
3086:
3087: zend_update_class_constants(ce TSRMLS_CC);
3088:
3089: array_init(return_value);
3090:
3091: zend_hash_internal_pointer_reset_ex(CE_STATIC_MEMBERS(ce), &pos);
3092:
3093: while (zend_hash_get_current_data_ex(CE_STATIC_MEMBERS(ce), (void **) &value, &pos) == SUCCESS) {
3094: uint key_len;
3095: char *key;
3096: ulong num_index;
3097:
3098: if (zend_hash_get_current_key_ex(CE_STATIC_MEMBERS(ce), &key, &key_len, &num_index, 0, &pos) != FAILURE && key) {
3099: char *prop_name, *class_name;
3100: zval *prop_copy;
3101:
3102: zend_unmangle_property_name(key, key_len-1, &class_name, &prop_name);
3103:
3104: /* filter privates from base classes */
3105: if (!(class_name && class_name[0] != '*' && strcmp(class_name, ce->name))) {
3106: /* copy: enforce read only access */
3107: ALLOC_ZVAL(prop_copy);
3108: MAKE_COPY_ZVAL(value, prop_copy);
3109:
3110: add_assoc_zval(return_value, prop_name, prop_copy);
3111: }
3112: }
3113: zend_hash_move_forward_ex(CE_STATIC_MEMBERS(ce), &pos);
3114: }
3115: }
3116: /* }}} */
3117:
3118: /* {{{ proto public mixed ReflectionClass::getStaticPropertyValue(string name [, mixed default])
3119: Returns the value of a static property */
3120: ZEND_METHOD(reflection_class, getStaticPropertyValue)
3121: {
3122: reflection_object *intern;
3123: zend_class_entry *ce;
3124: char *name;
3125: int name_len;
3126: zval **prop, *def_value = NULL;
3127:
3128: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z", &name, &name_len, &def_value) == FAILURE) {
3129: return;
3130: }
3131:
3132: GET_REFLECTION_OBJECT_PTR(ce);
3133:
3134: zend_update_class_constants(ce TSRMLS_CC);
3135: prop = zend_std_get_static_property(ce, name, name_len, 1 TSRMLS_CC);
3136: if (!prop) {
3137: if (def_value) {
3138: RETURN_ZVAL(def_value, 1, 0);
3139: } else {
3140: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
3141: "Class %s does not have a property named %s", ce->name, name);
3142: }
3143: return;
3144: } else {
3145: RETURN_ZVAL(*prop, 1, 0);
3146: }
3147: }
3148: /* }}} */
3149:
3150: /* {{{ proto public void ReflectionClass::setStaticPropertyValue($name, $value)
3151: Sets the value of a static property */
3152: ZEND_METHOD(reflection_class, setStaticPropertyValue)
3153: {
3154: reflection_object *intern;
3155: zend_class_entry *ce;
3156: char *name;
3157: int name_len;
3158: zval **variable_ptr, *value;
3159: int refcount;
3160: zend_uchar is_ref;
3161:
3162: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz", &name, &name_len, &value) == FAILURE) {
3163: return;
3164: }
3165:
3166: GET_REFLECTION_OBJECT_PTR(ce);
3167:
3168: zend_update_class_constants(ce TSRMLS_CC);
3169: variable_ptr = zend_std_get_static_property(ce, name, name_len, 1 TSRMLS_CC);
3170: if (!variable_ptr) {
3171: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
3172: "Class %s does not have a property named %s", ce->name, name);
3173: return;
3174: }
3175: refcount = Z_REFCOUNT_PP(variable_ptr);
3176: is_ref = Z_ISREF_PP(variable_ptr);
3177: zval_dtor(*variable_ptr);
3178: **variable_ptr = *value;
3179: zval_copy_ctor(*variable_ptr);
3180: Z_SET_REFCOUNT_PP(variable_ptr, refcount);
3181: Z_SET_ISREF_TO_PP(variable_ptr, is_ref);
3182:
3183: }
3184: /* }}} */
3185:
3186: /* {{{ proto public array ReflectionClass::getDefaultProperties()
3187: Returns an associative array containing copies of all default property values of the class */
3188: ZEND_METHOD(reflection_class, getDefaultProperties)
3189: {
3190: reflection_object *intern;
3191: zend_class_entry *ce;
3192: int count, i;
3193: HashTable *ht_list[3];
3194:
3195: if (zend_parse_parameters_none() == FAILURE) {
3196: return;
3197: }
3198: GET_REFLECTION_OBJECT_PTR(ce);
3199: array_init(return_value);
3200:
3201: zend_update_class_constants(ce TSRMLS_CC);
3202:
3203: ht_list[0] = CE_STATIC_MEMBERS(ce);
3204: ht_list[1] = &ce->default_properties;
3205: ht_list[2] = NULL;
3206:
3207: for (i = 0; ht_list[i] != NULL; i++) {
3208:
3209: count = zend_hash_num_elements(ht_list[i]);
3210: if (count > 0) {
3211: HashPosition pos;
3212: zval **prop;
3213:
3214: zend_hash_internal_pointer_reset_ex(ht_list[i], &pos);
3215: while (zend_hash_get_current_data_ex(ht_list[i], (void **) &prop, &pos) == SUCCESS) {
3216: char *key, *class_name, *prop_name;
3217: uint key_len;
3218: ulong num_index;
3219: zval *prop_copy;
3220:
3221: zend_hash_get_current_key_ex(ht_list[i], &key, &key_len, &num_index, 0, &pos);
3222: zend_hash_move_forward_ex(ht_list[i], &pos);
3223: zend_unmangle_property_name(key, key_len-1, &class_name, &prop_name);
3224: if (class_name && class_name[0] != '*' && strcmp(class_name, ce->name)) {
3225: /* filter privates from base classes */
3226: continue;
3227: }
3228:
3229: /* copy: enforce read only access */
3230: ALLOC_ZVAL(prop_copy);
3231: MAKE_COPY_ZVAL(prop, prop_copy);
3232:
3233: add_assoc_zval(return_value, prop_name, prop_copy);
3234: }
3235: }
3236: }
3237: }
3238: /* }}} */
3239:
3240: /* {{{ proto public string ReflectionClass::__toString()
3241: Returns a string representation */
3242: ZEND_METHOD(reflection_class, __toString)
3243: {
3244: reflection_object *intern;
3245: zend_class_entry *ce;
3246: string str;
3247:
3248: if (zend_parse_parameters_none() == FAILURE) {
3249: return;
3250: }
3251: GET_REFLECTION_OBJECT_PTR(ce);
3252: string_init(&str);
3253: _class_string(&str, ce, intern->obj, "" TSRMLS_CC);
3254: RETURN_STRINGL(str.string, str.len - 1, 0);
3255: }
3256: /* }}} */
3257:
3258: /* {{{ proto public string ReflectionClass::getName()
3259: Returns the class' name */
3260: ZEND_METHOD(reflection_class, getName)
3261: {
3262: if (zend_parse_parameters_none() == FAILURE) {
3263: return;
3264: }
3265: _default_get_entry(getThis(), "name", sizeof("name"), return_value TSRMLS_CC);
3266: }
3267: /* }}} */
3268:
3269: /* {{{ proto public bool ReflectionClass::isInternal()
3270: Returns whether this class is an internal class */
3271: ZEND_METHOD(reflection_class, isInternal)
3272: {
3273: reflection_object *intern;
3274: zend_class_entry *ce;
3275:
3276: if (zend_parse_parameters_none() == FAILURE) {
3277: return;
3278: }
3279: GET_REFLECTION_OBJECT_PTR(ce);
3280: RETURN_BOOL(ce->type == ZEND_INTERNAL_CLASS);
3281: }
3282: /* }}} */
3283:
3284: /* {{{ proto public bool ReflectionClass::isUserDefined()
3285: Returns whether this class is user-defined */
3286: ZEND_METHOD(reflection_class, isUserDefined)
3287: {
3288: reflection_object *intern;
3289: zend_class_entry *ce;
3290:
3291: if (zend_parse_parameters_none() == FAILURE) {
3292: return;
3293: }
3294: GET_REFLECTION_OBJECT_PTR(ce);
3295: RETURN_BOOL(ce->type == ZEND_USER_CLASS);
3296: }
3297: /* }}} */
3298:
3299: /* {{{ proto public string ReflectionClass::getFileName()
3300: Returns the filename of the file this class was declared in */
3301: ZEND_METHOD(reflection_class, getFileName)
3302: {
3303: reflection_object *intern;
3304: zend_class_entry *ce;
3305:
3306: if (zend_parse_parameters_none() == FAILURE) {
3307: return;
3308: }
3309: GET_REFLECTION_OBJECT_PTR(ce);
3310: if (ce->type == ZEND_USER_CLASS) {
3311: RETURN_STRING(ce->filename, 1);
3312: }
3313: RETURN_FALSE;
3314: }
3315: /* }}} */
3316:
3317: /* {{{ proto public int ReflectionClass::getStartLine()
3318: Returns the line this class' declaration starts at */
3319: ZEND_METHOD(reflection_class, getStartLine)
3320: {
3321: reflection_object *intern;
3322: zend_class_entry *ce;
3323:
3324: if (zend_parse_parameters_none() == FAILURE) {
3325: return;
3326: }
3327: GET_REFLECTION_OBJECT_PTR(ce);
3328: if (ce->type == ZEND_USER_FUNCTION) {
3329: RETURN_LONG(ce->line_start);
3330: }
3331: RETURN_FALSE;
3332: }
3333: /* }}} */
3334:
3335: /* {{{ proto public int ReflectionClass::getEndLine()
3336: Returns the line this class' declaration ends at */
3337: ZEND_METHOD(reflection_class, getEndLine)
3338: {
3339: reflection_object *intern;
3340: zend_class_entry *ce;
3341:
3342: if (zend_parse_parameters_none() == FAILURE) {
3343: return;
3344: }
3345: GET_REFLECTION_OBJECT_PTR(ce);
3346: if (ce->type == ZEND_USER_CLASS) {
3347: RETURN_LONG(ce->line_end);
3348: }
3349: RETURN_FALSE;
3350: }
3351: /* }}} */
3352:
3353: /* {{{ proto public string ReflectionClass::getDocComment()
3354: Returns the doc comment for this class */
3355: ZEND_METHOD(reflection_class, getDocComment)
3356: {
3357: reflection_object *intern;
3358: zend_class_entry *ce;
3359:
3360: if (zend_parse_parameters_none() == FAILURE) {
3361: return;
3362: }
3363: GET_REFLECTION_OBJECT_PTR(ce);
3364: if (ce->type == ZEND_USER_CLASS && ce->doc_comment) {
3365: RETURN_STRINGL(ce->doc_comment, ce->doc_comment_len, 1);
3366: }
3367: RETURN_FALSE;
3368: }
3369: /* }}} */
3370:
3371: /* {{{ proto public ReflectionMethod ReflectionClass::getConstructor()
3372: Returns the class' constructor if there is one, NULL otherwise */
3373: ZEND_METHOD(reflection_class, getConstructor)
3374: {
3375: reflection_object *intern;
3376: zend_class_entry *ce;
3377:
3378: if (zend_parse_parameters_none() == FAILURE) {
3379: return;
3380: }
3381: GET_REFLECTION_OBJECT_PTR(ce);
3382:
3383: if (ce->constructor) {
3384: reflection_method_factory(ce, ce->constructor, NULL, return_value TSRMLS_CC);
3385: } else {
3386: RETURN_NULL();
3387: }
3388: }
3389: /* }}} */
3390:
3391: /* {{{ proto public bool ReflectionClass::hasMethod(string name)
3392: Returns whether a method exists or not */
3393: ZEND_METHOD(reflection_class, hasMethod)
3394: {
3395: reflection_object *intern;
3396: zend_class_entry *ce;
3397: char *name, *lc_name;
3398: int name_len;
3399:
3400: METHOD_NOTSTATIC(reflection_class_ptr);
3401: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_len) == FAILURE) {
3402: return;
3403: }
3404:
3405: GET_REFLECTION_OBJECT_PTR(ce);
3406: lc_name = zend_str_tolower_dup(name, name_len);
3407: if ((ce == zend_ce_closure && (name_len == sizeof(ZEND_INVOKE_FUNC_NAME)-1)
3408: && memcmp(lc_name, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1) == 0)
3409: || zend_hash_exists(&ce->function_table, lc_name, name_len + 1)) {
3410: efree(lc_name);
3411: RETURN_TRUE;
3412: } else {
3413: efree(lc_name);
3414: RETURN_FALSE;
3415: }
3416: }
3417: /* }}} */
3418:
3419: /* {{{ proto public ReflectionMethod ReflectionClass::getMethod(string name) throws ReflectionException
3420: Returns the class' method specified by its name */
3421: ZEND_METHOD(reflection_class, getMethod)
3422: {
3423: reflection_object *intern;
3424: zend_class_entry *ce;
3425: zend_function *mptr;
3426: zval obj_tmp;
3427: char *name, *lc_name;
3428: int name_len;
3429:
3430: METHOD_NOTSTATIC(reflection_class_ptr);
3431: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_len) == FAILURE) {
3432: return;
3433: }
3434:
3435: GET_REFLECTION_OBJECT_PTR(ce);
3436: lc_name = zend_str_tolower_dup(name, name_len);
3437: if (ce == zend_ce_closure && intern->obj && (name_len == sizeof(ZEND_INVOKE_FUNC_NAME)-1)
3438: && memcmp(lc_name, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1) == 0
3439: && (mptr = zend_get_closure_invoke_method(intern->obj TSRMLS_CC)) != NULL)
3440: {
3441: /* don't assign closure_object since we only reflect the invoke handler
3442: method and not the closure definition itself */
3443: reflection_method_factory(ce, mptr, NULL, return_value TSRMLS_CC);
3444: efree(lc_name);
3445: } else if (ce == zend_ce_closure && !intern->obj && (name_len == sizeof(ZEND_INVOKE_FUNC_NAME)-1)
3446: && memcmp(lc_name, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1) == 0
3447: && object_init_ex(&obj_tmp, ce) == SUCCESS && (mptr = zend_get_closure_invoke_method(&obj_tmp TSRMLS_CC)) != NULL) {
3448: /* don't assign closure_object since we only reflect the invoke handler
3449: method and not the closure definition itself */
3450: reflection_method_factory(ce, mptr, NULL, return_value TSRMLS_CC);
3451: zval_dtor(&obj_tmp);
3452: efree(lc_name);
3453: } else if (zend_hash_find(&ce->function_table, lc_name, name_len + 1, (void**) &mptr) == SUCCESS) {
3454: reflection_method_factory(ce, mptr, NULL, return_value TSRMLS_CC);
3455: efree(lc_name);
3456: } else {
3457: efree(lc_name);
3458: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
3459: "Method %s does not exist", name);
3460: return;
3461: }
3462: }
3463: /* }}} */
3464:
3465: /* {{{ _addmethod */
3466: static void _addmethod(zend_function *mptr, zend_class_entry *ce, zval *retval, long filter, zval *obj TSRMLS_DC)
3467: {
3468: zval *method;
3469: uint len = strlen(mptr->common.function_name);
3470: zend_function *closure;
3471:
3472: if (mptr->common.fn_flags & filter) {
3473: ALLOC_ZVAL(method);
3474: if (ce == zend_ce_closure && obj && (len == sizeof(ZEND_INVOKE_FUNC_NAME)-1)
3475: && memcmp(mptr->common.function_name, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1) == 0
3476: && (closure = zend_get_closure_invoke_method(obj TSRMLS_CC)) != NULL)
3477: {
3478: mptr = closure;
3479: }
3480: /* don't assign closure_object since we only reflect the invoke handler
3481: method and not the closure definition itself, even if we have a
3482: closure */
3483: reflection_method_factory(ce, mptr, NULL, method TSRMLS_CC);
3484: add_next_index_zval(retval, method);
3485: }
3486: }
3487: /* }}} */
3488:
3489: /* {{{ _addmethod */
3490: static int _addmethod_va(zend_function *mptr TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
3491: {
3492: zend_class_entry *ce = *va_arg(args, zend_class_entry**);
3493: zval *retval = va_arg(args, zval*);
3494: long filter = va_arg(args, long);
3495: zval *obj = va_arg(args, zval *);
3496:
3497: _addmethod(mptr, ce, retval, filter, obj TSRMLS_CC);
3498: return ZEND_HASH_APPLY_KEEP;
3499: }
3500: /* }}} */
3501:
3502: /* {{{ proto public ReflectionMethod[] ReflectionClass::getMethods([long $filter])
3503: Returns an array of this class' methods */
3504: ZEND_METHOD(reflection_class, getMethods)
3505: {
3506: reflection_object *intern;
3507: zend_class_entry *ce;
3508: long filter = 0;
3509: int argc = ZEND_NUM_ARGS();
3510:
3511: METHOD_NOTSTATIC(reflection_class_ptr);
3512: if (argc) {
3513: if (zend_parse_parameters(argc TSRMLS_CC, "|l", &filter) == FAILURE) {
3514: return;
3515: }
3516: } else {
3517: /* No parameters given, default to "return all" */
3518: filter = ZEND_ACC_PPP_MASK | ZEND_ACC_ABSTRACT | ZEND_ACC_FINAL | ZEND_ACC_STATIC;
3519: }
3520:
3521: GET_REFLECTION_OBJECT_PTR(ce);
3522:
3523: array_init(return_value);
3524: zend_hash_apply_with_arguments(&ce->function_table TSRMLS_CC, (apply_func_args_t) _addmethod_va, 4, &ce, return_value, filter, intern->obj);
3525: if (intern->obj && instanceof_function(ce, zend_ce_closure TSRMLS_CC)) {
3526: zend_function *closure = zend_get_closure_invoke_method(intern->obj TSRMLS_CC);
3527: if (closure) {
3528: _addmethod(closure, ce, return_value, filter, intern->obj TSRMLS_CC);
3529: _free_function(closure TSRMLS_CC);
3530: }
3531: }
3532: }
3533: /* }}} */
3534:
3535: /* {{{ proto public bool ReflectionClass::hasProperty(string name)
3536: Returns whether a property exists or not */
3537: ZEND_METHOD(reflection_class, hasProperty)
3538: {
3539: reflection_object *intern;
3540: zend_property_info *property_info;
3541: zend_class_entry *ce;
3542: char *name;
3543: int name_len;
3544: zval *property;
3545:
3546: METHOD_NOTSTATIC(reflection_class_ptr);
3547: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_len) == FAILURE) {
3548: return;
3549: }
3550:
3551: GET_REFLECTION_OBJECT_PTR(ce);
3552: if (zend_hash_find(&ce->properties_info, name, name_len+1, (void **) &property_info) == SUCCESS) {
3553: if (property_info->flags & ZEND_ACC_SHADOW) {
3554: RETURN_FALSE;
3555: }
3556: RETURN_TRUE;
3557: } else {
3558: if (intern->obj && Z_OBJ_HANDLER_P(intern->obj, has_property)) {
3559: MAKE_STD_ZVAL(property);
3560: ZVAL_STRINGL(property, name, name_len, 1);
3561: if (Z_OBJ_HANDLER_P(intern->obj, has_property)(intern->obj, property, 2 TSRMLS_CC)) {
3562: zval_ptr_dtor(&property);
3563: RETURN_TRUE;
3564: }
3565: zval_ptr_dtor(&property);
3566: }
3567: RETURN_FALSE;
3568: }
3569: }
3570: /* }}} */
3571:
3572: /* {{{ proto public ReflectionProperty ReflectionClass::getProperty(string name) throws ReflectionException
3573: Returns the class' property specified by its name */
3574: ZEND_METHOD(reflection_class, getProperty)
3575: {
3576: reflection_object *intern;
3577: zend_class_entry *ce, **pce;
3578: zend_property_info *property_info;
3579: char *name, *tmp, *classname;
3580: int name_len, classname_len;
3581:
3582: METHOD_NOTSTATIC(reflection_class_ptr);
3583: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_len) == FAILURE) {
3584: return;
3585: }
3586:
3587: GET_REFLECTION_OBJECT_PTR(ce);
3588: if (zend_hash_find(&ce->properties_info, name, name_len + 1, (void**) &property_info) == SUCCESS) {
3589: if ((property_info->flags & ZEND_ACC_SHADOW) == 0) {
3590: reflection_property_factory(ce, property_info, return_value TSRMLS_CC);
3591: return;
3592: }
3593: } else if (intern->obj) {
3594: /* Check for dynamic properties */
3595: if (zend_hash_exists(Z_OBJ_HT_P(intern->obj)->get_properties(intern->obj TSRMLS_CC), name, name_len+1)) {
3596: zend_property_info property_info_tmp;
3597: property_info_tmp.flags = ZEND_ACC_IMPLICIT_PUBLIC;
3598: property_info_tmp.name = estrndup(name, name_len);
3599: property_info_tmp.name_length = name_len;
3600: property_info_tmp.h = zend_get_hash_value(name, name_len+1);
3601: property_info_tmp.doc_comment = NULL;
3602: property_info_tmp.ce = ce;
3603:
3604: reflection_property_factory(ce, &property_info_tmp, return_value TSRMLS_CC);
3605: intern = (reflection_object *) zend_object_store_get_object(return_value TSRMLS_CC);
3606: intern->ref_type = REF_TYPE_DYNAMIC_PROPERTY;
3607: return;
3608: }
3609: }
3610: if ((tmp = strstr(name, "::")) != NULL) {
3611: classname_len = tmp - name;
3612: classname = zend_str_tolower_dup(name, classname_len);
3613: classname[classname_len] = '\0';
3614: name_len = name_len - (classname_len + 2);
3615: name = tmp + 2;
3616:
3617: if (zend_lookup_class(classname, classname_len, &pce TSRMLS_CC) == FAILURE) {
3618: if (!EG(exception)) {
3619: zend_throw_exception_ex(reflection_exception_ptr, -1 TSRMLS_CC, "Class %s does not exist", classname);
3620: }
3621: efree(classname);
3622: return;
3623: }
3624: efree(classname);
3625:
3626: if (!instanceof_function(ce, *pce TSRMLS_CC)) {
3627: zend_throw_exception_ex(reflection_exception_ptr, -1 TSRMLS_CC, "Fully qualified property name %s::%s does not specify a base class of %s", (*pce)->name, name, ce->name);
3628: return;
3629: }
3630: ce = *pce;
3631:
3632: if (zend_hash_find(&ce->properties_info, name, name_len + 1, (void**) &property_info) == SUCCESS && (property_info->flags & ZEND_ACC_SHADOW) == 0) {
3633: reflection_property_factory(ce, property_info, return_value TSRMLS_CC);
3634: return;
3635: }
3636: }
3637: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
3638: "Property %s does not exist", name);
3639: }
3640: /* }}} */
3641:
3642: /* {{{ _addproperty */
3643: static int _addproperty(zend_property_info *pptr TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
3644: {
3645: zval *property;
3646: zend_class_entry *ce = *va_arg(args, zend_class_entry**);
3647: zval *retval = va_arg(args, zval*);
3648: long filter = va_arg(args, long);
3649:
3650: if (pptr->flags & ZEND_ACC_SHADOW) {
3651: return 0;
3652: }
3653:
3654: if (pptr->flags & filter) {
3655: ALLOC_ZVAL(property);
3656: reflection_property_factory(ce, pptr, property TSRMLS_CC);
3657: add_next_index_zval(retval, property);
3658: }
3659: return 0;
3660: }
3661: /* }}} */
3662:
3663: /* {{{ _adddynproperty */
3664: static int _adddynproperty(zval **pptr TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
3665: {
3666: zval *property;
3667: zend_class_entry *ce = *va_arg(args, zend_class_entry**);
3668: zval *retval = va_arg(args, zval*), member;
3669:
3670: if (hash_key->arKey[0] == '\0') {
3671: return 0; /* non public cannot be dynamic */
3672: }
3673:
3674: ZVAL_STRINGL(&member, hash_key->arKey, hash_key->nKeyLength-1, 0);
3675: if (zend_get_property_info(ce, &member, 1 TSRMLS_CC) == &EG(std_property_info)) {
3676: MAKE_STD_ZVAL(property);
3677: EG(std_property_info).flags = ZEND_ACC_IMPLICIT_PUBLIC;
3678: reflection_property_factory(ce, &EG(std_property_info), property TSRMLS_CC);
3679: add_next_index_zval(retval, property);
3680: }
3681: return 0;
3682: }
3683: /* }}} */
3684:
3685: /* {{{ proto public ReflectionProperty[] ReflectionClass::getProperties([long $filter])
3686: Returns an array of this class' properties */
3687: ZEND_METHOD(reflection_class, getProperties)
3688: {
3689: reflection_object *intern;
3690: zend_class_entry *ce;
3691: long filter = 0;
3692: int argc = ZEND_NUM_ARGS();
3693:
3694: METHOD_NOTSTATIC(reflection_class_ptr);
3695: if (argc) {
3696: if (zend_parse_parameters(argc TSRMLS_CC, "|l", &filter) == FAILURE) {
3697: return;
3698: }
3699: } else {
3700: /* No parameters given, default to "return all" */
3701: filter = ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC;
3702: }
3703:
3704: GET_REFLECTION_OBJECT_PTR(ce);
3705:
3706: array_init(return_value);
3707: zend_hash_apply_with_arguments(&ce->properties_info TSRMLS_CC, (apply_func_args_t) _addproperty, 3, &ce, return_value, filter);
3708:
3709: if (intern->obj && (filter & ZEND_ACC_PUBLIC) != 0 && Z_OBJ_HT_P(intern->obj)->get_properties) {
3710: HashTable *properties = Z_OBJ_HT_P(intern->obj)->get_properties(intern->obj TSRMLS_CC);
3711: zend_hash_apply_with_arguments(properties TSRMLS_CC, (apply_func_args_t) _adddynproperty, 2, &ce, return_value);
3712: }
3713: }
3714: /* }}} */
3715:
3716: /* {{{ proto public bool ReflectionClass::hasConstant(string name)
3717: Returns whether a constant exists or not */
3718: ZEND_METHOD(reflection_class, hasConstant)
3719: {
3720: reflection_object *intern;
3721: zend_class_entry *ce;
3722: char *name;
3723: int name_len;
3724:
3725: METHOD_NOTSTATIC(reflection_class_ptr);
3726: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_len) == FAILURE) {
3727: return;
3728: }
3729:
3730: GET_REFLECTION_OBJECT_PTR(ce);
3731: if (zend_hash_exists(&ce->constants_table, name, name_len + 1)) {
3732: RETURN_TRUE;
3733: } else {
3734: RETURN_FALSE;
3735: }
3736: }
3737: /* }}} */
3738:
3739: /* {{{ proto public array ReflectionClass::getConstants()
3740: Returns an associative array containing this class' constants and their values */
3741: ZEND_METHOD(reflection_class, getConstants)
3742: {
3743: zval *tmp_copy;
3744: reflection_object *intern;
3745: zend_class_entry *ce;
3746:
3747: if (zend_parse_parameters_none() == FAILURE) {
3748: return;
3749: }
3750: GET_REFLECTION_OBJECT_PTR(ce);
3751: array_init(return_value);
3752: zend_hash_apply_with_argument(&ce->constants_table, (apply_func_arg_t)zval_update_constant_inline_change, ce TSRMLS_CC);
3753: zend_hash_copy(Z_ARRVAL_P(return_value), &ce->constants_table, (copy_ctor_func_t) zval_add_ref, (void *) &tmp_copy, sizeof(zval *));
3754: }
3755: /* }}} */
3756:
3757: /* {{{ proto public mixed ReflectionClass::getConstant(string name)
3758: Returns the class' constant specified by its name */
3759: ZEND_METHOD(reflection_class, getConstant)
3760: {
3761: reflection_object *intern;
3762: zend_class_entry *ce;
3763: zval **value;
3764: char *name;
3765: int name_len;
3766:
3767: METHOD_NOTSTATIC(reflection_class_ptr);
3768: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_len) == FAILURE) {
3769: return;
3770: }
3771:
3772: GET_REFLECTION_OBJECT_PTR(ce);
3773: zend_hash_apply_with_argument(&ce->constants_table, (apply_func_arg_t)zval_update_constant_inline_change, ce TSRMLS_CC);
3774: if (zend_hash_find(&ce->constants_table, name, name_len + 1, (void **) &value) == FAILURE) {
3775: RETURN_FALSE;
3776: }
3777: MAKE_COPY_ZVAL(value, return_value);
3778: }
3779: /* }}} */
3780:
3781: /* {{{ _class_check_flag */
3782: static void _class_check_flag(INTERNAL_FUNCTION_PARAMETERS, int mask)
3783: {
3784: reflection_object *intern;
3785: zend_class_entry *ce;
3786:
3787: if (zend_parse_parameters_none() == FAILURE) {
3788: return;
3789: }
3790: GET_REFLECTION_OBJECT_PTR(ce);
3791: RETVAL_BOOL(ce->ce_flags & mask);
3792: }
3793: /* }}} */
3794:
3795: /* {{{ proto public bool ReflectionClass::isInstantiable()
3796: Returns whether this class is instantiable */
3797: ZEND_METHOD(reflection_class, isInstantiable)
3798: {
3799: reflection_object *intern;
3800: zend_class_entry *ce;
3801:
3802: if (zend_parse_parameters_none() == FAILURE) {
3803: return;
3804: }
3805: GET_REFLECTION_OBJECT_PTR(ce);
3806: if (ce->ce_flags & (ZEND_ACC_INTERFACE | ZEND_ACC_EXPLICIT_ABSTRACT_CLASS | ZEND_ACC_IMPLICIT_ABSTRACT_CLASS)) {
3807: RETURN_FALSE;
3808: }
3809:
3810: /* Basically, the class is instantiable. Though, if there is a constructor
3811: * and it is not publicly accessible, it isn't! */
3812: if (!ce->constructor) {
3813: RETURN_TRUE;
3814: }
3815:
3816: RETURN_BOOL(ce->constructor->common.fn_flags & ZEND_ACC_PUBLIC);
3817: }
3818: /* }}} */
3819:
3820: /* {{{ proto public bool ReflectionClass::isInterface()
3821: Returns whether this is an interface or a class */
3822: ZEND_METHOD(reflection_class, isInterface)
3823: {
3824: _class_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_INTERFACE);
3825: }
3826: /* }}} */
3827:
3828: /* {{{ proto public bool ReflectionClass::isFinal()
3829: Returns whether this class is final */
3830: ZEND_METHOD(reflection_class, isFinal)
3831: {
3832: _class_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_FINAL_CLASS);
3833: }
3834: /* }}} */
3835:
3836: /* {{{ proto public bool ReflectionClass::isAbstract()
3837: Returns whether this class is abstract */
3838: ZEND_METHOD(reflection_class, isAbstract)
3839: {
3840: _class_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS);
3841: }
3842: /* }}} */
3843:
3844: /* {{{ proto public int ReflectionClass::getModifiers()
3845: Returns a bitfield of the access modifiers for this class */
3846: ZEND_METHOD(reflection_class, getModifiers)
3847: {
3848: reflection_object *intern;
3849: zend_class_entry *ce;
3850:
3851: if (zend_parse_parameters_none() == FAILURE) {
3852: return;
3853: }
3854: GET_REFLECTION_OBJECT_PTR(ce);
3855:
3856: RETURN_LONG(ce->ce_flags);
3857: }
3858: /* }}} */
3859:
3860: /* {{{ proto public bool ReflectionClass::isInstance(stdclass object)
3861: Returns whether the given object is an instance of this class */
3862: ZEND_METHOD(reflection_class, isInstance)
3863: {
3864: reflection_object *intern;
3865: zend_class_entry *ce;
3866: zval *object;
3867:
3868: METHOD_NOTSTATIC(reflection_class_ptr);
3869: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &object) == FAILURE) {
3870: return;
3871: }
3872: GET_REFLECTION_OBJECT_PTR(ce);
3873: RETURN_BOOL(HAS_CLASS_ENTRY(*object) && instanceof_function(Z_OBJCE_P(object), ce TSRMLS_CC));
3874: }
3875: /* }}} */
3876:
3877: /* {{{ proto public stdclass ReflectionClass::newInstance(mixed* args, ...)
3878: Returns an instance of this class */
3879: ZEND_METHOD(reflection_class, newInstance)
3880: {
3881: zval *retval_ptr = NULL;
3882: reflection_object *intern;
3883: zend_class_entry *ce;
3884:
3885: METHOD_NOTSTATIC(reflection_class_ptr);
3886: GET_REFLECTION_OBJECT_PTR(ce);
3887:
3888: /* Run the constructor if there is one */
3889: if (ce->constructor) {
3890: zval ***params = NULL;
3891: int num_args = 0;
3892: zend_fcall_info fci;
3893: zend_fcall_info_cache fcc;
3894:
3895: if (!(ce->constructor->common.fn_flags & ZEND_ACC_PUBLIC)) {
3896: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC, "Access to non-public constructor of class %s", ce->name);
3897: return;
3898: }
3899:
3900: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "*", ¶ms, &num_args) == FAILURE) {
3901: if (params) {
3902: efree(params);
3903: }
3904: RETURN_FALSE;
3905: }
3906:
3907: object_init_ex(return_value, ce);
3908:
3909: fci.size = sizeof(fci);
3910: fci.function_table = EG(function_table);
3911: fci.function_name = NULL;
3912: fci.symbol_table = NULL;
3913: fci.object_ptr = return_value;
3914: fci.retval_ptr_ptr = &retval_ptr;
3915: fci.param_count = num_args;
3916: fci.params = params;
3917: fci.no_separation = 1;
3918:
3919: fcc.initialized = 1;
3920: fcc.function_handler = ce->constructor;
3921: fcc.calling_scope = EG(scope);
3922: fcc.called_scope = Z_OBJCE_P(return_value);
3923: fcc.object_ptr = return_value;
3924:
3925: if (zend_call_function(&fci, &fcc TSRMLS_CC) == FAILURE) {
3926: if (params) {
3927: efree(params);
3928: }
3929: if (retval_ptr) {
3930: zval_ptr_dtor(&retval_ptr);
3931: }
3932: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invocation of %s's constructor failed", ce->name);
3933: RETURN_NULL();
3934: }
3935: if (retval_ptr) {
3936: zval_ptr_dtor(&retval_ptr);
3937: }
3938: if (params) {
3939: efree(params);
3940: }
3941: } else if (!ZEND_NUM_ARGS()) {
3942: object_init_ex(return_value, ce);
3943: } else {
3944: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC, "Class %s does not have a constructor, so you cannot pass any constructor arguments", ce->name);
3945: }
3946: }
3947: /* }}} */
3948:
3949: /* {{{ proto public stdclass ReflectionClass::newInstanceArgs([array args])
3950: Returns an instance of this class */
3951: ZEND_METHOD(reflection_class, newInstanceArgs)
3952: {
3953: zval *retval_ptr = NULL;
3954: reflection_object *intern;
3955: zend_class_entry *ce;
3956: int argc = 0;
3957: HashTable *args;
3958:
3959:
3960: METHOD_NOTSTATIC(reflection_class_ptr);
3961: GET_REFLECTION_OBJECT_PTR(ce);
3962:
3963: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|h", &args) == FAILURE) {
3964: return;
3965: }
3966: if (ZEND_NUM_ARGS() > 0) {
3967: argc = args->nNumOfElements;
3968: }
3969:
3970: /* Run the constructor if there is one */
3971: if (ce->constructor) {
3972: zval ***params = NULL;
3973: zend_fcall_info fci;
3974: zend_fcall_info_cache fcc;
3975:
3976: if (!(ce->constructor->common.fn_flags & ZEND_ACC_PUBLIC)) {
3977: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC, "Access to non-public constructor of class %s", ce->name);
3978: return;
3979: }
3980:
3981: if (argc) {
3982: params = safe_emalloc(sizeof(zval **), argc, 0);
3983: zend_hash_apply_with_argument(args, (apply_func_arg_t)_zval_array_to_c_array, ¶ms TSRMLS_CC);
3984: params -= argc;
3985: }
3986:
3987: object_init_ex(return_value, ce);
3988:
3989: fci.size = sizeof(fci);
3990: fci.function_table = EG(function_table);
3991: fci.function_name = NULL;
3992: fci.symbol_table = NULL;
3993: fci.object_ptr = return_value;
3994: fci.retval_ptr_ptr = &retval_ptr;
3995: fci.param_count = argc;
3996: fci.params = params;
3997: fci.no_separation = 1;
3998:
3999: fcc.initialized = 1;
4000: fcc.function_handler = ce->constructor;
4001: fcc.calling_scope = EG(scope);
4002: fcc.called_scope = Z_OBJCE_P(return_value);
4003: fcc.object_ptr = return_value;
4004:
4005: if (zend_call_function(&fci, &fcc TSRMLS_CC) == FAILURE) {
4006: if (params) {
4007: efree(params);
4008: }
4009: if (retval_ptr) {
4010: zval_ptr_dtor(&retval_ptr);
4011: }
4012: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invocation of %s's constructor failed", ce->name);
4013: RETURN_NULL();
4014: }
4015: if (retval_ptr) {
4016: zval_ptr_dtor(&retval_ptr);
4017: }
4018: if (params) {
4019: efree(params);
4020: }
4021: } else if (!ZEND_NUM_ARGS() || !argc) {
4022: object_init_ex(return_value, ce);
4023: } else {
4024: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC, "Class %s does not have a constructor, so you cannot pass any constructor arguments", ce->name);
4025: }
4026: }
4027: /* }}} */
4028:
4029: /* {{{ proto public ReflectionClass[] ReflectionClass::getInterfaces()
4030: Returns an array of interfaces this class implements */
4031: ZEND_METHOD(reflection_class, getInterfaces)
4032: {
4033: reflection_object *intern;
4034: zend_class_entry *ce;
4035:
4036: if (zend_parse_parameters_none() == FAILURE) {
4037: return;
4038: }
4039: GET_REFLECTION_OBJECT_PTR(ce);
4040:
4041: /* Return an empty array if this class implements no interfaces */
4042: array_init(return_value);
4043:
4044: if (ce->num_interfaces) {
4045: zend_uint i;
4046:
4047: for (i=0; i < ce->num_interfaces; i++) {
4048: zval *interface;
4049: ALLOC_ZVAL(interface);
4050: zend_reflection_class_factory(ce->interfaces[i], interface TSRMLS_CC);
4051: add_assoc_zval_ex(return_value, ce->interfaces[i]->name, ce->interfaces[i]->name_length + 1, interface);
4052: }
4053: }
4054: }
4055: /* }}} */
4056:
4057: /* {{{ proto public String[] ReflectionClass::getInterfaceNames()
4058: Returns an array of names of interfaces this class implements */
4059: ZEND_METHOD(reflection_class, getInterfaceNames)
4060: {
4061: reflection_object *intern;
4062: zend_class_entry *ce;
4063: zend_uint i;
4064:
4065: if (zend_parse_parameters_none() == FAILURE) {
4066: return;
4067: }
4068: GET_REFLECTION_OBJECT_PTR(ce);
4069:
4070: /* Return an empty array if this class implements no interfaces */
4071: array_init(return_value);
4072:
4073: for (i=0; i < ce->num_interfaces; i++) {
4074: add_next_index_stringl(return_value, ce->interfaces[i]->name, ce->interfaces[i]->name_length, 1);
4075: }
4076: }
4077: /* }}} */
4078:
4079: /* {{{ proto public ReflectionClass ReflectionClass::getParentClass()
4080: Returns the class' parent class, or, if none exists, FALSE */
4081: ZEND_METHOD(reflection_class, getParentClass)
4082: {
4083: reflection_object *intern;
4084: zend_class_entry *ce;
4085:
4086: if (zend_parse_parameters_none() == FAILURE) {
4087: return;
4088: }
4089: GET_REFLECTION_OBJECT_PTR(ce);
4090:
4091: if (ce->parent) {
4092: zend_reflection_class_factory(ce->parent, return_value TSRMLS_CC);
4093: } else {
4094: RETURN_FALSE;
4095: }
4096: }
4097: /* }}} */
4098:
4099: /* {{{ proto public bool ReflectionClass::isSubclassOf(string|ReflectionClass class)
4100: Returns whether this class is a subclass of another class */
4101: ZEND_METHOD(reflection_class, isSubclassOf)
4102: {
4103: reflection_object *intern, *argument;
4104: zend_class_entry *ce, **pce, *class_ce;
4105: zval *class_name;
4106:
4107: METHOD_NOTSTATIC(reflection_class_ptr);
4108: GET_REFLECTION_OBJECT_PTR(ce);
4109:
4110: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &class_name) == FAILURE) {
4111: return;
4112: }
4113:
4114: switch(class_name->type) {
4115: case IS_STRING:
4116: if (zend_lookup_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), &pce TSRMLS_CC) == FAILURE) {
4117: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
4118: "Class %s does not exist", Z_STRVAL_P(class_name));
4119: return;
4120: }
4121: class_ce = *pce;
4122: break;
4123: case IS_OBJECT:
4124: if (instanceof_function(Z_OBJCE_P(class_name), reflection_class_ptr TSRMLS_CC)) {
4125: argument = (reflection_object *) zend_object_store_get_object(class_name TSRMLS_CC);
4126: if (argument == NULL || argument->ptr == NULL) {
4127: php_error_docref(NULL TSRMLS_CC, E_ERROR, "Internal error: Failed to retrieve the argument's reflection object");
4128: /* Bails out */
4129: }
4130: class_ce = argument->ptr;
4131: break;
4132: }
4133: /* no break */
4134: default:
4135: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
4136: "Parameter one must either be a string or a ReflectionClass object");
4137: return;
4138: }
4139:
4140: RETURN_BOOL((ce != class_ce && instanceof_function(ce, class_ce TSRMLS_CC)));
4141: }
4142: /* }}} */
4143:
4144: /* {{{ proto public bool ReflectionClass::implementsInterface(string|ReflectionClass interface_name)
4145: Returns whether this class is a subclass of another class */
4146: ZEND_METHOD(reflection_class, implementsInterface)
4147: {
4148: reflection_object *intern, *argument;
4149: zend_class_entry *ce, *interface_ce, **pce;
4150: zval *interface;
4151:
4152: METHOD_NOTSTATIC(reflection_class_ptr);
4153: GET_REFLECTION_OBJECT_PTR(ce);
4154:
4155: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &interface) == FAILURE) {
4156: return;
4157: }
4158:
4159: switch(interface->type) {
4160: case IS_STRING:
4161: if (zend_lookup_class(Z_STRVAL_P(interface), Z_STRLEN_P(interface), &pce TSRMLS_CC) == FAILURE) {
4162: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
4163: "Interface %s does not exist", Z_STRVAL_P(interface));
4164: return;
4165: }
4166: interface_ce = *pce;
4167: break;
4168: case IS_OBJECT:
4169: if (instanceof_function(Z_OBJCE_P(interface), reflection_class_ptr TSRMLS_CC)) {
4170: argument = (reflection_object *) zend_object_store_get_object(interface TSRMLS_CC);
4171: if (argument == NULL || argument->ptr == NULL) {
4172: php_error_docref(NULL TSRMLS_CC, E_ERROR, "Internal error: Failed to retrieve the argument's reflection object");
4173: /* Bails out */
4174: }
4175: interface_ce = argument->ptr;
4176: break;
4177: }
4178: /* no break */
4179: default:
4180: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
4181: "Parameter one must either be a string or a ReflectionClass object");
4182: return;
4183: }
4184:
4185: if (!(interface_ce->ce_flags & ZEND_ACC_INTERFACE)) {
4186: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
4187: "Interface %s is a Class", interface_ce->name);
4188: return;
4189: }
4190: RETURN_BOOL(instanceof_function(ce, interface_ce TSRMLS_CC));
4191: }
4192: /* }}} */
4193:
4194: /* {{{ proto public bool ReflectionClass::isIterateable()
4195: Returns whether this class is iterateable (can be used inside foreach) */
4196: ZEND_METHOD(reflection_class, isIterateable)
4197: {
4198: reflection_object *intern;
4199: zend_class_entry *ce;
4200:
4201: if (zend_parse_parameters_none() == FAILURE) {
4202: return;
4203: }
4204:
4205: METHOD_NOTSTATIC(reflection_class_ptr);
4206: GET_REFLECTION_OBJECT_PTR(ce);
4207:
4208: RETURN_BOOL(ce->get_iterator != NULL);
4209: }
4210: /* }}} */
4211:
4212: /* {{{ proto public ReflectionExtension|NULL ReflectionClass::getExtension()
4213: Returns NULL or the extension the class belongs to */
4214: ZEND_METHOD(reflection_class, getExtension)
4215: {
4216: reflection_object *intern;
4217: zend_class_entry *ce;
4218:
4219: if (zend_parse_parameters_none() == FAILURE) {
4220: return;
4221: }
4222:
4223: METHOD_NOTSTATIC(reflection_class_ptr);
4224: GET_REFLECTION_OBJECT_PTR(ce);
4225:
4226: if (ce->module) {
4227: reflection_extension_factory(return_value, ce->module->name TSRMLS_CC);
4228: }
4229: }
4230: /* }}} */
4231:
4232: /* {{{ proto public string|false ReflectionClass::getExtensionName()
4233: Returns false or the name of the extension the class belongs to */
4234: ZEND_METHOD(reflection_class, getExtensionName)
4235: {
4236: reflection_object *intern;
4237: zend_class_entry *ce;
4238:
4239: if (zend_parse_parameters_none() == FAILURE) {
4240: return;
4241: }
4242:
4243: METHOD_NOTSTATIC(reflection_class_ptr);
4244: GET_REFLECTION_OBJECT_PTR(ce);
4245:
4246: if (ce->module) {
4247: RETURN_STRING(ce->module->name, 1);
4248: } else {
4249: RETURN_FALSE;
4250: }
4251: }
4252: /* }}} */
4253:
4254: /* {{{ proto public bool ReflectionClass::inNamespace()
4255: Returns whether this class is defined in namespace */
4256: ZEND_METHOD(reflection_class, inNamespace)
4257: {
4258: zval **name;
4259: char *colon;
4260:
4261: if (zend_parse_parameters_none() == FAILURE) {
4262: return;
4263: }
4264: if (zend_hash_find(Z_OBJPROP_P(getThis()), "name", sizeof("name"), (void **) &name) == FAILURE) {
4265: RETURN_FALSE;
4266: }
4267: if (Z_TYPE_PP(name) == IS_STRING
4268: && (colon = zend_memrchr(Z_STRVAL_PP(name), '\\', Z_STRLEN_PP(name)))
4269: && colon > Z_STRVAL_PP(name))
4270: {
4271: RETURN_TRUE;
4272: }
4273: RETURN_FALSE;
4274: }
4275: /* }}} */
4276:
4277: /* {{{ proto public string ReflectionClass::getNamespaceName()
4278: Returns the name of namespace where this class is defined */
4279: ZEND_METHOD(reflection_class, getNamespaceName)
4280: {
4281: zval **name;
4282: char *backslash;
4283:
4284: if (zend_parse_parameters_none() == FAILURE) {
4285: return;
4286: }
4287: if (zend_hash_find(Z_OBJPROP_P(getThis()), "name", sizeof("name"), (void **) &name) == FAILURE) {
4288: RETURN_FALSE;
4289: }
4290: if (Z_TYPE_PP(name) == IS_STRING
4291: && (backslash = zend_memrchr(Z_STRVAL_PP(name), '\\', Z_STRLEN_PP(name)))
4292: && backslash > Z_STRVAL_PP(name))
4293: {
4294: RETURN_STRINGL(Z_STRVAL_PP(name), backslash - Z_STRVAL_PP(name), 1);
4295: }
4296: RETURN_EMPTY_STRING();
4297: }
4298: /* }}} */
4299:
4300: /* {{{ proto public string ReflectionClass::getShortName()
4301: Returns the short name of the class (without namespace part) */
4302: ZEND_METHOD(reflection_class, getShortName)
4303: {
4304: zval **name;
4305: char *backslash;
4306:
4307: if (zend_parse_parameters_none() == FAILURE) {
4308: return;
4309: }
4310: if (zend_hash_find(Z_OBJPROP_P(getThis()), "name", sizeof("name"), (void **) &name) == FAILURE) {
4311: RETURN_FALSE;
4312: }
4313: if (Z_TYPE_PP(name) == IS_STRING
4314: && (backslash = zend_memrchr(Z_STRVAL_PP(name), '\\', Z_STRLEN_PP(name)))
4315: && backslash > Z_STRVAL_PP(name))
4316: {
4317: RETURN_STRINGL(backslash + 1, Z_STRLEN_PP(name) - (backslash - Z_STRVAL_PP(name) + 1), 1);
4318: }
4319: RETURN_ZVAL(*name, 1, 0);
4320: }
4321: /* }}} */
4322:
4323: /* {{{ proto public static mixed ReflectionObject::export(mixed argument [, bool return]) throws ReflectionException
4324: Exports a reflection object. Returns the output if TRUE is specified for return, printing it otherwise. */
4325: ZEND_METHOD(reflection_object, export)
4326: {
4327: _reflection_export(INTERNAL_FUNCTION_PARAM_PASSTHRU, reflection_object_ptr, 1);
4328: }
4329: /* }}} */
4330:
4331: /* {{{ proto public void ReflectionObject::__construct(mixed argument) throws ReflectionException
4332: Constructor. Takes an instance as an argument */
4333: ZEND_METHOD(reflection_object, __construct)
4334: {
4335: reflection_class_object_ctor(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
4336: }
4337: /* }}} */
4338:
4339: /* {{{ proto public static mixed ReflectionProperty::export(mixed class, string name [, bool return]) throws ReflectionException
4340: Exports a reflection object. Returns the output if TRUE is specified for return, printing it otherwise. */
4341: ZEND_METHOD(reflection_property, export)
4342: {
4343: _reflection_export(INTERNAL_FUNCTION_PARAM_PASSTHRU, reflection_property_ptr, 2);
4344: }
4345: /* }}} */
4346:
4347: /* {{{ proto public void ReflectionProperty::__construct(mixed class, string name)
4348: Constructor. Throws an Exception in case the given property does not exist */
4349: ZEND_METHOD(reflection_property, __construct)
4350: {
4351: zval *propname, *classname;
4352: char *name_str, *class_name, *prop_name;
4353: int name_len, dynam_prop = 0;
4354: zval *object;
4355: reflection_object *intern;
4356: zend_class_entry **pce;
4357: zend_class_entry *ce;
4358: zend_property_info *property_info = NULL;
4359: property_reference *reference;
4360:
4361: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zs", &classname, &name_str, &name_len) == FAILURE) {
4362: return;
4363: }
4364:
4365: object = getThis();
4366: intern = (reflection_object *) zend_object_store_get_object(object TSRMLS_CC);
4367: if (intern == NULL) {
4368: return;
4369: }
4370:
4371: /* Find the class entry */
4372: switch (Z_TYPE_P(classname)) {
4373: case IS_STRING:
4374: if (zend_lookup_class(Z_STRVAL_P(classname), Z_STRLEN_P(classname), &pce TSRMLS_CC) == FAILURE) {
4375: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
4376: "Class %s does not exist", Z_STRVAL_P(classname));
4377: return;
4378: }
4379: ce = *pce;
4380: break;
4381:
4382: case IS_OBJECT:
4383: ce = Z_OBJCE_P(classname);
4384: break;
4385:
4386: default:
4387: _DO_THROW("The parameter class is expected to be either a string or an object");
4388: /* returns out of this function */
4389: }
4390:
4391: if (zend_hash_find(&ce->properties_info, name_str, name_len + 1, (void **) &property_info) == FAILURE || (property_info->flags & ZEND_ACC_SHADOW)) {
4392: /* Check for dynamic properties */
4393: if (property_info == NULL && Z_TYPE_P(classname) == IS_OBJECT && Z_OBJ_HT_P(classname)->get_properties) {
4394: if (zend_hash_exists(Z_OBJ_HT_P(classname)->get_properties(classname TSRMLS_CC), name_str, name_len+1)) {
4395: dynam_prop = 1;
4396: }
4397: }
4398: if (dynam_prop == 0) {
4399: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC, "Property %s::$%s does not exist", ce->name, name_str);
4400: return;
4401: }
4402: }
4403:
4404: if (dynam_prop == 0 && (property_info->flags & ZEND_ACC_PRIVATE) == 0) {
4405: /* we have to search the class hierarchy for this (implicit) public or protected property */
4406: zend_class_entry *tmp_ce = ce;
4407: zend_property_info *tmp_info;
4408:
4409: while (tmp_ce && zend_hash_find(&tmp_ce->properties_info, name_str, name_len + 1, (void **) &tmp_info) != SUCCESS) {
4410: ce = tmp_ce;
4411: property_info = tmp_info;
4412: tmp_ce = tmp_ce->parent;
4413: }
4414: }
4415:
4416: MAKE_STD_ZVAL(classname);
4417: MAKE_STD_ZVAL(propname);
4418:
4419: if (dynam_prop == 0) {
4420: zend_unmangle_property_name(property_info->name, property_info->name_length, &class_name, &prop_name);
4421: ZVAL_STRINGL(classname, property_info->ce->name, property_info->ce->name_length, 1);
4422: ZVAL_STRING(propname, prop_name, 1);
4423: } else {
4424: ZVAL_STRINGL(classname, ce->name, ce->name_length, 1);
4425: ZVAL_STRINGL(propname, name_str, name_len, 1);
4426: }
4427: zend_hash_update(Z_OBJPROP_P(object), "class", sizeof("class"), (void **) &classname, sizeof(zval *), NULL);
4428: zend_hash_update(Z_OBJPROP_P(object), "name", sizeof("name"), (void **) &propname, sizeof(zval *), NULL);
4429:
4430: reference = (property_reference*) emalloc(sizeof(property_reference));
4431: if (dynam_prop) {
4432: reference->prop.flags = ZEND_ACC_IMPLICIT_PUBLIC;
4433: reference->prop.name = Z_STRVAL_P(propname);
4434: reference->prop.name_length = Z_STRLEN_P(propname);
4435: reference->prop.h = zend_get_hash_value(name_str, name_len+1);
4436: reference->prop.doc_comment = NULL;
4437: reference->prop.ce = ce;
4438: } else {
4439: reference->prop = *property_info;
4440: }
4441: reference->ce = ce;
4442: intern->ptr = reference;
4443: intern->ref_type = REF_TYPE_PROPERTY;
4444: intern->ce = ce;
4445: intern->ignore_visibility = 0;
4446: }
4447: /* }}} */
4448:
4449: /* {{{ proto public string ReflectionProperty::__toString()
4450: Returns a string representation */
4451: ZEND_METHOD(reflection_property, __toString)
4452: {
4453: reflection_object *intern;
4454: property_reference *ref;
4455: string str;
4456:
4457: if (zend_parse_parameters_none() == FAILURE) {
4458: return;
4459: }
4460: GET_REFLECTION_OBJECT_PTR(ref);
4461: string_init(&str);
4462: _property_string(&str, &ref->prop, NULL, "" TSRMLS_CC);
4463: RETURN_STRINGL(str.string, str.len - 1, 0);
4464: }
4465: /* }}} */
4466:
4467: /* {{{ proto public string ReflectionProperty::getName()
4468: Returns the class' name */
4469: ZEND_METHOD(reflection_property, getName)
4470: {
4471: if (zend_parse_parameters_none() == FAILURE) {
4472: return;
4473: }
4474: _default_get_entry(getThis(), "name", sizeof("name"), return_value TSRMLS_CC);
4475: }
4476: /* }}} */
4477:
4478: static void _property_check_flag(INTERNAL_FUNCTION_PARAMETERS, int mask)
4479: {
4480: reflection_object *intern;
4481: property_reference *ref;
4482:
4483: if (zend_parse_parameters_none() == FAILURE) {
4484: return;
4485: }
4486: GET_REFLECTION_OBJECT_PTR(ref);
4487: RETURN_BOOL(ref->prop.flags & mask);
4488: }
4489:
4490: /* {{{ proto public bool ReflectionProperty::isPublic()
4491: Returns whether this property is public */
4492: ZEND_METHOD(reflection_property, isPublic)
4493: {
4494: _property_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_PUBLIC | ZEND_ACC_IMPLICIT_PUBLIC);
4495: }
4496: /* }}} */
4497:
4498: /* {{{ proto public bool ReflectionProperty::isPrivate()
4499: Returns whether this property is private */
4500: ZEND_METHOD(reflection_property, isPrivate)
4501: {
4502: _property_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_PRIVATE);
4503: }
4504: /* }}} */
4505:
4506: /* {{{ proto public bool ReflectionProperty::isProtected()
4507: Returns whether this property is protected */
4508: ZEND_METHOD(reflection_property, isProtected)
4509: {
4510: _property_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_PROTECTED);
4511: }
4512: /* }}} */
4513:
4514: /* {{{ proto public bool ReflectionProperty::isStatic()
4515: Returns whether this property is static */
4516: ZEND_METHOD(reflection_property, isStatic)
4517: {
4518: _property_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_STATIC);
4519: }
4520: /* }}} */
4521:
4522: /* {{{ proto public bool ReflectionProperty::isDefault()
4523: Returns whether this property is default (declared at compilation time). */
4524: ZEND_METHOD(reflection_property, isDefault)
4525: {
4526: _property_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ~ZEND_ACC_IMPLICIT_PUBLIC);
4527: }
4528: /* }}} */
4529:
4530: /* {{{ proto public int ReflectionProperty::getModifiers()
4531: Returns a bitfield of the access modifiers for this property */
4532: ZEND_METHOD(reflection_property, getModifiers)
4533: {
4534: reflection_object *intern;
4535: property_reference *ref;
4536:
4537: if (zend_parse_parameters_none() == FAILURE) {
4538: return;
4539: }
4540: GET_REFLECTION_OBJECT_PTR(ref);
4541:
4542: RETURN_LONG(ref->prop.flags);
4543: }
4544: /* }}} */
4545:
4546: /* {{{ proto public mixed ReflectionProperty::getValue([stdclass object])
4547: Returns this property's value */
4548: ZEND_METHOD(reflection_property, getValue)
4549: {
4550: reflection_object *intern;
4551: property_reference *ref;
4552: zval *object, name;
4553: zval **member = NULL, *member_p = NULL;
4554:
4555: METHOD_NOTSTATIC(reflection_property_ptr);
4556: GET_REFLECTION_OBJECT_PTR(ref);
4557:
4558: if (!(ref->prop.flags & (ZEND_ACC_PUBLIC | ZEND_ACC_IMPLICIT_PUBLIC)) && intern->ignore_visibility == 0) {
4559: _default_get_entry(getThis(), "name", sizeof("name"), &name TSRMLS_CC);
4560: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
4561: "Cannot access non-public member %s::%s", intern->ce->name, Z_STRVAL(name));
4562: zval_dtor(&name);
4563: return;
4564: }
4565:
4566: if ((ref->prop.flags & ZEND_ACC_STATIC)) {
4567: zend_update_class_constants(intern->ce TSRMLS_CC);
4568: if (zend_hash_quick_find(CE_STATIC_MEMBERS(intern->ce), ref->prop.name, ref->prop.name_length + 1, ref->prop.h, (void **) &member) == FAILURE) {
4569: php_error_docref(NULL TSRMLS_CC, E_ERROR, "Internal error: Could not find the property %s::%s", intern->ce->name, ref->prop.name);
4570: /* Bails out */
4571: }
4572: MAKE_COPY_ZVAL(member, return_value);
4573: } else {
4574: char *class_name, *prop_name;
4575:
4576: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &object) == FAILURE) {
4577: return;
4578: }
4579: zend_unmangle_property_name(ref->prop.name, ref->prop.name_length, &class_name, &prop_name);
4580: member_p = zend_read_property(ref->ce, object, prop_name, strlen(prop_name), 1 TSRMLS_CC);
4581: MAKE_COPY_ZVAL(&member_p, return_value);
4582: if (member_p != EG(uninitialized_zval_ptr)) {
4583: zval_add_ref(&member_p);
4584: zval_ptr_dtor(&member_p);
4585: }
4586: }
4587: }
4588: /* }}} */
4589:
4590: /* {{{ proto public void ReflectionProperty::setValue([stdclass object,] mixed value)
4591: Sets this property's value */
4592: ZEND_METHOD(reflection_property, setValue)
4593: {
4594: reflection_object *intern;
4595: property_reference *ref;
4596: zval **variable_ptr;
4597: zval *object, name;
4598: zval *value;
4599: int setter_done = 0;
4600: zval *tmp;
4601: HashTable *prop_table;
4602:
4603: METHOD_NOTSTATIC(reflection_property_ptr);
4604: GET_REFLECTION_OBJECT_PTR(ref);
4605:
4606: if (!(ref->prop.flags & ZEND_ACC_PUBLIC) && intern->ignore_visibility == 0) {
4607: _default_get_entry(getThis(), "name", sizeof("name"), &name TSRMLS_CC);
4608: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
4609: "Cannot access non-public member %s::%s", intern->ce->name, Z_STRVAL(name));
4610: zval_dtor(&name);
4611: return;
4612: }
4613:
4614: if ((ref->prop.flags & ZEND_ACC_STATIC)) {
4615: if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "z", &value) == FAILURE) {
4616: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &tmp, &value) == FAILURE) {
4617: return;
4618: }
4619: }
4620: zend_update_class_constants(intern->ce TSRMLS_CC);
4621: prop_table = CE_STATIC_MEMBERS(intern->ce);
4622:
4623: if (zend_hash_quick_find(prop_table, ref->prop.name, ref->prop.name_length + 1, ref->prop.h, (void **) &variable_ptr) == FAILURE) {
4624: php_error_docref(NULL TSRMLS_CC, E_ERROR, "Internal error: Could not find the property %s::%s", intern->ce->name, ref->prop.name);
4625: /* Bails out */
4626: }
4627: if (*variable_ptr == value) {
4628: setter_done = 1;
4629: } else {
4630: if (PZVAL_IS_REF(*variable_ptr)) {
4631: zval_dtor(*variable_ptr);
4632: (*variable_ptr)->type = value->type;
4633: (*variable_ptr)->value = value->value;
4634: if (Z_REFCOUNT_P(value) > 0) {
4635: zval_copy_ctor(*variable_ptr);
4636: }
4637: setter_done = 1;
4638: }
4639: }
4640: if (!setter_done) {
4641: zval **foo;
4642:
4643: Z_ADDREF_P(value);
4644: if (PZVAL_IS_REF(value)) {
4645: SEPARATE_ZVAL(&value);
4646: }
4647: zend_hash_quick_update(prop_table, ref->prop.name, ref->prop.name_length+1, ref->prop.h, &value, sizeof(zval *), (void **) &foo);
4648: }
4649: } else {
4650: char *class_name, *prop_name;
4651:
4652: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "oz", &object, &value) == FAILURE) {
4653: return;
4654: }
4655: zend_unmangle_property_name(ref->prop.name, ref->prop.name_length, &class_name, &prop_name);
4656: zend_update_property(ref->ce, object, prop_name, strlen(prop_name), value TSRMLS_CC);
4657: }
4658: }
4659: /* }}} */
4660:
4661: /* {{{ proto public ReflectionClass ReflectionProperty::getDeclaringClass()
4662: Get the declaring class */
4663: ZEND_METHOD(reflection_property, getDeclaringClass)
4664: {
4665: reflection_object *intern;
4666: property_reference *ref;
4667: zend_class_entry *tmp_ce, *ce;
4668: zend_property_info *tmp_info;
4669: char *prop_name, *class_name;
4670: int prop_name_len;
4671:
4672: if (zend_parse_parameters_none() == FAILURE) {
4673: return;
4674: }
4675: GET_REFLECTION_OBJECT_PTR(ref);
4676:
4677: if (zend_unmangle_property_name(ref->prop.name, ref->prop.name_length, &class_name, &prop_name) != SUCCESS) {
4678: RETURN_FALSE;
4679: }
4680:
4681: prop_name_len = strlen(prop_name);
4682: ce = tmp_ce = ref->ce;
4683: while (tmp_ce && zend_hash_find(&tmp_ce->properties_info, prop_name, prop_name_len + 1, (void **) &tmp_info) == SUCCESS) {
4684: if (tmp_info->flags & ZEND_ACC_PRIVATE || tmp_info->flags & ZEND_ACC_SHADOW) {
4685: /* it's a private property, so it can't be inherited */
4686: break;
4687: }
4688: ce = tmp_ce;
4689: if (tmp_ce == tmp_info->ce) {
4690: /* declared in this class, done */
4691: break;
4692: }
4693: tmp_ce = tmp_ce->parent;
4694: }
4695:
4696: zend_reflection_class_factory(ce, return_value TSRMLS_CC);
4697: }
4698: /* }}} */
4699:
4700: /* {{{ proto public string ReflectionProperty::getDocComment()
4701: Returns the doc comment for this property */
4702: ZEND_METHOD(reflection_property, getDocComment)
4703: {
4704: reflection_object *intern;
4705: property_reference *ref;
4706:
4707: if (zend_parse_parameters_none() == FAILURE) {
4708: return;
4709: }
4710: GET_REFLECTION_OBJECT_PTR(ref);
4711: if (ref->prop.doc_comment) {
4712: RETURN_STRINGL(ref->prop.doc_comment, ref->prop.doc_comment_len, 1);
4713: }
4714: RETURN_FALSE;
4715: }
4716: /* }}} */
4717:
4718: /* {{{ proto public int ReflectionProperty::setAccessible(bool visible)
4719: Sets whether non-public properties can be requested */
4720: ZEND_METHOD(reflection_property, setAccessible)
4721: {
4722: reflection_object *intern;
4723: zend_bool visible;
4724:
4725: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "b", &visible) == FAILURE) {
4726: return;
4727: }
4728:
4729: intern = (reflection_object *) zend_object_store_get_object(getThis() TSRMLS_CC);
4730:
4731: if (intern == NULL) {
4732: return;
4733: }
4734:
4735: intern->ignore_visibility = visible;
4736: }
4737: /* }}} */
4738:
4739: /* {{{ proto public static mixed ReflectionExtension::export(string name [, bool return]) throws ReflectionException
4740: Exports a reflection object. Returns the output if TRUE is specified for return, printing it otherwise. */
4741: ZEND_METHOD(reflection_extension, export)
4742: {
4743: _reflection_export(INTERNAL_FUNCTION_PARAM_PASSTHRU, reflection_extension_ptr, 1);
4744: }
4745: /* }}} */
4746:
4747: /* {{{ proto public void ReflectionExtension::__construct(string name)
4748: Constructor. Throws an Exception in case the given extension does not exist */
4749: ZEND_METHOD(reflection_extension, __construct)
4750: {
4751: zval *name;
4752: zval *object;
4753: char *lcname;
4754: reflection_object *intern;
4755: zend_module_entry *module;
4756: char *name_str;
4757: int name_len;
4758: ALLOCA_FLAG(use_heap)
4759:
4760: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name_str, &name_len) == FAILURE) {
4761: return;
4762: }
4763:
4764: object = getThis();
4765: intern = (reflection_object *) zend_object_store_get_object(object TSRMLS_CC);
4766: if (intern == NULL) {
4767: return;
4768: }
4769: lcname = do_alloca(name_len + 1, use_heap);
4770: zend_str_tolower_copy(lcname, name_str, name_len);
4771: if (zend_hash_find(&module_registry, lcname, name_len + 1, (void **)&module) == FAILURE) {
4772: free_alloca(lcname, use_heap);
4773: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
4774: "Extension %s does not exist", name_str);
4775: return;
4776: }
4777: free_alloca(lcname, use_heap);
4778: MAKE_STD_ZVAL(name);
4779: ZVAL_STRING(name, module->name, 1);
4780: zend_hash_update(Z_OBJPROP_P(object), "name", sizeof("name"), (void **) &name, sizeof(zval *), NULL);
4781: intern->ptr = module;
4782: intern->ref_type = REF_TYPE_OTHER;
4783: intern->ce = NULL;
4784: }
4785: /* }}} */
4786:
4787: /* {{{ proto public string ReflectionExtension::__toString()
4788: Returns a string representation */
4789: ZEND_METHOD(reflection_extension, __toString)
4790: {
4791: reflection_object *intern;
4792: zend_module_entry *module;
4793: string str;
4794:
4795: if (zend_parse_parameters_none() == FAILURE) {
4796: return;
4797: }
4798: GET_REFLECTION_OBJECT_PTR(module);
4799: string_init(&str);
4800: _extension_string(&str, module, "" TSRMLS_CC);
4801: RETURN_STRINGL(str.string, str.len - 1, 0);
4802: }
4803: /* }}} */
4804:
4805: /* {{{ proto public string ReflectionExtension::getName()
4806: Returns this extension's name */
4807: ZEND_METHOD(reflection_extension, getName)
4808: {
4809: if (zend_parse_parameters_none() == FAILURE) {
4810: return;
4811: }
4812: _default_get_entry(getThis(), "name", sizeof("name"), return_value TSRMLS_CC);
4813: }
4814: /* }}} */
4815:
4816: /* {{{ proto public string ReflectionExtension::getVersion()
4817: Returns this extension's version */
4818: ZEND_METHOD(reflection_extension, getVersion)
4819: {
4820: reflection_object *intern;
4821: zend_module_entry *module;
4822:
4823: if (zend_parse_parameters_none() == FAILURE) {
4824: return;
4825: }
4826: GET_REFLECTION_OBJECT_PTR(module);
4827:
4828: /* An extension does not necessarily have a version number */
4829: if (module->version == NO_VERSION_YET) {
4830: RETURN_NULL();
4831: } else {
4832: RETURN_STRING(module->version, 1);
4833: }
4834: }
4835: /* }}} */
4836:
4837: /* {{{ proto public ReflectionFunction[] ReflectionExtension::getFunctions()
4838: Returns an array of this extension's fuctions */
4839: ZEND_METHOD(reflection_extension, getFunctions)
4840: {
4841: reflection_object *intern;
4842: zend_module_entry *module;
4843:
4844: if (zend_parse_parameters_none() == FAILURE) {
4845: return;
4846: }
4847: GET_REFLECTION_OBJECT_PTR(module);
4848:
4849: array_init(return_value);
4850: if (module->functions) {
4851: zval *function;
4852: zend_function *fptr;
4853: const zend_function_entry *func = module->functions;
4854:
4855: /* Is there a better way of doing this? */
4856: while (func->fname) {
4857: int fname_len = strlen(func->fname);
4858: char *lc_name = zend_str_tolower_dup(func->fname, fname_len);
4859:
4860: if (zend_hash_find(EG(function_table), lc_name, fname_len + 1, (void**) &fptr) == FAILURE) {
4861: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Internal error: Cannot find extension function %s in global function table", func->fname);
4862: func++;
4863: efree(lc_name);
4864: continue;
4865: }
4866:
4867: ALLOC_ZVAL(function);
4868: reflection_function_factory(fptr, NULL, function TSRMLS_CC);
4869: add_assoc_zval_ex(return_value, func->fname, fname_len+1, function);
4870: func++;
4871: efree(lc_name);
4872: }
4873: }
4874: }
4875: /* }}} */
4876:
4877: static int _addconstant(zend_constant *constant TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
4878: {
4879: zval *const_val;
4880: zval *retval = va_arg(args, zval*);
4881: int number = va_arg(args, int);
4882:
4883: if (number == constant->module_number) {
4884: ALLOC_ZVAL(const_val);
4885: *const_val = constant->value;
4886: zval_copy_ctor(const_val);
4887: INIT_PZVAL(const_val);
4888: add_assoc_zval_ex(retval, constant->name, constant->name_len, const_val);
4889: }
4890: return 0;
4891: }
4892:
4893: /* {{{ proto public array ReflectionExtension::getConstants()
4894: Returns an associative array containing this extension's constants and their values */
4895: ZEND_METHOD(reflection_extension, getConstants)
4896: {
4897: reflection_object *intern;
4898: zend_module_entry *module;
4899:
4900: if (zend_parse_parameters_none() == FAILURE) {
4901: return;
4902: }
4903: GET_REFLECTION_OBJECT_PTR(module);
4904:
4905: array_init(return_value);
4906: zend_hash_apply_with_arguments(EG(zend_constants) TSRMLS_CC, (apply_func_args_t) _addconstant, 2, return_value, module->module_number);
4907: }
4908: /* }}} */
4909:
4910: /* {{{ _addinientry */
4911: static int _addinientry(zend_ini_entry *ini_entry TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
4912: {
4913: zval *retval = va_arg(args, zval*);
4914: int number = va_arg(args, int);
4915:
4916: if (number == ini_entry->module_number) {
4917: if (ini_entry->value) {
4918: add_assoc_stringl(retval, ini_entry->name, ini_entry->value, ini_entry->value_length, 1);
4919: } else {
4920: add_assoc_null(retval, ini_entry->name);
4921: }
4922: }
4923: return ZEND_HASH_APPLY_KEEP;
4924: }
4925: /* }}} */
4926:
4927: /* {{{ proto public array ReflectionExtension::getINIEntries()
4928: Returns an associative array containing this extension's INI entries and their values */
4929: ZEND_METHOD(reflection_extension, getINIEntries)
4930: {
4931: reflection_object *intern;
4932: zend_module_entry *module;
4933:
4934: if (zend_parse_parameters_none() == FAILURE) {
4935: return;
4936: }
4937: GET_REFLECTION_OBJECT_PTR(module);
4938:
4939: array_init(return_value);
4940: zend_hash_apply_with_arguments(EG(ini_directives) TSRMLS_CC, (apply_func_args_t) _addinientry, 2, return_value, module->module_number);
4941: }
4942: /* }}} */
4943:
4944: /* {{{ add_extension_class */
4945: static int add_extension_class(zend_class_entry **pce TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
4946: {
4947: zval *class_array = va_arg(args, zval*), *zclass;
4948: struct _zend_module_entry *module = va_arg(args, struct _zend_module_entry*);
4949: int add_reflection_class = va_arg(args, int);
4950:
4951: if ((*pce)->module && !strcasecmp((*pce)->module->name, module->name)) {
4952: if (add_reflection_class) {
4953: ALLOC_ZVAL(zclass);
4954: zend_reflection_class_factory(*pce, zclass TSRMLS_CC);
4955: add_assoc_zval_ex(class_array, (*pce)->name, (*pce)->name_length + 1, zclass);
4956: } else {
4957: add_next_index_stringl(class_array, (*pce)->name, (*pce)->name_length, 1);
4958: }
4959: }
4960: return ZEND_HASH_APPLY_KEEP;
4961: }
4962: /* }}} */
4963:
4964: /* {{{ proto public ReflectionClass[] ReflectionExtension::getClasses()
4965: Returns an array containing ReflectionClass objects for all classes of this extension */
4966: ZEND_METHOD(reflection_extension, getClasses)
4967: {
4968: reflection_object *intern;
4969: zend_module_entry *module;
4970:
4971: if (zend_parse_parameters_none() == FAILURE) {
4972: return;
4973: }
4974: GET_REFLECTION_OBJECT_PTR(module);
4975:
4976: array_init(return_value);
4977: zend_hash_apply_with_arguments(EG(class_table) TSRMLS_CC, (apply_func_args_t) add_extension_class, 3, return_value, module, 1);
4978: }
4979: /* }}} */
4980:
4981: /* {{{ proto public array ReflectionExtension::getClassNames()
4982: Returns an array containing all names of all classes of this extension */
4983: ZEND_METHOD(reflection_extension, getClassNames)
4984: {
4985: reflection_object *intern;
4986: zend_module_entry *module;
4987:
4988: if (zend_parse_parameters_none() == FAILURE) {
4989: return;
4990: }
4991: GET_REFLECTION_OBJECT_PTR(module);
4992:
4993: array_init(return_value);
4994: zend_hash_apply_with_arguments(EG(class_table) TSRMLS_CC, (apply_func_args_t) add_extension_class, 3, return_value, module, 0);
4995: }
4996: /* }}} */
4997:
4998: /* {{{ proto public array ReflectionExtension::getDependencies()
4999: Returns an array containing all names of all extensions this extension depends on */
5000: ZEND_METHOD(reflection_extension, getDependencies)
5001: {
5002: reflection_object *intern;
5003: zend_module_entry *module;
5004: const zend_module_dep *dep;
5005:
5006: if (zend_parse_parameters_none() == FAILURE) {
5007: return;
5008: }
5009: GET_REFLECTION_OBJECT_PTR(module);
5010:
5011: array_init(return_value);
5012:
5013: dep = module->deps;
5014:
5015: if (!dep)
5016: {
5017: return;
5018: }
5019:
5020: while(dep->name) {
5021: char *relation;
5022: char *rel_type;
5023: int len;
5024:
5025: switch(dep->type) {
5026: case MODULE_DEP_REQUIRED:
5027: rel_type = "Required";
5028: break;
5029: case MODULE_DEP_CONFLICTS:
5030: rel_type = "Conflicts";
5031: break;
5032: case MODULE_DEP_OPTIONAL:
5033: rel_type = "Optional";
5034: break;
5035: default:
5036: rel_type = "Error"; /* shouldn't happen */
5037: break;
5038: }
5039:
5040: len = spprintf(&relation, 0, "%s%s%s%s%s",
5041: rel_type,
5042: dep->rel ? " " : "",
5043: dep->rel ? dep->rel : "",
5044: dep->version ? " " : "",
5045: dep->version ? dep->version : "");
5046: add_assoc_stringl(return_value, dep->name, relation, len, 0);
5047: dep++;
5048: }
5049: }
5050: /* }}} */
5051:
5052: /* {{{ proto public void ReflectionExtension::info() U
5053: Prints phpinfo block for the extension */
5054: ZEND_METHOD(reflection_extension, info)
5055: {
5056: reflection_object *intern;
5057: zend_module_entry *module;
5058:
5059: if (zend_parse_parameters_none() == FAILURE) {
5060: return;
5061: }
5062: GET_REFLECTION_OBJECT_PTR(module);
5063:
5064: php_info_print_module(module TSRMLS_CC);
5065: }
5066: /* }}} */
5067:
5068: /* {{{ method tables */
5069: static const zend_function_entry reflection_exception_functions[] = {
5070: PHP_FE_END
5071: };
5072:
5073: ZEND_BEGIN_ARG_INFO(arginfo_reflection__void, 0)
5074: ZEND_END_ARG_INFO()
5075:
5076:
5077: ZEND_BEGIN_ARG_INFO(arginfo_reflection_getModifierNames, 0)
5078: ZEND_ARG_INFO(0, modifiers)
5079: ZEND_END_ARG_INFO()
5080:
5081: ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_export, 0, 0, 1)
5082: ZEND_ARG_OBJ_INFO(0, reflector, Reflector, 0)
5083: ZEND_ARG_INFO(0, return)
5084: ZEND_END_ARG_INFO()
5085:
5086: static const zend_function_entry reflection_functions[] = {
5087: ZEND_ME(reflection, getModifierNames, arginfo_reflection_getModifierNames, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
5088: ZEND_ME(reflection, export, arginfo_reflection_export, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
5089: PHP_FE_END
5090: };
5091:
5092: static const zend_function_entry reflector_functions[] = {
5093: ZEND_FENTRY(export, NULL, NULL, ZEND_ACC_STATIC|ZEND_ACC_ABSTRACT|ZEND_ACC_PUBLIC)
5094: ZEND_ABSTRACT_ME(reflector, __toString, arginfo_reflection__void)
5095: PHP_FE_END
5096: };
5097:
5098: ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_function_export, 0, 0, 1)
5099: ZEND_ARG_INFO(0, name)
5100: ZEND_ARG_INFO(0, return)
5101: ZEND_END_ARG_INFO()
5102:
5103: ZEND_BEGIN_ARG_INFO(arginfo_reflection_function___construct, 0)
5104: ZEND_ARG_INFO(0, name)
5105: ZEND_END_ARG_INFO()
5106:
5107: ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_function_invoke, 0, 0, 0)
5108: ZEND_ARG_INFO(0, args)
5109: ZEND_END_ARG_INFO()
5110:
5111: ZEND_BEGIN_ARG_INFO(arginfo_reflection_function_invokeArgs, 0)
5112: ZEND_ARG_ARRAY_INFO(0, args, 0)
5113: ZEND_END_ARG_INFO()
5114:
5115: static const zend_function_entry reflection_function_abstract_functions[] = {
5116: ZEND_ME(reflection, __clone, arginfo_reflection__void, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL)
5117: PHP_ABSTRACT_ME(reflection_function, __toString, arginfo_reflection__void)
5118: ZEND_ME(reflection_function, inNamespace, arginfo_reflection__void, 0)
5119: ZEND_ME(reflection_function, isClosure, arginfo_reflection__void, 0)
5120: ZEND_ME(reflection_function, isDeprecated, arginfo_reflection__void, 0)
5121: ZEND_ME(reflection_function, isInternal, arginfo_reflection__void, 0)
5122: ZEND_ME(reflection_function, isUserDefined, arginfo_reflection__void, 0)
5123: ZEND_ME(reflection_function, getDocComment, arginfo_reflection__void, 0)
5124: ZEND_ME(reflection_function, getEndLine, arginfo_reflection__void, 0)
5125: ZEND_ME(reflection_function, getExtension, arginfo_reflection__void, 0)
5126: ZEND_ME(reflection_function, getExtensionName, arginfo_reflection__void, 0)
5127: ZEND_ME(reflection_function, getFileName, arginfo_reflection__void, 0)
5128: ZEND_ME(reflection_function, getName, arginfo_reflection__void, 0)
5129: ZEND_ME(reflection_function, getNamespaceName, arginfo_reflection__void, 0)
5130: ZEND_ME(reflection_function, getNumberOfParameters, arginfo_reflection__void, 0)
5131: ZEND_ME(reflection_function, getNumberOfRequiredParameters, arginfo_reflection__void, 0)
5132: ZEND_ME(reflection_function, getParameters, arginfo_reflection__void, 0)
5133: ZEND_ME(reflection_function, getShortName, arginfo_reflection__void, 0)
5134: ZEND_ME(reflection_function, getStartLine, arginfo_reflection__void, 0)
5135: ZEND_ME(reflection_function, getStaticVariables, arginfo_reflection__void, 0)
5136: ZEND_ME(reflection_function, returnsReference, arginfo_reflection__void, 0)
5137: PHP_FE_END
5138: };
5139:
5140: static const zend_function_entry reflection_function_functions[] = {
5141: ZEND_ME(reflection_function, __construct, arginfo_reflection_function___construct, 0)
5142: ZEND_ME(reflection_function, __toString, arginfo_reflection__void, 0)
5143: ZEND_ME(reflection_function, export, arginfo_reflection_function_export, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC)
5144: ZEND_ME(reflection_function, isDisabled, arginfo_reflection__void, 0)
5145: ZEND_ME(reflection_function, invoke, arginfo_reflection_function_invoke, 0)
5146: ZEND_ME(reflection_function, invokeArgs, arginfo_reflection_function_invokeArgs, 0)
5147: PHP_FE_END
5148: };
5149:
5150: ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_method_export, 0, 0, 2)
5151: ZEND_ARG_INFO(0, class)
5152: ZEND_ARG_INFO(0, name)
5153: ZEND_ARG_INFO(0, return)
5154: ZEND_END_ARG_INFO()
5155:
5156: ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_method___construct, 0, 0, 1)
5157: ZEND_ARG_INFO(0, class_or_method)
5158: ZEND_ARG_INFO(0, name)
5159: ZEND_END_ARG_INFO()
5160:
5161: ZEND_BEGIN_ARG_INFO(arginfo_reflection_method_invoke, 0)
5162: ZEND_ARG_INFO(0, object)
5163: ZEND_ARG_INFO(0, args)
5164: ZEND_END_ARG_INFO()
5165:
5166: ZEND_BEGIN_ARG_INFO(arginfo_reflection_method_invokeArgs, 0)
5167: ZEND_ARG_INFO(0, object)
5168: ZEND_ARG_ARRAY_INFO(0, args, 0)
5169: ZEND_END_ARG_INFO()
5170:
5171: ZEND_BEGIN_ARG_INFO(arginfo_reflection_method_setAccessible, 0)
5172: ZEND_ARG_INFO(0, value)
5173: ZEND_END_ARG_INFO()
5174:
5175: static const zend_function_entry reflection_method_functions[] = {
5176: ZEND_ME(reflection_method, export, arginfo_reflection_method_export, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC)
5177: ZEND_ME(reflection_method, __construct, arginfo_reflection_method___construct, 0)
5178: ZEND_ME(reflection_method, __toString, arginfo_reflection__void, 0)
5179: ZEND_ME(reflection_method, isPublic, arginfo_reflection__void, 0)
5180: ZEND_ME(reflection_method, isPrivate, arginfo_reflection__void, 0)
5181: ZEND_ME(reflection_method, isProtected, arginfo_reflection__void, 0)
5182: ZEND_ME(reflection_method, isAbstract, arginfo_reflection__void, 0)
5183: ZEND_ME(reflection_method, isFinal, arginfo_reflection__void, 0)
5184: ZEND_ME(reflection_method, isStatic, arginfo_reflection__void, 0)
5185: ZEND_ME(reflection_method, isConstructor, arginfo_reflection__void, 0)
5186: ZEND_ME(reflection_method, isDestructor, arginfo_reflection__void, 0)
5187: ZEND_ME(reflection_method, getModifiers, arginfo_reflection__void, 0)
5188: ZEND_ME(reflection_method, invoke, arginfo_reflection_method_invoke, 0)
5189: ZEND_ME(reflection_method, invokeArgs, arginfo_reflection_method_invokeArgs, 0)
5190: ZEND_ME(reflection_method, getDeclaringClass, arginfo_reflection__void, 0)
5191: ZEND_ME(reflection_method, getPrototype, arginfo_reflection__void, 0)
5192: ZEND_ME(reflection_property, setAccessible, arginfo_reflection_method_setAccessible, 0)
5193: PHP_FE_END
5194: };
5195:
5196:
5197: ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_class_export, 0, 0, 1)
5198: ZEND_ARG_INFO(0, argument)
5199: ZEND_ARG_INFO(0, return)
5200: ZEND_END_ARG_INFO()
5201:
5202: ZEND_BEGIN_ARG_INFO(arginfo_reflection_class___construct, 0)
5203: ZEND_ARG_INFO(0, argument)
5204: ZEND_END_ARG_INFO()
5205:
5206: ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_class_getStaticPropertyValue, 0, 0, 1)
5207: ZEND_ARG_INFO(0, name)
5208: ZEND_ARG_INFO(0, default)
5209: ZEND_END_ARG_INFO()
5210:
5211: ZEND_BEGIN_ARG_INFO(arginfo_reflection_class_setStaticPropertyValue, 0)
5212: ZEND_ARG_INFO(0, name)
5213: ZEND_ARG_INFO(0, value)
5214: ZEND_END_ARG_INFO()
5215:
5216: ZEND_BEGIN_ARG_INFO(arginfo_reflection_class_hasMethod, 0)
5217: ZEND_ARG_INFO(0, name)
5218: ZEND_END_ARG_INFO()
5219:
5220: ZEND_BEGIN_ARG_INFO(arginfo_reflection_class_getMethod, 0)
5221: ZEND_ARG_INFO(0, name)
5222: ZEND_END_ARG_INFO()
5223:
5224: ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_class_getMethods, 0, 0, 0)
5225: ZEND_ARG_INFO(0, filter)
5226: ZEND_END_ARG_INFO()
5227:
5228: ZEND_BEGIN_ARG_INFO(arginfo_reflection_class_hasProperty, 0)
5229: ZEND_ARG_INFO(0, name)
5230: ZEND_END_ARG_INFO()
5231:
5232: ZEND_BEGIN_ARG_INFO(arginfo_reflection_class_getProperty, 0)
5233: ZEND_ARG_INFO(0, name)
5234: ZEND_END_ARG_INFO()
5235:
5236: ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_class_getProperties, 0, 0, 0)
5237: ZEND_ARG_INFO(0, filter)
5238: ZEND_END_ARG_INFO()
5239:
5240: ZEND_BEGIN_ARG_INFO(arginfo_reflection_class_hasConstant, 0)
5241: ZEND_ARG_INFO(0, name)
5242: ZEND_END_ARG_INFO()
5243:
5244: ZEND_BEGIN_ARG_INFO(arginfo_reflection_class_getConstant, 0)
5245: ZEND_ARG_INFO(0, name)
5246: ZEND_END_ARG_INFO()
5247:
5248: ZEND_BEGIN_ARG_INFO(arginfo_reflection_class_isInstance, 0)
5249: ZEND_ARG_INFO(0, object)
5250: ZEND_END_ARG_INFO()
5251:
5252: ZEND_BEGIN_ARG_INFO(arginfo_reflection_class_newInstance, 0)
5253: ZEND_ARG_INFO(0, args)
5254: ZEND_END_ARG_INFO()
5255:
5256: ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_class_newInstanceArgs, 0, 0, 0)
5257: ZEND_ARG_ARRAY_INFO(0, args, 0)
5258: ZEND_END_ARG_INFO()
5259:
5260: ZEND_BEGIN_ARG_INFO(arginfo_reflection_class_isSubclassOf, 0)
5261: ZEND_ARG_INFO(0, class)
5262: ZEND_END_ARG_INFO()
5263:
5264: ZEND_BEGIN_ARG_INFO(arginfo_reflection_class_implementsInterface, 0)
5265: ZEND_ARG_INFO(0, interface)
5266: ZEND_END_ARG_INFO()
5267:
5268: static const zend_function_entry reflection_class_functions[] = {
5269: ZEND_ME(reflection, __clone, arginfo_reflection__void, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL)
5270: ZEND_ME(reflection_class, export, arginfo_reflection_class_export, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC)
5271: ZEND_ME(reflection_class, __construct, arginfo_reflection_class___construct, 0)
5272: ZEND_ME(reflection_class, __toString, arginfo_reflection__void, 0)
5273: ZEND_ME(reflection_class, getName, arginfo_reflection__void, 0)
5274: ZEND_ME(reflection_class, isInternal, arginfo_reflection__void, 0)
5275: ZEND_ME(reflection_class, isUserDefined, arginfo_reflection__void, 0)
5276: ZEND_ME(reflection_class, isInstantiable, arginfo_reflection__void, 0)
5277: ZEND_ME(reflection_class, getFileName, arginfo_reflection__void, 0)
5278: ZEND_ME(reflection_class, getStartLine, arginfo_reflection__void, 0)
5279: ZEND_ME(reflection_class, getEndLine, arginfo_reflection__void, 0)
5280: ZEND_ME(reflection_class, getDocComment, arginfo_reflection__void, 0)
5281: ZEND_ME(reflection_class, getConstructor, arginfo_reflection__void, 0)
5282: ZEND_ME(reflection_class, hasMethod, arginfo_reflection_class_hasMethod, 0)
5283: ZEND_ME(reflection_class, getMethod, arginfo_reflection_class_getMethod, 0)
5284: ZEND_ME(reflection_class, getMethods, arginfo_reflection_class_getMethods, 0)
5285: ZEND_ME(reflection_class, hasProperty, arginfo_reflection_class_hasProperty, 0)
5286: ZEND_ME(reflection_class, getProperty, arginfo_reflection_class_getProperty, 0)
5287: ZEND_ME(reflection_class, getProperties, arginfo_reflection_class_getProperties, 0)
5288: ZEND_ME(reflection_class, hasConstant, arginfo_reflection_class_hasConstant, 0)
5289: ZEND_ME(reflection_class, getConstants, arginfo_reflection__void, 0)
5290: ZEND_ME(reflection_class, getConstant, arginfo_reflection_class_getConstant, 0)
5291: ZEND_ME(reflection_class, getInterfaces, arginfo_reflection__void, 0)
5292: ZEND_ME(reflection_class, getInterfaceNames, arginfo_reflection__void, 0)
5293: ZEND_ME(reflection_class, isInterface, arginfo_reflection__void, 0)
5294: ZEND_ME(reflection_class, isAbstract, arginfo_reflection__void, 0)
5295: ZEND_ME(reflection_class, isFinal, arginfo_reflection__void, 0)
5296: ZEND_ME(reflection_class, getModifiers, arginfo_reflection__void, 0)
5297: ZEND_ME(reflection_class, isInstance, arginfo_reflection_class_isInstance, 0)
5298: ZEND_ME(reflection_class, newInstance, arginfo_reflection_class_newInstance, 0)
5299: ZEND_ME(reflection_class, newInstanceArgs, arginfo_reflection_class_newInstanceArgs, 0)
5300: ZEND_ME(reflection_class, getParentClass, arginfo_reflection__void, 0)
5301: ZEND_ME(reflection_class, isSubclassOf, arginfo_reflection_class_isSubclassOf, 0)
5302: ZEND_ME(reflection_class, getStaticProperties, arginfo_reflection__void, 0)
5303: ZEND_ME(reflection_class, getStaticPropertyValue, arginfo_reflection_class_getStaticPropertyValue, 0)
5304: ZEND_ME(reflection_class, setStaticPropertyValue, arginfo_reflection_class_setStaticPropertyValue, 0)
5305: ZEND_ME(reflection_class, getDefaultProperties, arginfo_reflection__void, 0)
5306: ZEND_ME(reflection_class, isIterateable, arginfo_reflection__void, 0)
5307: ZEND_ME(reflection_class, implementsInterface, arginfo_reflection_class_implementsInterface, 0)
5308: ZEND_ME(reflection_class, getExtension, arginfo_reflection__void, 0)
5309: ZEND_ME(reflection_class, getExtensionName, arginfo_reflection__void, 0)
5310: ZEND_ME(reflection_class, inNamespace, arginfo_reflection__void, 0)
5311: ZEND_ME(reflection_class, getNamespaceName, arginfo_reflection__void, 0)
5312: ZEND_ME(reflection_class, getShortName, arginfo_reflection__void, 0)
5313: PHP_FE_END
5314: };
5315:
5316:
5317: ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_object_export, 0, 0, 1)
5318: ZEND_ARG_INFO(0, argument)
5319: ZEND_ARG_INFO(0, return)
5320: ZEND_END_ARG_INFO()
5321:
5322: ZEND_BEGIN_ARG_INFO(arginfo_reflection_object___construct, 0)
5323: ZEND_ARG_INFO(0, argument)
5324: ZEND_END_ARG_INFO()
5325:
5326: static const zend_function_entry reflection_object_functions[] = {
5327: ZEND_ME(reflection_object, export, arginfo_reflection_object_export, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC)
5328: ZEND_ME(reflection_object, __construct, arginfo_reflection_object___construct, 0)
5329: PHP_FE_END
5330: };
5331:
5332:
5333: ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_property_export, 0, 0, 2)
5334: ZEND_ARG_INFO(0, class)
5335: ZEND_ARG_INFO(0, name)
5336: ZEND_ARG_INFO(0, return)
5337: ZEND_END_ARG_INFO()
5338:
5339: ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_property___construct, 0, 0, 2)
5340: ZEND_ARG_INFO(0, class)
5341: ZEND_ARG_INFO(0, name)
5342: ZEND_END_ARG_INFO()
5343:
5344: ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_property_getValue, 0, 0, 0)
5345: ZEND_ARG_INFO(0, object)
5346: ZEND_END_ARG_INFO()
5347:
5348: ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_property_setValue, 0, 0, 1)
5349: ZEND_ARG_INFO(0, object)
5350: ZEND_ARG_INFO(0, value)
5351: ZEND_END_ARG_INFO()
5352:
5353: ZEND_BEGIN_ARG_INFO(arginfo_reflection_property_setAccessible, 0)
5354: ZEND_ARG_INFO(0, visible)
5355: ZEND_END_ARG_INFO()
5356:
5357: static const zend_function_entry reflection_property_functions[] = {
5358: ZEND_ME(reflection, __clone, arginfo_reflection__void, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL)
5359: ZEND_ME(reflection_property, export, arginfo_reflection_property_export, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC)
5360: ZEND_ME(reflection_property, __construct, arginfo_reflection_property___construct, 0)
5361: ZEND_ME(reflection_property, __toString, arginfo_reflection__void, 0)
5362: ZEND_ME(reflection_property, getName, arginfo_reflection__void, 0)
5363: ZEND_ME(reflection_property, getValue, arginfo_reflection_property_getValue, 0)
5364: ZEND_ME(reflection_property, setValue, arginfo_reflection_property_setValue, 0)
5365: ZEND_ME(reflection_property, isPublic, arginfo_reflection__void, 0)
5366: ZEND_ME(reflection_property, isPrivate, arginfo_reflection__void, 0)
5367: ZEND_ME(reflection_property, isProtected, arginfo_reflection__void, 0)
5368: ZEND_ME(reflection_property, isStatic, arginfo_reflection__void, 0)
5369: ZEND_ME(reflection_property, isDefault, arginfo_reflection__void, 0)
5370: ZEND_ME(reflection_property, getModifiers, arginfo_reflection__void, 0)
5371: ZEND_ME(reflection_property, getDeclaringClass, arginfo_reflection__void, 0)
5372: ZEND_ME(reflection_property, getDocComment, arginfo_reflection__void, 0)
5373: ZEND_ME(reflection_property, setAccessible, arginfo_reflection_property_setAccessible, 0)
5374: PHP_FE_END
5375: };
5376:
5377: ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_parameter_export, 0, 0, 2)
5378: ZEND_ARG_INFO(0, function)
5379: ZEND_ARG_INFO(0, parameter)
5380: ZEND_ARG_INFO(0, return)
5381: ZEND_END_ARG_INFO()
5382:
5383: ZEND_BEGIN_ARG_INFO(arginfo_reflection_parameter___construct, 0)
5384: ZEND_ARG_INFO(0, function)
5385: ZEND_ARG_INFO(0, parameter)
5386: ZEND_END_ARG_INFO()
5387:
5388: static const zend_function_entry reflection_parameter_functions[] = {
5389: ZEND_ME(reflection, __clone, arginfo_reflection__void, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL)
5390: ZEND_ME(reflection_parameter, export, arginfo_reflection_parameter_export, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC)
5391: ZEND_ME(reflection_parameter, __construct, arginfo_reflection_parameter___construct, 0)
5392: ZEND_ME(reflection_parameter, __toString, arginfo_reflection__void, 0)
5393: ZEND_ME(reflection_parameter, getName, arginfo_reflection__void, 0)
5394: ZEND_ME(reflection_parameter, isPassedByReference, arginfo_reflection__void, 0)
5395: ZEND_ME(reflection_parameter, getDeclaringFunction, arginfo_reflection__void, 0)
5396: ZEND_ME(reflection_parameter, getDeclaringClass, arginfo_reflection__void, 0)
5397: ZEND_ME(reflection_parameter, getClass, arginfo_reflection__void, 0)
5398: ZEND_ME(reflection_parameter, isArray, arginfo_reflection__void, 0)
5399: ZEND_ME(reflection_parameter, allowsNull, arginfo_reflection__void, 0)
5400: ZEND_ME(reflection_parameter, getPosition, arginfo_reflection__void, 0)
5401: ZEND_ME(reflection_parameter, isOptional, arginfo_reflection__void, 0)
5402: ZEND_ME(reflection_parameter, isDefaultValueAvailable, arginfo_reflection__void, 0)
5403: ZEND_ME(reflection_parameter, getDefaultValue, arginfo_reflection__void, 0)
5404: PHP_FE_END
5405: };
5406:
5407: ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_extension_export, 0, 0, 1)
5408: ZEND_ARG_INFO(0, name)
5409: ZEND_ARG_INFO(0, return)
5410: ZEND_END_ARG_INFO()
5411:
5412: ZEND_BEGIN_ARG_INFO(arginfo_reflection_extension___construct, 0)
5413: ZEND_ARG_INFO(0, name)
5414: ZEND_END_ARG_INFO()
5415:
5416: static const zend_function_entry reflection_extension_functions[] = {
5417: ZEND_ME(reflection, __clone, arginfo_reflection__void, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL)
5418: ZEND_ME(reflection_extension, export, arginfo_reflection_extension_export, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC)
5419: ZEND_ME(reflection_extension, __construct, arginfo_reflection_extension___construct, 0)
5420: ZEND_ME(reflection_extension, __toString, arginfo_reflection__void, 0)
5421: ZEND_ME(reflection_extension, getName, arginfo_reflection__void, 0)
5422: ZEND_ME(reflection_extension, getVersion, arginfo_reflection__void, 0)
5423: ZEND_ME(reflection_extension, getFunctions, arginfo_reflection__void, 0)
5424: ZEND_ME(reflection_extension, getConstants, arginfo_reflection__void, 0)
5425: ZEND_ME(reflection_extension, getINIEntries, arginfo_reflection__void, 0)
5426: ZEND_ME(reflection_extension, getClasses, arginfo_reflection__void, 0)
5427: ZEND_ME(reflection_extension, getClassNames, arginfo_reflection__void, 0)
5428: ZEND_ME(reflection_extension, getDependencies, arginfo_reflection__void, 0)
5429: ZEND_ME(reflection_extension, info, arginfo_reflection__void, 0)
5430: PHP_FE_END
5431: };
5432: /* }}} */
5433:
5434: const zend_function_entry reflection_ext_functions[] = { /* {{{ */
5435: PHP_FE_END
5436: }; /* }}} */
5437:
5438: static zend_object_handlers *zend_std_obj_handlers;
5439:
5440: /* {{{ _reflection_write_property */
5441: static void _reflection_write_property(zval *object, zval *member, zval *value TSRMLS_DC)
5442: {
5443: if ((Z_TYPE_P(member) == IS_STRING)
5444: && zend_hash_exists(&Z_OBJCE_P(object)->default_properties, Z_STRVAL_P(member), Z_STRLEN_P(member)+1)
5445: && ((Z_STRLEN_P(member) == sizeof("name") - 1 && !memcmp(Z_STRVAL_P(member), "name", sizeof("name")))
5446: || (Z_STRLEN_P(member) == sizeof("class") - 1 && !memcmp(Z_STRVAL_P(member), "class", sizeof("class")))))
5447: {
5448: zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
5449: "Cannot set read-only property %s::$%s", Z_OBJCE_P(object)->name, Z_STRVAL_P(member));
5450: }
5451: else
5452: {
5453: zend_std_obj_handlers->write_property(object, member, value TSRMLS_CC);
5454: }
5455: }
5456: /* }}} */
5457:
5458: PHP_MINIT_FUNCTION(reflection) /* {{{ */
5459: {
5460: zend_class_entry _reflection_entry;
5461:
5462: zend_std_obj_handlers = zend_get_std_object_handlers();
5463: memcpy(&reflection_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
5464: reflection_object_handlers.clone_obj = NULL;
5465: reflection_object_handlers.write_property = _reflection_write_property;
5466:
5467: INIT_CLASS_ENTRY(_reflection_entry, "ReflectionException", reflection_exception_functions);
5468: reflection_exception_ptr = zend_register_internal_class_ex(&_reflection_entry, zend_exception_get_default(TSRMLS_C), NULL TSRMLS_CC);
5469:
5470: INIT_CLASS_ENTRY(_reflection_entry, "Reflection", reflection_functions);
5471: reflection_ptr = zend_register_internal_class(&_reflection_entry TSRMLS_CC);
5472:
5473: INIT_CLASS_ENTRY(_reflection_entry, "Reflector", reflector_functions);
5474: reflector_ptr = zend_register_internal_interface(&_reflection_entry TSRMLS_CC);
5475:
5476: INIT_CLASS_ENTRY(_reflection_entry, "ReflectionFunctionAbstract", reflection_function_abstract_functions);
5477: _reflection_entry.create_object = reflection_objects_new;
5478: reflection_function_abstract_ptr = zend_register_internal_class(&_reflection_entry TSRMLS_CC);
5479: reflection_register_implement(reflection_function_abstract_ptr, reflector_ptr TSRMLS_CC);
5480: zend_declare_property_string(reflection_function_abstract_ptr, "name", sizeof("name")-1, "", ZEND_ACC_ABSTRACT TSRMLS_CC);
5481:
5482: INIT_CLASS_ENTRY(_reflection_entry, "ReflectionFunction", reflection_function_functions);
5483: _reflection_entry.create_object = reflection_objects_new;
5484: reflection_function_ptr = zend_register_internal_class_ex(&_reflection_entry, reflection_function_abstract_ptr, NULL TSRMLS_CC);
5485: zend_declare_property_string(reflection_function_ptr, "name", sizeof("name")-1, "", ZEND_ACC_PUBLIC TSRMLS_CC);
5486:
5487: REGISTER_REFLECTION_CLASS_CONST_LONG(function, "IS_DEPRECATED", ZEND_ACC_DEPRECATED);
5488:
5489: INIT_CLASS_ENTRY(_reflection_entry, "ReflectionParameter", reflection_parameter_functions);
5490: _reflection_entry.create_object = reflection_objects_new;
5491: reflection_parameter_ptr = zend_register_internal_class(&_reflection_entry TSRMLS_CC);
5492: reflection_register_implement(reflection_parameter_ptr, reflector_ptr TSRMLS_CC);
5493: zend_declare_property_string(reflection_parameter_ptr, "name", sizeof("name")-1, "", ZEND_ACC_PUBLIC TSRMLS_CC);
5494:
5495: INIT_CLASS_ENTRY(_reflection_entry, "ReflectionMethod", reflection_method_functions);
5496: _reflection_entry.create_object = reflection_objects_new;
5497: reflection_method_ptr = zend_register_internal_class_ex(&_reflection_entry, reflection_function_abstract_ptr, NULL TSRMLS_CC);
5498: zend_declare_property_string(reflection_method_ptr, "name", sizeof("name")-1, "", ZEND_ACC_PUBLIC TSRMLS_CC);
5499: zend_declare_property_string(reflection_method_ptr, "class", sizeof("class")-1, "", ZEND_ACC_PUBLIC TSRMLS_CC);
5500:
5501: REGISTER_REFLECTION_CLASS_CONST_LONG(method, "IS_STATIC", ZEND_ACC_STATIC);
5502: REGISTER_REFLECTION_CLASS_CONST_LONG(method, "IS_PUBLIC", ZEND_ACC_PUBLIC);
5503: REGISTER_REFLECTION_CLASS_CONST_LONG(method, "IS_PROTECTED", ZEND_ACC_PROTECTED);
5504: REGISTER_REFLECTION_CLASS_CONST_LONG(method, "IS_PRIVATE", ZEND_ACC_PRIVATE);
5505: REGISTER_REFLECTION_CLASS_CONST_LONG(method, "IS_ABSTRACT", ZEND_ACC_ABSTRACT);
5506: REGISTER_REFLECTION_CLASS_CONST_LONG(method, "IS_FINAL", ZEND_ACC_FINAL);
5507:
5508: INIT_CLASS_ENTRY(_reflection_entry, "ReflectionClass", reflection_class_functions);
5509: _reflection_entry.create_object = reflection_objects_new;
5510: reflection_class_ptr = zend_register_internal_class(&_reflection_entry TSRMLS_CC);
5511: reflection_register_implement(reflection_class_ptr, reflector_ptr TSRMLS_CC);
5512: zend_declare_property_string(reflection_class_ptr, "name", sizeof("name")-1, "", ZEND_ACC_PUBLIC TSRMLS_CC);
5513:
5514: REGISTER_REFLECTION_CLASS_CONST_LONG(class, "IS_IMPLICIT_ABSTRACT", ZEND_ACC_IMPLICIT_ABSTRACT_CLASS);
5515: REGISTER_REFLECTION_CLASS_CONST_LONG(class, "IS_EXPLICIT_ABSTRACT", ZEND_ACC_EXPLICIT_ABSTRACT_CLASS);
5516: REGISTER_REFLECTION_CLASS_CONST_LONG(class, "IS_FINAL", ZEND_ACC_FINAL_CLASS);
5517:
5518: INIT_CLASS_ENTRY(_reflection_entry, "ReflectionObject", reflection_object_functions);
5519: _reflection_entry.create_object = reflection_objects_new;
5520: reflection_object_ptr = zend_register_internal_class_ex(&_reflection_entry, reflection_class_ptr, NULL TSRMLS_CC);
5521:
5522: INIT_CLASS_ENTRY(_reflection_entry, "ReflectionProperty", reflection_property_functions);
5523: _reflection_entry.create_object = reflection_objects_new;
5524: reflection_property_ptr = zend_register_internal_class(&_reflection_entry TSRMLS_CC);
5525: reflection_register_implement(reflection_property_ptr, reflector_ptr TSRMLS_CC);
5526: zend_declare_property_string(reflection_property_ptr, "name", sizeof("name")-1, "", ZEND_ACC_PUBLIC TSRMLS_CC);
5527: zend_declare_property_string(reflection_property_ptr, "class", sizeof("class")-1, "", ZEND_ACC_PUBLIC TSRMLS_CC);
5528:
5529: REGISTER_REFLECTION_CLASS_CONST_LONG(property, "IS_STATIC", ZEND_ACC_STATIC);
5530: REGISTER_REFLECTION_CLASS_CONST_LONG(property, "IS_PUBLIC", ZEND_ACC_PUBLIC);
5531: REGISTER_REFLECTION_CLASS_CONST_LONG(property, "IS_PROTECTED", ZEND_ACC_PROTECTED);
5532: REGISTER_REFLECTION_CLASS_CONST_LONG(property, "IS_PRIVATE", ZEND_ACC_PRIVATE);
5533:
5534: INIT_CLASS_ENTRY(_reflection_entry, "ReflectionExtension", reflection_extension_functions);
5535: _reflection_entry.create_object = reflection_objects_new;
5536: reflection_extension_ptr = zend_register_internal_class(&_reflection_entry TSRMLS_CC);
5537: reflection_register_implement(reflection_extension_ptr, reflector_ptr TSRMLS_CC);
5538: zend_declare_property_string(reflection_extension_ptr, "name", sizeof("name")-1, "", ZEND_ACC_PUBLIC TSRMLS_CC);
5539:
5540: return SUCCESS;
5541: } /* }}} */
5542:
5543: PHP_MINFO_FUNCTION(reflection) /* {{{ */
5544: {
5545: php_info_print_table_start();
5546: php_info_print_table_header(2, "Reflection", "enabled");
5547:
5548: php_info_print_table_row(2, "Version", "$Revision: 321634 $");
5549:
5550: php_info_print_table_end();
5551: } /* }}} */
5552:
5553: zend_module_entry reflection_module_entry = { /* {{{ */
5554: STANDARD_MODULE_HEADER,
5555: "Reflection",
5556: reflection_ext_functions,
5557: PHP_MINIT(reflection),
5558: NULL,
5559: NULL,
5560: NULL,
5561: PHP_MINFO(reflection),
5562: "$Revision: 321634 $",
5563: STANDARD_MODULE_PROPERTIES
5564: }; /* }}} */
5565:
5566: /*
5567: * Local variables:
5568: * tab-width: 4
5569: * c-basic-offset: 4
5570: * indent-tabs-mode: t
5571: * End:
5572: * vim600: noet sw=4 ts=4 fdm=marker
5573: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to php_reflection.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / reflection