On Tue, 2003-07-01 at 23:36, George Schlossnagle wrote:
> Csn you make your diff of current cvs? I committed a good bit of your
> previous patch.
Yup, you'll find it attached.
> I don't know if i dig the way you implemented reflection_method. I
> have some partially complete work that handles this in a manner more
> consistent with the rest of the code.
? I simply copied your idea with the _factory method an intern->ptr
pointing to the class entry|the function pointer...
[...]
> > TBDiscussed: Would something like
> > $modifiers= array('public', 'static')
> > be cooler? Currently, one would be checking with
> > $modifiers & STATIC
> > etc.
>
> or
>
> array('public' => 1, 'static' => 1)
Seems like a better solution (more user-friendly) - I've implemented
this.
> The bitmask is pretty cryptic. Besides STATIC is a keyword.
You're right:)
- Timm
Index: Zend/zend_reflection_api.c
===================================================================
RCS file: /repository/ZendEngine2/zend_reflection_api.c,v
retrieving revision 1.7
diff -u -r1.7 zend_reflection_api.c
--- Zend/zend_reflection_api.c 1 Jul 2003 18:41:42 -0000 1.7
+++ Zend/zend_reflection_api.c 1 Jul 2003 22:19:31 -0000
@@ -42,6 +42,7 @@
} \
#define _DO_THROW(msg) \
+ { \
extern zend_class_entry *default_exception_ptr; \
zval *ex; \
zval *tmp; \
@@ -63,11 +64,13 @@
zend_hash_update(Z_OBJPROP_P(ex), "line", sizeof("line"), (void **) &tmp, sizeof(zval *), NULL); \
tmp = NULL; \
\
- EG(exception) = ex;
-
+ EG(exception) = ex; \
+ return; \
+ }
zend_class_entry *reflection_function_ptr;
zend_class_entry *reflection_class_ptr;
+zend_class_entry *reflection_method_ptr;
static zend_object_handlers reflection_object_handlers;
@@ -119,7 +122,7 @@
ALLOC_HASHTABLE(intern->zo.properties);
zend_hash_init(intern->zo.properties, 0, NULL, ZVAL_PTR_DTOR, 0);
retval.handle = zend_objects_store_put(intern, reflection_objects_dtor, reflection_objects_clone TSRMLS_CC);
- retval.handlers = &reflection_object_handlers;
+ retval.handlers = &reflection_object_handlers;
return retval;
}
@@ -160,6 +163,7 @@
zend_hash_update(Z_OBJPROP_P(object), "name", sizeof("name"), (void **) name, sizeof(zval *), NULL);
lcname = zend_str_tolower_dup((const char *)Z_STRVAL_PP(name), (int) Z_STRLEN_PP(name));
if (zend_hash_find(EG(function_table), lcname, (int)(Z_STRLEN_PP(name) + 1), (void **)&fptr) == FAILURE) {
+ efree(lcname);
_DO_THROW("Function does not exist");
}
efree(lcname);
@@ -317,7 +321,8 @@
{
reflection_object *intern;
zval *name;
- ALLOC_ZVAL(name);
+
+ MAKE_STD_ZVAL(name);
ZVAL_STRINGL(name, ce->name, ce->name_length, 1);
reflection_instanciate(reflection_class_ptr, object TSRMLS_CC);
intern = (reflection_object *) zend_object_store_get_object(object TSRMLS_CC);
@@ -325,6 +330,229 @@
zend_hash_update(Z_OBJPROP_P(object), "name", sizeof("name"), (void **) &name, sizeof(zval *), NULL);
}
+void reflection_method_factory(zend_class_entry *ce, zend_function *method, zval *object TSRMLS_DC)
+{
+ reflection_object *intern;
+ zval *name;
+ zval *classname;
+
+ MAKE_STD_ZVAL(name);
+ ZVAL_STRING(name, method->common.function_name, 1);
+ MAKE_STD_ZVAL(classname);
+ ZVAL_STRINGL(classname, ce->name, ce->name_length, 1);
+ reflection_instanciate(reflection_method_ptr, object TSRMLS_CC);
+ intern = (reflection_object *) zend_object_store_get_object(object TSRMLS_CC);
+ intern->ptr = method;
+ zend_hash_update(Z_OBJPROP_P(object), "name", sizeof("name"), (void **) &name, sizeof(zval *), NULL);
+ zend_hash_update(Z_OBJPROP_P(object), "class", sizeof("class"), (void **) &classname, sizeof(zval *), NULL);
+}
+
+/* {{{ proto Reflection_Class Reflection_Method::__construct(mixed class, string name)
+ Constructor. Throws an Exception in case the given method does not exist */
+ZEND_FUNCTION(reflection_method)
+{
+ zval **name, **class;
+ zval *classname;
+ zval *object;
+ reflection_object *intern;
+ char *lcname;
+ zend_class_entry **pce;
+ zend_class_entry *ce;
+ zend_function *mptr;
+
+ int argc = ZEND_NUM_ARGS();
+ if (zend_get_parameters_ex(argc, &class, &name) == FAILURE) {
+ ZEND_WRONG_PARAM_COUNT();
+ }
+
+ object = getThis();
+ intern = (reflection_object *) zend_object_store_get_object(object TSRMLS_CC);
+ if (intern == NULL) {
+ return;
+ }
+
+ /* Find the class entry */
+ switch (Z_TYPE_PP(class)) {
+ case IS_STRING:
+ convert_to_string_ex(class);
+ lcname = zend_str_tolower_dup((const char *)Z_STRVAL_PP(class), (int) Z_STRLEN_PP(class));
+ if (zend_hash_find(EG(class_table), lcname, (int)(Z_STRLEN_PP(class) + 1), (void **) &pce) == FAILURE) {
+ efree(lcname);
+ _DO_THROW("Class does not exist");
+ /* returns out of this function */
+ }
+ ce = *pce;
+ efree(lcname);
+ break;
+
+ case IS_OBJECT:
+ ce = Z_OBJCE_PP(class);
+ break;
+
+ default:
+ _DO_THROW("The parameter class is expected to be either a string or an object");
+ /* returns out of this function */
+ }
+
+ MAKE_STD_ZVAL(classname);
+ ZVAL_STRINGL(classname, ce->name, ce->name_length, 1);
+ zend_hash_update(Z_OBJPROP_P(object), "class", sizeof("class"), (void **) &classname, sizeof(zval *), NULL);
+
+ convert_to_string_ex(name);
+ zval_add_ref(name);
+ zend_hash_update(Z_OBJPROP_P(object), "name", sizeof("name"), (void **) name, sizeof(zval *), NULL);
+ lcname = zend_str_tolower_dup((const char *)Z_STRVAL_PP(name), (int) Z_STRLEN_PP(name));
+
+ if (zend_hash_find(&ce->function_table, lcname, (int)(Z_STRLEN_PP(name) + 1), (void **) &mptr) == FAILURE) {
+ efree(lcname);
+ _DO_THROW("Method does not exist");
+ /* returns out of this function */
+ }
+ efree(lcname);
+ intern->ptr = mptr;
+}
+/* }}} */
+
+/* {{{ proto mixed Reflection_Method::invoke(stdclass object, mixed* args)
+ Invokes the function */
+ZEND_FUNCTION(reflection_method_invoke)
+{
+ zval *retval_ptr;
+ zval ***params;
+ reflection_object *intern;
+ zend_function *mptr;
+ int argc = ZEND_NUM_ARGS();
+
+ METHOD_NOTSTATIC;
+ GET_REFLECTION_OBJECT_PTR(mptr);
+
+ params = safe_emalloc(sizeof(zval **), argc, 0);
+ if (zend_get_parameters_array_ex(argc, params) == FAILURE) {
+ efree(params);
+ RETURN_FALSE;
+ }
+
+ if (argc < 1 || Z_TYPE_PP(params[0]) != IS_OBJECT) {
+ zend_error(E_WARNING, "First parameter is expected to be an object");
+ efree(params);
+ RETURN_FALSE;
+ }
+
+ if (fast_call_user_function(&mptr->common.scope->function_table, params[0], NULL,
+ &retval_ptr, argc - 1, params+ 1,
+ 1, NULL, &mptr TSRMLS_CC) == SUCCESS && retval_ptr) {
+ COPY_PZVAL_TO_ZVAL(*return_value, retval_ptr);
+ }
+ efree(params);
+}
+/* }}} */
+
+static void _method_check_flag(INTERNAL_FUNCTION_PARAMETERS, int mask)
+{
+ reflection_object *intern;
+ zend_function *mptr;
+
+ METHOD_NOTSTATIC_NUMPARAMS(0);
+ GET_REFLECTION_OBJECT_PTR(mptr);
+ RETURN_BOOL(mptr->common.fn_flags & mask);
+}
+
+/* {{{ proto bool Reflection_Method::isFinal()
+ Returns whether this method is final */
+ZEND_FUNCTION(reflection_method_isfinal)
+{
+ _method_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_FINAL);
+}
+/* }}} */
+
+/* {{{ proto bool Reflection_Method::isAbstract()
+ Returns whether this method is abstract */
+ZEND_FUNCTION(reflection_method_isabstract)
+{
+ _method_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_ABSTRACT);
+}
+/* }}} */
+
+/* {{{ proto bool Reflection_Method::isPublic()
+ Returns whether this method is public */
+ZEND_FUNCTION(reflection_method_ispublic)
+{
+ _method_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_PUBLIC);
+}
+/* }}} */
+
+/* {{{ proto bool Reflection_Method::isPrivate()
+ Returns whether this method is private */
+ZEND_FUNCTION(reflection_method_isprivate)
+{
+ _method_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_PRIVATE);
+}
+/* }}} */
+
+/* {{{ proto bool Reflection_Method::isProtected()
+ Returns whether this method is protected */
+ZEND_FUNCTION(reflection_method_isprotected)
+{
+ _method_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_PROTECTED);
+}
+/* }}} */
+
+/* {{{ proto bool Reflection_Method::isStatic()
+ Returns whether this method is static */
+ZEND_FUNCTION(reflection_method_isstatic)
+{
+ _method_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_STATIC);
+}
+/* }}} */
+
+/* {{{ proto bool Reflection_Method::isConstructor()
+ Returns whether this method is the constructor */
+ZEND_FUNCTION(reflection_method_isconstructor)
+{
+ reflection_object *intern;
+ zend_function *mptr;
+
+ METHOD_NOTSTATIC_NUMPARAMS(0);
+ GET_REFLECTION_OBJECT_PTR(mptr);
+ RETURN_BOOL(mptr->common.scope->constructor == mptr);
+}
+/* }}} */
+
+/* {{{ proto bool Reflection_Method::getModifiers()
+ Returns the access modifiers for this method */
+ZEND_FUNCTION(reflection_method_getmodifiers)
+{
+ reflection_object *intern;
+ zend_function *mptr;
+
+ METHOD_NOTSTATIC_NUMPARAMS(0);
+ GET_REFLECTION_OBJECT_PTR(mptr);
+
+ array_init(return_value);
+
+ switch (mptr->common.fn_flags & ZEND_ACC_PPP_MASK) {
+ case ZEND_ACC_PUBLIC:
+ add_assoc_bool_ex(return_value, "public", sizeof("public"), 1);
+ break;
+ case ZEND_ACC_PRIVATE:
+ add_assoc_bool_ex(return_value, "private", sizeof("private"), 1);
+ break;
+ case ZEND_ACC_PROTECTED:
+ add_assoc_bool_ex(return_value, "protected", sizeof("protected"), 1);
+ break;
+ }
+ if (mptr->common.fn_flags & ZEND_ACC_ABSTRACT) {
+ add_assoc_bool_ex(return_value, "abstract", sizeof("abstract"), 1);
+ }
+ if (mptr->common.fn_flags & ZEND_ACC_STATIC) {
+ add_assoc_bool_ex(return_value, "static", sizeof("static"), 1);
+ }
+ if (mptr->common.fn_flags & ZEND_ACC_FINAL) {
+ add_assoc_bool_ex(return_value, "final", sizeof("final"), 1);
+ }
+}
+/* }}} */
+
/* {{{ proto Reflection_Class Reflection_Class::__construct(string name)
Constructor. Throws an Exception in case the given class does not exist */
ZEND_FUNCTION(reflection_class)
@@ -350,6 +578,7 @@
zend_hash_update(Z_OBJPROP_P(object), "name", sizeof("name"), (void **) name, sizeof(zval *), NULL);
lcname = zend_str_tolower_dup((const char *)Z_STRVAL_PP(name), (int) Z_STRLEN_PP(name));
if (zend_hash_find(EG(class_table), lcname, (int)(Z_STRLEN_PP(name) + 1), (void **)&ce) == FAILURE) {
+ efree(lcname);
_DO_THROW("Class does not exist");
}
efree(lcname);
@@ -456,6 +685,81 @@
}
/* }}} */
+/* {{{ proto PHP_Method Reflection_Class::getConstructor()
+ Returns the class' constructor if there is one, NULL otherwise */
+ZEND_FUNCTION(reflection_class_getconstructor)
+{
+ reflection_object *intern;
+ zend_class_entry *ce;
+
+ METHOD_NOTSTATIC_NUMPARAMS(0);
+ GET_REFLECTION_OBJECT_PTR(ce);
+
+ if (ce->constructor) {
+ reflection_method_factory(ce, ce->constructor, return_value TSRMLS_CC);
+ } else {
+ RETURN_NULL();
+ }
+}
+/* }}} */
+
+/* {{{ proto PHP_Method Reflection_Class::getMethod(string name)
+ Returns the class' method specified by it's name */
+ZEND_FUNCTION(reflection_class_getmethod)
+{
+ reflection_object *intern;
+ zend_class_entry *ce;
+ zend_function *mptr;
+ zval **name;
+ int argc = ZEND_NUM_ARGS();
+
+ METHOD_NOTSTATIC;
+ if (zend_get_parameters_ex(argc, &name) == FAILURE) {
+ ZEND_WRONG_PARAM_COUNT();
+ }
+
+ GET_REFLECTION_OBJECT_PTR(ce);
+
+ if (zend_hash_find(&ce->function_table, Z_STRVAL_PP(name), Z_STRLEN_PP(name) + 1, (void**) &mptr) == SUCCESS) {
+ reflection_method_factory(ce, mptr, return_value TSRMLS_CC);
+ } else {
+ RETURN_NULL();
+ }
+}
+/* }}} */
+
+static int _addmethod(zend_function *mptr, int num_args, va_list args, zend_hash_key *hash_key)
+{
+ zval *method;
+ zend_class_entry *ce = *va_arg(args, zend_class_entry**);
+
+ ALLOC_ZVAL(method);
+ reflection_method_factory(ce, mptr, method TSRMLS_CC);
+ add_next_index_zval(va_arg(args, zval*), method);
+ return 0;
+}
+
+/* {{{ proto PHP_Method[] Reflection_Class::getMethods()
+ Returns an array of this class' methods */
+ZEND_FUNCTION(reflection_class_getmethods)
+{
+ reflection_object *intern;
+ zend_class_entry *ce;
+ zval **name;
+ int argc = ZEND_NUM_ARGS();
+
+ METHOD_NOTSTATIC;
+ if (zend_get_parameters_ex(argc, &name) == FAILURE) {
+ ZEND_WRONG_PARAM_COUNT();
+ }
+
+ GET_REFLECTION_OBJECT_PTR(ce);
+
+ array_init(return_value);
+ zend_hash_apply_with_arguments(&ce->function_table, (apply_func_args_t) _addmethod, 2, &ce, return_value);
+}
+/* }}} */
+
/* {{{ proto array Reflection_Class::getConstants()
Returns an associative array containing this class' constants and their values */
ZEND_FUNCTION(reflection_class_getconstants)
@@ -529,6 +833,27 @@
}
/* }}} */
+/* {{{ proto bool Reflection_Class::getModifiers()
+ Returns the access modifiers for this class */
+ZEND_FUNCTION(reflection_class_getmodifiers)
+{
+ reflection_object *intern;
+ zend_class_entry *ce;
+
+ METHOD_NOTSTATIC_NUMPARAMS(0);
+ GET_REFLECTION_OBJECT_PTR(ce);
+
+ array_init(return_value);
+
+ if (ce->ce_flags & ZEND_ACC_ABSTRACT_CLASS) {
+ add_assoc_bool_ex(return_value, "abstract", sizeof("abstract"), 1);
+ }
+ if (ce->ce_flags & ZEND_ACC_FINAL_CLASS) {
+ add_assoc_bool_ex(return_value, "final", sizeof("final"), 1);
+ }
+}
+/* }}} */
+
/* {{{ proto bool Reflection_Class::isInstance(stdclass object)
Returns whether the given object is an instance of this class */
ZEND_FUNCTION(reflection_class_isinstance)
@@ -546,6 +871,44 @@
}
/* }}} */
+/* {{{ proto stdclass Reflection_Class::newInstance(mixed* args)
+ Returns an instance of this class */
+ZEND_FUNCTION(reflection_class_newinstance)
+{
+ zval *retval_ptr;
+ reflection_object *intern;
+ zend_class_entry *ce;
+ int argc = ZEND_NUM_ARGS();
+
+ METHOD_NOTSTATIC;
+ GET_REFLECTION_OBJECT_PTR(ce);
+
+ object_init_ex(return_value, ce);
+
+ /* Run the constructor if there is one */
+ if (ce->constructor) {
+ zval ***params;
+
+ params = safe_emalloc(sizeof(zval **), argc, 0);
+ if (zend_get_parameters_array_ex(argc, params) == FAILURE) {
+ efree(params);
+ RETURN_FALSE;
+ }
+
+ if (fast_call_user_function(EG(function_table), &return_value, NULL,
+ &retval_ptr, argc, params,
+ 1, NULL, &ce->constructor TSRMLS_CC) == FAILURE) {
+ efree(params);
+ zend_error(E_WARNING, "Invokation of %s's constructor failed\n", ce->name);
+ RETURN_NULL();
+ }
+ if (retval_ptr) {
+ zval_ptr_dtor(&retval_ptr);
+ }
+ efree(params);
+ }
+}
+/* }}} */
/* {{{ proto Reflection_Class[] Reflection_Class::getInterfaces()
Returns an array of interfaces this class implements */
@@ -605,6 +968,20 @@
{NULL, NULL, NULL}
};
+static zend_function_entry reflection_method_functions[] = {
+ ZEND_FE(reflection_method, NULL)
+ ZEND_NAMED_FE(ispublic, ZEND_FN(reflection_method_ispublic), NULL)
+ ZEND_NAMED_FE(isprivate, ZEND_FN(reflection_method_isprivate), NULL)
+ ZEND_NAMED_FE(isprotected, ZEND_FN(reflection_method_isprotected), NULL)
+ ZEND_NAMED_FE(isabstract, ZEND_FN(reflection_method_isabstract), NULL)
+ ZEND_NAMED_FE(isfinal, ZEND_FN(reflection_method_isfinal), NULL)
+ ZEND_NAMED_FE(isstatic, ZEND_FN(reflection_method_isstatic), NULL)
+ ZEND_NAMED_FE(getmodifiers, ZEND_FN(reflection_method_getmodifiers), NULL)
+ ZEND_NAMED_FE(isconstructor, ZEND_FN(reflection_method_isconstructor), NULL)
+ ZEND_NAMED_FE(invoke, ZEND_FN(reflection_method_invoke), NULL)
+ {NULL, NULL, NULL}
+};
+
static zend_function_entry reflection_class_functions[] = {
ZEND_FE(reflection_class, NULL)
ZEND_NAMED_FE(getname, ZEND_FN(reflection_class_getname), NULL)
@@ -614,23 +991,35 @@
ZEND_NAMED_FE(getstartline, ZEND_FN(reflection_class_getstartline), NULL)
ZEND_NAMED_FE(getendline, ZEND_FN(reflection_class_getendline), NULL)
ZEND_NAMED_FE(getdoccomment, ZEND_FN(reflection_class_getdoccomment), NULL)
+ ZEND_NAMED_FE(getconstructor, ZEND_FN(reflection_class_getconstructor), NULL)
+ ZEND_NAMED_FE(getmethod, ZEND_FN(reflection_class_getmethod), NULL)
+ ZEND_NAMED_FE(getmethods, ZEND_FN(reflection_class_getmethods), NULL)
ZEND_NAMED_FE(getconstants, ZEND_FN(reflection_class_getconstants), NULL)
ZEND_NAMED_FE(getconstant, ZEND_FN(reflection_class_getconstant), NULL)
ZEND_NAMED_FE(getinterfaces, ZEND_FN(reflection_class_getinterfaces), NULL)
ZEND_NAMED_FE(isinterface, ZEND_FN(reflection_class_isinterface), NULL)
ZEND_NAMED_FE(isabstract, ZEND_FN(reflection_class_isabstract), NULL)
ZEND_NAMED_FE(isfinal, ZEND_FN(reflection_class_isfinal), NULL)
+ ZEND_NAMED_FE(getmodifiers, ZEND_FN(reflection_class_getmodifiers), NULL)
ZEND_NAMED_FE(isinstance, ZEND_FN(reflection_class_isinstance), NULL)
+ ZEND_NAMED_FE(newinstance, ZEND_FN(reflection_class_newinstance), NULL)
ZEND_NAMED_FE(getparentclass, ZEND_FN(reflection_class_getparentclass), NULL)
{NULL, NULL, NULL}
};
ZEND_API void zend_register_reflection_api(TSRMLS_D) {
zend_class_entry _reflection_entry;
+
memcpy(&reflection_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
+
INIT_CLASS_ENTRY(_reflection_entry, "reflection_function", reflection_function_functions);
_reflection_entry.create_object = reflection_objects_new;
reflection_function_ptr = zend_register_internal_class(&_reflection_entry TSRMLS_CC);
+
+ INIT_CLASS_ENTRY(_reflection_entry, "reflection_method", reflection_method_functions);
+ _reflection_entry.create_object = reflection_objects_new;
+ reflection_method_ptr = zend_register_internal_class_ex(&_reflection_entry, reflection_function_ptr, NULL TSRMLS_CC);
+
INIT_CLASS_ENTRY(_reflection_entry, "reflection_class", reflection_class_functions);
_reflection_entry.create_object = reflection_objects_new;
reflection_class_ptr = zend_register_internal_class(&_reflection_entry TSRMLS_CC);
--
PHP Internals - PHP Runtime Development Mailing List
To unsubscribe, visit: http://www.php.net/unsub.php
