- Fixed bug #46064 (Exception when creating ReflectionProperty object on dynamicly...

diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c
index de80f877716c10f47cafca7c3f00549f325b8eeb..698542be4c6eddaa080050981bdd6348cc3b4671 100644 (file)
--- a/ext/reflection/php_reflection.c
+++ b/ext/reflection/php_reflection.c
@@ -1424,6 +1424,9 @@ ZEND_METHOD(reflection, getModifierNames)
        if (modifiers & (ZEND_ACC_FINAL | ZEND_ACC_FINAL_CLASS)) {
                add_next_index_ascii_stringl(return_value, "final", sizeof("final")-1, 1);
        }
+       if (modifiers & ZEND_ACC_IMPLICIT_PUBLIC) {
+               add_next_index_ascii_stringl(return_value, "public", sizeof("public")-1, 1);
+       }
 
        /* These are mutually exclusive */
        switch (modifiers & ZEND_ACC_PPP_MASK) {
@@ -3468,7 +3471,8 @@ ZEND_METHOD(reflection_class, getProperty)
        zend_property_info *property_info;
        zstr name, classname;
        zstr tmp; 
-       int name_len, classname_len, tmp_len;
+       int name_len, classname_len;
+       unsigned int tmp_len;
        zend_uchar name_type;
 
        METHOD_NOTSTATIC(reflection_class_ptr);
@@ -3482,6 +3486,20 @@ ZEND_METHOD(reflection_class, getProperty)
                        reflection_property_factory(ce, property_info, return_value TSRMLS_CC);
                }
                return;
+       } else if (intern->obj) {
+               /* Check for dynamic properties */
+               if (zend_u_hash_exists(Z_OBJ_HT_P(intern->obj)->get_properties(intern->obj TSRMLS_CC), name_type, name, name_len+1)) {
+                       zend_property_info property_info_tmp;
+                       property_info_tmp.flags = ZEND_ACC_IMPLICIT_PUBLIC;
+                       property_info_tmp.name = name;
+                       property_info_tmp.name_length = name_len;
+                       property_info_tmp.h = zend_u_get_hash_value(name_type, name, name_len+1);
+                       property_info_tmp.doc_comment = NULL_ZSTR;
+                       property_info_tmp.ce = ce;
+
+                       reflection_property_factory(ce, &property_info_tmp, return_value TSRMLS_CC);
+                       return;
+               }
        }
        if ((name_type == IS_UNICODE && (tmp.u = u_strstr(name.u, u_doublecolon)) != NULL)
                || (name_type == IS_STRING  && (tmp.s =   strstr(name.s, "::")) != NULL))
@@ -4229,12 +4247,12 @@ ZEND_METHOD(reflection_property, __construct)
 {
        zval *propname, *classname;
        zstr name_str, class_name, prop_name;
-       int name_len;
+       int name_len, dynam_prop = 0;
        zval *object;
        reflection_object *intern;
        zend_class_entry **pce;
        zend_class_entry *ce;
-       zend_property_info *property_info;
+       zend_property_info *property_info = NULL;
        property_reference *reference;
        zend_uchar name_type;
 
@@ -4270,12 +4288,19 @@ ZEND_METHOD(reflection_property, __construct)
        }
 
        if (zend_u_hash_find(&ce->properties_info, name_type, name_str, name_len + 1, (void **) &property_info) == FAILURE || (property_info->flags & ZEND_ACC_SHADOW)) {
-               zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC, 
-                       "Property %v::$%R does not exist", ce->name, name_type, name_str);
-               return;
+               /* Check for dynamic properties */
+               if (property_info == NULL && Z_TYPE_P(classname) == IS_OBJECT && Z_OBJ_HT_P(classname)->get_properties) {
+                       if (zend_u_hash_exists(Z_OBJ_HT_P(classname)->get_properties(classname TSRMLS_CC), name_type, name_str, name_len+1)) {
+                               dynam_prop = 1;
+                       }
+               }
+               if (dynam_prop == 0) {
+                       zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC, "Property %s::$%v does not exist", ce->name, name_str);
+                       return;
+               }
        }
        
