On Wed, 2003-07-02 at 05:32, Timm Friebe wrote:
[...]
> This should now be the final patch.
Then again, it would help to attach it:)
- 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 2 Jul 2003 03:34:34 -0000
@@ -17,8 +17,6 @@
*/
/* $Id: zend_reflection_api.c,v 1.7 2003/07/01 18:41:42 gschlossnagle Exp $ */
-#include <assert.h>
-
#include "zend.h"
#include "zend_API.h"
#include "zend_default_classes.h"
@@ -42,6 +40,7 @@
} \
#define _DO_THROW(msg) \
+ { \
extern zend_class_entry *default_exception_ptr; \
zval *ex; \
zval *tmp; \
@@ -63,11 +62,19 @@
zend_hash_update(Z_OBJPROP_P(ex), "line", sizeof("line"), (void **) &tmp, sizeof(zval *), NULL); \
tmp = NULL; \
\
- EG(exception) = ex;
+ EG(exception) = ex; \
+ return; \
+ }
+typedef struct _property_reference {
+ zend_class_entry *ce;
+ zend_property_info *prop;
+} property_reference;
zend_class_entry *reflection_function_ptr;
zend_class_entry *reflection_class_ptr;
+zend_class_entry *reflection_method_ptr;
+zend_class_entry *reflection_property_ptr;
static zend_object_handlers reflection_object_handlers;
@@ -86,10 +93,16 @@
typedef struct {
zend_object zo;
void *ptr;
+ unsigned int free_ptr:1;
} reflection_object;
static void reflection_objects_dtor(void *object, zend_object_handle handle TSRMLS_DC)
{
+ reflection_object *intern = (reflection_object *) object;
+
+ if (intern->free_ptr) {
+ efree(intern->ptr);
+ }
zend_objects_destroy_object(object, handle TSRMLS_CC);
}
@@ -104,6 +117,7 @@
(*intern_clone)->zo.in_set = 0;
ALLOC_HASHTABLE((*intern_clone)->zo.properties);
(*intern_clone)->ptr = intern->ptr;
+ (*intern_clone)->free_ptr = intern->free_ptr;
}
ZEND_API zend_object_value reflection_objects_new(zend_class_entry *class_type TSRMLS_DC)
@@ -119,7 +133,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,10 +174,12 @@
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);
intern->ptr = fptr;
+ intern->free_ptr = 0;
}
/* }}} */
@@ -317,14 +333,285 @@
{
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);
intern->ptr = ce;
+ intern->free_ptr = 0;
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;
+ intern->free_ptr = 0;
+ 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);
+}
+
+void reflection_property_factory(zend_class_entry *ce, zend_property_info *prop, zval *object TSRMLS_DC)
+{
+ reflection_object *intern;
+ zval *name;
+ zval *classname;
+ property_reference *reference;
+
+ MAKE_STD_ZVAL(name);
+
+ /* Unmangle the property name if necessary */
+ if (prop->name[0] != 0) {
+ ZVAL_STRINGL(name, prop->name, prop->name_length, 1);
+ } else {
+ char* tmp;
+
+ tmp= prop->name+ 1;
+ ZVAL_STRING(name, tmp + strlen(tmp) + 1, 1);
+ }
+ MAKE_STD_ZVAL(classname);
+ ZVAL_STRINGL(classname, ce->name, ce->name_length, 1);
+ reflection_instanciate(reflection_property_ptr, object TSRMLS_CC);
+ intern = (reflection_object *) zend_object_store_get_object(object TSRMLS_CC);
+ reference = (property_reference*) emalloc(sizeof(property_reference));
+ reference->ce = ce;
+ reference->prop = prop;
+ intern->ptr = reference;
+ intern->free_ptr = 1;
+ 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;
+ intern->free_ptr = 0;
+}
+/* }}} */
+
+/* {{{ 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 instance of %s", mptr->common.scope->name);
+ efree(params);
+ RETURN_FALSE;
+ }
+
+ if (fast_call_user_function(EG(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 void Reflection_Method::getDeclaringClass()
+ Get the declaring class */
+ZEND_FUNCTION(reflection_method_getdeclaringclass)
+{
+ reflection_object *intern;
+ zend_function *mptr;
+
+ METHOD_NOTSTATIC;
+ GET_REFLECTION_OBJECT_PTR(mptr);
+
+ reflection_class_factory(mptr->common.scope, return_value TSRMLS_CC);
+}
+
/* {{{ 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,10 +637,12 @@
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);
intern->ptr = *ce;
+ intern->free_ptr = 0;
}
/* }}} */
@@ -456,6 +745,138 @@
}
/* }}} */
+/* {{{ 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 Reflection_Property Reflection_Class::getProperty(string name)
+ Returns the class' property specified by it's name */
+ZEND_FUNCTION(reflection_class_getproperty)
+{
+ reflection_object *intern;
+ zend_class_entry *ce;
+ zend_property_info *property_info;
+ 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->properties_info, Z_STRVAL_PP(name), Z_STRLEN_PP(name) + 1, (void**) &property_info) == SUCCESS) {
+ reflection_property_factory(ce, property_info, return_value TSRMLS_CC);
+ } else {
+ RETURN_NULL();
+ }
+}
+/* }}} */
+
+static int _addproperty(zend_property_info *pptr, int num_args, va_list args, zend_hash_key *hash_key)
+{
+ zval *property;
+ zend_class_entry *ce = *va_arg(args, zend_class_entry**);
+
+ ALLOC_ZVAL(property);
+ reflection_property_factory(ce, pptr, property TSRMLS_CC);
+ add_next_index_zval(va_arg(args, zval*), property);
+ return 0;
+}
+
+/* {{{ proto Reflection_Property[] Reflection_Class::getProperties()
+ Returns an array of this class' properties */
+ZEND_FUNCTION(reflection_class_getproperties)
+{
+ 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->properties_info, (apply_func_args_t) _addproperty, 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)
@@ -495,7 +916,7 @@
}
/* }}} */
-static void _check_flag(INTERNAL_FUNCTION_PARAMETERS, int mask)
+static void _class_check_flag(INTERNAL_FUNCTION_PARAMETERS, int mask)
{
reflection_object *intern;
zend_class_entry *ce;
@@ -509,7 +930,7 @@
Returns whether this is an interface or a class */
ZEND_FUNCTION(reflection_class_isinterface)
{
- _check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_INTERFACE);
+ _class_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_INTERFACE);
}
/* }}} */
@@ -517,7 +938,7 @@
Returns whether this class is final */
ZEND_FUNCTION(reflection_class_isfinal)
{
- _check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_FINAL_CLASS);
+ _class_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_FINAL_CLASS);
}
/* }}} */
@@ -525,7 +946,28 @@
Returns whether this class is abstract */
ZEND_FUNCTION(reflection_class_isabstract)
{
- _check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_ABSTRACT_CLASS);
+ _class_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_ABSTRACT_CLASS);
+}
+/* }}} */
+
+/* {{{ 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);
+ }
}
/* }}} */
@@ -546,6 +988,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 */
@@ -591,6 +1071,254 @@
}
/* }}} */
+/* {{{ proto Reflection_Property Reflection_Property::__construct(mixed class, string name)
+ Constructor. Throws an Exception in case the given property does not exist */
+ZEND_FUNCTION(reflection_property)
+{
+ zval **name, **class;
+ zval *classname;
+ zval *object;
+ reflection_object *intern;
+ char *lcname;
+ zend_class_entry **pce;
+ zend_class_entry *ce;
+ zend_property_info *property_info;
+ property_reference *reference;
+
+ 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->properties_info, lcname, (int)(Z_STRLEN_PP(name) + 1), (void **) &property_info) == FAILURE) {
+ efree(lcname);
+ _DO_THROW("Property does not exist");
+ /* returns out of this function */
+ }
+ efree(lcname);
+
+ reference = (property_reference*) emalloc(sizeof(property_reference));
+ reference->ce = ce;
+ reference->prop = property_info;
+ intern->ptr = reference;
+ intern->free_ptr = 1;
+}
+/* }}} */
+
+/* {{{ proto string Reflection_Property::getName()
+ Returns the class' name */
+ZEND_FUNCTION(reflection_property_getname)
+{
+ METHOD_NOTSTATIC_NUMPARAMS(0);
+ _default_get_entry(getThis(), "name", sizeof("name"), return_value TSRMLS_CC);
+}
+/* }}} */
+
+static void _property_check_flag(INTERNAL_FUNCTION_PARAMETERS, int mask)
+{
+ reflection_object *intern;
+ property_reference *ref;
+
+ METHOD_NOTSTATIC_NUMPARAMS(0);
+ GET_REFLECTION_OBJECT_PTR(ref);
+ RETURN_BOOL(ref->prop->flags & mask);
+}
+
+/* {{{ proto bool Reflection_Property::isPublic()
+ Returns whether this property is public */
+ZEND_FUNCTION(reflection_property_ispublic)
+{
+ _property_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_PUBLIC);
+}
+/* }}} */
+
+/* {{{ proto bool Reflection_Property::isPrivate()
+ Returns whether this property is private */
+ZEND_FUNCTION(reflection_property_isprivate)
+{
+ _property_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_PRIVATE);
+}
+/* }}} */
+
+/* {{{ proto bool Reflection_Property::isProtected()
+ Returns whether this property is protected */
+ZEND_FUNCTION(reflection_property_isprotected)
+{
+ _property_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_PROTECTED);
+}
+/* }}} */
+
+/* {{{ proto bool Reflection_Property::isStatic()
+ Returns whether this property is static */
+ZEND_FUNCTION(reflection_property_isstatic)
+{
+ _property_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_STATIC);
+}
+/* }}} */
+
+/* {{{ proto bool Reflection_Property::isDefault()
+ Returns whether this property is default (declared at compilation time). */
+ZEND_FUNCTION(reflection_property_isdefault)
+{
+ _property_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ~ZEND_ACC_IMPLICIT_PUBLIC);
+}
+/* }}} */
+
+/* {{{ proto bool Reflection_Property::getModifiers()
+ Returns the access modifiers for this property */
+ZEND_FUNCTION(reflection_property_getmodifiers)
+{
+ reflection_object *intern;
+ property_reference *ref;
+
+ METHOD_NOTSTATIC_NUMPARAMS(0);
+ GET_REFLECTION_OBJECT_PTR(ref);
+
+ array_init(return_value);
+
+ switch (ref->prop->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 (ref->prop->flags & ZEND_ACC_STATIC) {
+ add_assoc_bool_ex(return_value, "static", sizeof("static"), 1);
+ }
+}
+/* }}} */
+
+/* {{{ proto mixed Reflection_Property::getValue(stdclass object)
+ Returns this property's value */
+ZEND_FUNCTION(reflection_property_getvalue)
+{
+ reflection_object *intern;
+ property_reference *ref;
+ zval *object;
+ zval **member= NULL;
+
+ METHOD_NOTSTATIC;
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &object) == FAILURE) {
+ return;
+ }
+
+ GET_REFLECTION_OBJECT_PTR(ref);
+
+ if (zend_hash_quick_find(Z_OBJPROP_P(object), ref->prop->name, ref->prop->name_length + 1, ref->prop->h, (void **) &member) == FAILURE) {
+ zend_error(E_ERROR, "Internal error: Could not find the property %s", ref->prop->name);
+ /* Bails out */
+ }
+
+ *return_value= **member;
+ zval_copy_ctor(return_value);
+}
+/* }}} */
+
+/* {{{ proto void Reflection_Property::setValue(stdclass object, mixed value)
+ Sets this property's value */
+ZEND_FUNCTION(reflection_property_setvalue)
+{
+ reflection_object *intern;
+ property_reference *ref;
+ zval **variable_ptr;
+ zval *object;
+ zval *value;
+ int setter_done = 0;
+
+ METHOD_NOTSTATIC;
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "oz", &object, &value) == FAILURE) {
+ return;
+ }
+
+ GET_REFLECTION_OBJECT_PTR(ref);
+
+ if (zend_hash_quick_find(Z_OBJPROP_P(object), ref->prop->name, ref->prop->name_length + 1, ref->prop->h, (void **) &variable_ptr) == SUCCESS) {
+ if (*variable_ptr == value) {
+ setter_done = 1;
+ } else {
+ if (PZVAL_IS_REF(*variable_ptr)) {
+ zval_dtor(*variable_ptr);
+ (*variable_ptr)->type = value->type;
+ (*variable_ptr)->value = value->value;
+ if (value->refcount > 0) {
+ zval_copy_ctor(*variable_ptr);
+ }
+ setter_done = 1;
+ }
+ }
+ } else {
+ zend_error(E_ERROR, "Internal error: Could not find the property %s", ref->prop->name);
+ /* Bails out */
+ }
+
+ if (!setter_done) {
+ zval **foo;
+
+ value->refcount++;
+ if (PZVAL_IS_REF(value)) {
+ SEPARATE_ZVAL(&value);
+ }
+ zend_hash_quick_update(Z_OBJPROP_P(object), ref->prop->name, ref->prop->name_length+1, ref->prop->h, &value, sizeof(zval *), (void **) &foo);
+ }
+}
+/* }}} */
+
+/* {{{ proto void Reflection_Property::getDeclaringClass()
+ Get the declaring class */
+ZEND_FUNCTION(reflection_property_getdeclaringclass)
+{
+ reflection_object *intern;
+ property_reference *ref;
+
+ METHOD_NOTSTATIC_NUMPARAMS(0);
+ GET_REFLECTION_OBJECT_PTR(ref);
+
+ reflection_class_factory(ref->ce, return_value TSRMLS_CC);
+}
+
static zend_function_entry reflection_function_functions[] = {
ZEND_FE(reflection_function, NULL)
ZEND_NAMED_FE(isinternal, ZEND_FN(reflection_function_isinternal), NULL)
@@ -605,6 +1333,21 @@
{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)
+ ZEND_NAMED_FE(getdeclaringclass, ZEND_FN(reflection_method_getdeclaringclass), 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,26 +1357,59 @@
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(getproperty, ZEND_FN(reflection_class_getproperty), NULL)
+ ZEND_NAMED_FE(getproperties, ZEND_FN(reflection_class_getproperties), 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}
};
+static zend_function_entry reflection_property_functions[] = {
+ ZEND_FE(reflection_property, NULL)
+ ZEND_NAMED_FE(getname, ZEND_FN(reflection_property_getname), NULL)
+ ZEND_NAMED_FE(getvalue, ZEND_FN(reflection_property_getvalue), NULL)
+ ZEND_NAMED_FE(setvalue, ZEND_FN(reflection_property_setvalue), NULL)
+ ZEND_NAMED_FE(ispublic, ZEND_FN(reflection_property_ispublic), NULL)
+ ZEND_NAMED_FE(isprivate, ZEND_FN(reflection_property_isprivate), NULL)
+ ZEND_NAMED_FE(isprotected, ZEND_FN(reflection_property_isprotected), NULL)
+ ZEND_NAMED_FE(isstatic, ZEND_FN(reflection_property_isstatic), NULL)
+ ZEND_NAMED_FE(isdefault, ZEND_FN(reflection_property_isdefault), NULL)
+ ZEND_NAMED_FE(getmodifiers, ZEND_FN(reflection_property_getmodifiers), NULL)
+ ZEND_NAMED_FE(getdeclaringclass, ZEND_FN(reflection_property_getdeclaringclass), 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);
+
+ INIT_CLASS_ENTRY(_reflection_entry, "reflection_property", reflection_property_functions);
+ _reflection_entry.create_object = reflection_objects_new;
+ reflection_property_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