-       if (!(property_info->flags & ZEND_ACC_PRIVATE)) {
+       if (dynam_prop == 0 && !(property_info->flags & ZEND_ACC_PRIVATE)) {
                /* we have to search the class hierarchy for this (implicit) public or protected property */
                zend_class_entry *tmp_ce = ce;
                zend_property_info *tmp_info;
@@ -4291,14 +4316,28 @@ ZEND_METHOD(reflection_property, __construct)
        ZVAL_TEXTL(classname, ce->name, ce->name_length, 1);
        zend_ascii_hash_update(Z_OBJPROP_P(object), "class", sizeof("class"), (void **) &classname, sizeof(zval *), NULL);
        
-       zend_u_unmangle_property_name(UG(unicode)?IS_UNICODE:IS_STRING, property_info->name, property_info->name_length, &class_name, &prop_name);
+       
        MAKE_STD_ZVAL(propname);
-       ZVAL_TEXT(propname, prop_name, 1);
+       if (dynam_prop == 0) {
+               zend_u_unmangle_property_name(UG(unicode)?IS_UNICODE:IS_STRING, property_info->name, property_info->name_length, &class_name, &prop_name);
+               ZVAL_TEXT(propname, prop_name, 1);
+       } else {
+               ZVAL_TEXTL(propname, name_str, name_len, 1);
+       }
        zend_ascii_hash_update(Z_OBJPROP_P(object), "name", sizeof("name"), (void **) &propname, sizeof(zval *), NULL);
 
        reference = (property_reference*) emalloc(sizeof(property_reference));
+       if (dynam_prop) {
+               reference->prop.flags = ZEND_ACC_IMPLICIT_PUBLIC;
+               reference->prop.name = Z_UNIVAL_P(propname);
+               reference->prop.name_length = Z_UNILEN_P(propname);
+               reference->prop.h = zend_u_get_hash_value(name_type, name_str, name_len+1);
+               reference->prop.doc_comment = NULL_ZSTR;
+               reference->prop.ce = ce;
+       } else {
+               reference->prop = *property_info;
+       }
        reference->ce = ce;
-       reference->prop = *property_info;
        reference->ignore_visibility = 0;
        intern->ptr = reference;
        intern->ref_type = REF_TYPE_PROPERTY;
@@ -4346,7 +4385,7 @@ static void _property_check_flag(INTERNAL_FUNCTION_PARAMETERS, int mask) /* {{{
    Returns whether this property is public */
 ZEND_METHOD(reflection_property, isPublic)
 {
-       _property_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_PUBLIC);
+       _property_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_PUBLIC | ZEND_ACC_IMPLICIT_PUBLIC);
 }
 /* }}} */
 
@@ -4439,7 +4478,7 @@ ZEND_METHOD(reflection_property, getValue)
        METHOD_NOTSTATIC(reflection_property_ptr);
        GET_REFLECTION_OBJECT_PTR(ref);
 
-       if (!(ref->prop.flags & ZEND_ACC_PUBLIC) && ref->ignore_visibility == 0) {
+       if (!(ref->prop.flags & (ZEND_ACC_PUBLIC | ZEND_ACC_IMPLICIT_PUBLIC)) && ref->ignore_visibility == 0) {
                _default_get_entry(getThis(), "name", sizeof("name"), &name TSRMLS_CC);
                zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC, 
                        "Cannot access non-public member %v::%v", intern->ce->name, Z_UNIVAL(name));

diff --git a/ext/reflection/tests/bug46064.phpt b/ext/reflection/tests/bug46064.phpt
new file mode 100644 (file)
index 0000000..c11829a
--- /dev/null
+++ b/ext/reflection/tests/bug46064.phpt
@@ -0,0 +1,81 @@
+--TEST--
+Bug #46064 (Exception when creating ReflectionProperty object on dynamicly created property)
+--FILE--
+<?php
+
+class x {
+       public $zzz = 2;
+}
+
+$o = new x;
+$o->z = 1000;
+$o->zzz = 3;
+
+var_dump($h = new reflectionproperty($o, 'z'));
+var_dump($h->isDefault());
+var_dump($h->isPublic());
+var_dump($h->isStatic());
+var_dump($h->getName());
+var_dump(Reflection::getModifierNames($h->getModifiers()));
+var_dump($h->getValue($o));
+
+print "---------------------------\n";
+try {
+       var_dump(new reflectionproperty($o, 'zz'));
+} catch (Exception $e) {
+       var_dump($e->getMessage());
+}
+
+var_dump(new reflectionproperty($o, 'zzz'));
+
+class test {
+       protected $a = 1;
+}
+
+class bar extends test {
+       public function __construct() {
+               $this->foobar = 2;
+               $this->a = 200;
+               
+               $p = new reflectionproperty($this, 'a');
+               $p->setAccessible(true);
+               var_dump($p->getValue($this), $p->isDefault(), $p->isPublic());
+               
+               $p = new reflectionproperty($this, 'foobar');
+               var_dump($p->getValue($this), $p->isDefault(), $p->isPublic());
+       }
+}
+
+new bar;
+
+?>
+--EXPECTF--
+object(ReflectionProperty)#2 (2) {
+  [u"name"]=>
+  unicode(1) "z"
+  [u"class"]=>
+  unicode(1) "x"
+}
+bool(false)
+bool(true)
+bool(false)
+unicode(1) "z"
+array(1) {
+  [0]=>
+  unicode(6) "public"
+}
+int(1000)
+---------------------------
+unicode(30) "Property x::$zz does not exist"
+object(ReflectionProperty)#3 (2) {
+  [u"name"]=>
+  unicode(3) "zzz"
+  [u"class"]=>
+  unicode(1) "x"
+}
+int(200)
+bool(true)
+bool(false)
+int(2)
+bool(false)
+bool(true)

diff --git a/ext/reflection/tests/bug46064_2.phpt b/ext/reflection/tests/bug46064_2.phpt
new file mode 100644 (file)
index 0000000..90bde69
--- /dev/null
+++ b/ext/reflection/tests/bug46064_2.phpt
@@ -0,0 +1,72 @@
+--TEST--
+Bug #46064.2 (Exception when creating ReflectionProperty object on dynamicly created property)
+--FILE--
+<?php
+
+class foo { 
+}
+
+$x = new foo;
+$x->test = 2000;
+
+
+$p = new ReflectionObject($x);
+var_dump($p->getProperty('test'));
+
+
+class bar {
+       public function __construct() {
+               $this->a = 1;
+       }
+}
+
+class test extends bar {
+       private $b = 2;
+
+       public function __construct() {
+               parent::__construct();
+               
+               $p = new reflectionobject($this);
+               var_dump($h = $p->getProperty('a'));
+               var_dump($h->isDefault(), $h->isProtected(), $h->isPrivate(), $h->isPublic(), $h->isStatic());
+               var_dump($p->getProperties());
+       }
+}
+
+new test;
+
+?>
+--EXPECT--
+object(ReflectionProperty)#3 (2) {
+  [u"name"]=>
+  unicode(4) "test"
+  [u"class"]=>
+  unicode(3) "foo"
+}
+object(ReflectionProperty)#5 (2) {
+  [u"name"]=>
+  unicode(1) "a"
+  [u"class"]=>
+  unicode(4) "test"
+}
+bool(false)
+bool(false)
+bool(false)
+bool(true)
+bool(false)
+array(2) {
+  [0]=>
+  &object(ReflectionProperty)#6 (2) {
+    [u"name"]=>
+    unicode(1) "b"
+    [u"class"]=>
+    unicode(4) "test"
+  }
+  [1]=>
+  &object(ReflectionProperty)#7 (2) {
+    [u"name"]=>
+    unicode(1) "a"
+    [u"class"]=>
+    unicode(4) "test"
+  }
+}