diff options
| -rw-r--r-- | UPGRADING | 2 | ||||
| -rw-r--r-- | Zend/tests/weakrefs/weakmap_basic_map_behavior.phpt | 173 | ||||
| -rw-r--r-- | Zend/tests/weakrefs/weakmap_error_conditions.phpt | 96 | ||||
| -rw-r--r-- | Zend/tests/weakrefs/weakmap_iteration.phpt | 80 | ||||
| -rw-r--r-- | Zend/tests/weakrefs/weakmap_multiple_weakrefs.phpt | 74 | ||||
| -rw-r--r-- | Zend/tests/weakrefs/weakmap_weakness.phpt | 107 | ||||
| -rw-r--r-- | Zend/zend_weakrefs.c | 532 | ||||
| -rw-r--r-- | Zend/zend_weakrefs.stub.php | 24 | ||||
| -rw-r--r-- | Zend/zend_weakrefs_arginfo.h | 20 |
9 files changed, 1083 insertions, 25 deletions
@@ -330,6 +330,8 @@ PHP 8.0 UPGRADE NOTES - Core: . Added support for union types. RFC: https://wiki.php.net/rfc/union_types_v2 + . Added WeakMap. + RFC: https://wiki.php.net/rfc/weak_maps . Added ValueError class. ======================================== diff --git a/Zend/tests/weakrefs/weakmap_basic_map_behavior.phpt b/Zend/tests/weakrefs/weakmap_basic_map_behavior.phpt new file mode 100644 index 0000000000..6eb283c662 --- /dev/null +++ b/Zend/tests/weakrefs/weakmap_basic_map_behavior.phpt @@ -0,0 +1,173 @@ +--TEST-- +Basic WeakMap behavior (as a map) +--FILE-- +<?php + +$map = new WeakMap; +var_dump(count($map)); + +$obj = new stdClass; +$obj->value = 1; +$obj2 = new stdClass; +$obj2->value = 2; + +$map[$obj] = $obj2; +var_dump(count($map)); +var_dump($map); +var_dump(isset($map[$obj])); +var_dump(!empty($map[$obj])); +var_dump($map[$obj]); + +$map[$obj] = 42; +var_dump($map); +var_dump(isset($map[$obj])); +var_dump(!empty($map[$obj])); +var_dump($map[$obj]); + +$map[$obj] = false; +var_dump($map); +var_dump(isset($map[$obj])); +var_dump(!empty($map[$obj])); +var_dump($map[$obj]); + +$map[$obj] = null; +var_dump($map); +var_dump(isset($map[$obj])); +var_dump(!empty($map[$obj])); +var_dump($map[$obj]); + +unset($map[$obj]); +var_dump($map); +var_dump(isset($map[$obj])); +var_dump(!empty($map[$obj])); +try { + var_dump($map[$obj]); +} catch (Error $e) { + echo $e->getMessage(), "\n"; +} + +echo "\nIndirect modification:\n"; +$map[$obj] = []; +$map[$obj][] = 42; +$map[$obj2] = 41; +$map[$obj2]++; +var_dump($map); + +echo "\nMethods:\n"; +var_dump($map->offsetSet($obj2, 43)); +var_dump($map->offsetGet($obj2)); +var_dump($map->offsetExists($obj2)); +var_dump($map->count()); +var_dump($map->offsetUnset($obj2)); +var_dump($map->count()); + +?> +--EXPECT-- +int(0) +int(1) +object(WeakMap)#1 (1) { + [0]=> + array(2) { + ["key"]=> + object(stdClass)#2 (1) { + ["value"]=> + int(1) + } + ["value"]=> + object(stdClass)#3 (1) { + ["value"]=> + int(2) + } + } +} +bool(true) +bool(true) +object(stdClass)#3 (1) { + ["value"]=> + int(2) +} +object(WeakMap)#1 (1) { + [0]=> + array(2) { + ["key"]=> + object(stdClass)#2 (1) { + ["value"]=> + int(1) + } + ["value"]=> + int(42) + } +} +bool(true) +bool(true) +int(42) +object(WeakMap)#1 (1) { + [0]=> + array(2) { + ["key"]=> + object(stdClass)#2 (1) { + ["value"]=> + int(1) + } + ["value"]=> + bool(false) + } +} +bool(true) +bool(false) +bool(false) +object(WeakMap)#1 (1) { + [0]=> + array(2) { + ["key"]=> + object(stdClass)#2 (1) { + ["value"]=> + int(1) + } + ["value"]=> + NULL + } +} +bool(false) +bool(false) +NULL +object(WeakMap)#1 (0) { +} +bool(false) +bool(false) +Object stdClass#2 not contained in WeakMap + +Indirect modification: +object(WeakMap)#1 (2) { + [0]=> + array(2) { + ["key"]=> + object(stdClass)#2 (1) { + ["value"]=> + int(1) + } + ["value"]=> + array(1) { + [0]=> + int(42) + } + } + [1]=> + array(2) { + ["key"]=> + object(stdClass)#3 (1) { + ["value"]=> + int(2) + } + ["value"]=> + int(42) + } +} + +Methods: +NULL +int(43) +bool(true) +int(2) +NULL +int(1) diff --git a/Zend/tests/weakrefs/weakmap_error_conditions.phpt b/Zend/tests/weakrefs/weakmap_error_conditions.phpt new file mode 100644 index 0000000000..75a824f422 --- /dev/null +++ b/Zend/tests/weakrefs/weakmap_error_conditions.phpt @@ -0,0 +1,96 @@ +--TEST-- +WeakMap error conditions +--FILE-- +<?php + +$map = new WeakMap; +try { + $map[1] = 2; +} catch (TypeError $e) { + echo $e->getMessage(), "\n"; +} +try { + var_dump($map[1]); +} catch (TypeError $e) { + echo $e->getMessage(), "\n"; +} +try { + isset($map[1]); +} catch (TypeError $e) { + echo $e->getMessage(), "\n"; +} +try { + unset($map[1]); +} catch (TypeError $e) { + echo $e->getMessage(), "\n"; +} + +try { + $map[] = 1; +} catch (Error $e) { + echo $e->getMessage(), "\n"; +} +try { + $map[][1] = 1; +} catch (Error $e) { + echo $e->getMessage(), "\n"; +} +try { + var_dump($map[new stdClass]); +} catch (Error $e) { + echo $e->getMessage(), "\n"; +} + +try { + $map->prop = 1; +} catch (Error $e) { + echo $e->getMessage(), "\n"; +} +try { + var_dump($map->prop); +} catch (Error $e) { + echo $e->getMessage(), "\n"; +} +try { + $r =& $map->prop; +} catch (Error $e) { + echo $e->getMessage(), "\n"; +} +try { + isset($map->prop); +} catch (Error $e) { + echo $e->getMessage(), "\n"; +} +try { + unset($map->prop); +} catch (Error $e) { + echo $e->getMessage(), "\n"; +} + +try { + serialize($map); +} catch (Exception $e) { + echo $e->getMessage(), "\n"; +} +try { + unserialize('C:7:"WeakMap":0:{}'); +} catch (Exception $e) { + echo $e->getMessage(), "\n"; +} + +?> +--EXPECT-- +WeakMap key must be an object +WeakMap key must be an object +WeakMap key must be an object +WeakMap key must be an object +Cannot append to WeakMap +Cannot append to WeakMap +Object stdClass#2 not contained in WeakMap +WeakMap objects do not support properties +WeakMap objects do not support properties +WeakMap objects do not support property references +WeakMap objects do not support properties +WeakMap objects do not support properties +Serialization of 'WeakMap' is not allowed +Unserialization of 'WeakMap' is not allowed diff --git a/Zend/tests/weakrefs/weakmap_iteration.phpt b/Zend/tests/weakrefs/weakmap_iteration.phpt new file mode 100644 index 0000000000..1d1f6def8f --- /dev/null +++ b/Zend/tests/weakrefs/weakmap_iteration.phpt @@ -0,0 +1,80 @@ +--TEST-- +WeakMap iteration +--FILE-- +<?php + +$map = new WeakMap; + +echo "\nEmpty loop:\n"; +foreach ($map as $key => $value) { + var_dump($key, $value); +} + +echo "\nSimple loop:\n"; +$obj0 = new stdClass; +$obj1 = new stdClass; +$obj2 = new stdClass; +$map[$obj0] = 0; +$map[$obj1] = 1; +$map[$obj2] = 2; +foreach ($map as $key => $value) { + var_dump($key, $value); +} + +echo "\nObject removed during loop:\n"; +foreach ($map as $key => $value) { + if (isset($obj1) && $key === $obj1) unset($obj1); + var_dump($key, $value); +} + +echo "\nBy reference iteration:\n"; +foreach ($map as $key => &$value) { + $value++; +} +var_dump($map); + +?> +--EXPECT-- +Empty loop: + +Simple loop: +object(stdClass)#2 (0) { +} +int(0) +object(stdClass)#3 (0) { +} +int(1) +object(stdClass)#4 (0) { +} +int(2) + +Object removed during loop: +object(stdClass)#2 (0) { +} +int(0) +object(stdClass)#3 (0) { +} +int(1) +object(stdClass)#4 (0) { +} +int(2) + +By reference iteration: +object(WeakMap)#1 (2) { + [0]=> + array(2) { + ["key"]=> + object(stdClass)#2 (0) { + } + ["value"]=> + &int(1) + } + [1]=> + array(2) { + ["key"]=> + object(stdClass)#4 (0) { + } + ["value"]=> + &int(3) + } +} diff --git a/Zend/tests/weakrefs/weakmap_multiple_weakrefs.phpt b/Zend/tests/weakrefs/weakmap_multiple_weakrefs.phpt new file mode 100644 index 0000000000..c3a1edaf05 --- /dev/null +++ b/Zend/tests/weakrefs/weakmap_multiple_weakrefs.phpt @@ -0,0 +1,74 @@ +--TEST-- +Multiple WeakMaps / WeakRefs on the same object +--FILE-- +<?php + +$obj = new stdClass; + +$ref = WeakReference::create($obj); +$map = new WeakMap; +$map[$obj] = 1; +$map2 = new WeakMap; +$map2[$obj] = 1; +$map3 = clone $map2; + +var_dump($ref->get(), $map, $map2, $map3); +unset($obj); +var_dump($ref->get(), $map, $map2, $map3); +unset($ref, $map, $map2); + +$obj = new stdClass; +$ref = WeakReference::create($obj); +$map = new WeakMap; +$map[$obj] = 1; +$map2 = new WeakMap; +$map2[$obj] = 1; +$map3 = clone $map2; + +unset($ref, $map, $map2, $map3); +var_dump($obj); +unset($obj); + +?> +--EXPECT-- +object(stdClass)#1 (0) { +} +object(WeakMap)#3 (1) { + [0]=> + array(2) { + ["key"]=> + object(stdClass)#1 (0) { + } + ["value"]=> + int(1) + } +} +object(WeakMap)#4 (1) { + [0]=> + array(2) { + ["key"]=> + object(stdClass)#1 (0) { + } + ["value"]=> + int(1) + } +} +object(WeakMap)#5 (1) { + [0]=> + array(2) { + ["key"]=> + object(stdClass)#1 (0) { + } + ["value"]=> + int(1) + } +} +NULL +object(WeakMap)#3 (0) { +} +object(WeakMap)#4 (0) { +} +object(WeakMap)#5 (0) { +} +object(stdClass)#4 (0) { +} diff --git a/Zend/tests/weakrefs/weakmap_weakness.phpt b/Zend/tests/weakrefs/weakmap_weakness.phpt new file mode 100644 index 0000000000..5e57dead56 --- /dev/null +++ b/Zend/tests/weakrefs/weakmap_weakness.phpt @@ -0,0 +1,107 @@ +--TEST-- +The weak part of the WeakMap +--FILE-- +<?php + +$map = new WeakMap; + +// This is doing to be inserted into the map and immediately removed again +$map[new stdClass] = 1; +var_dump($map); + +$obj = new stdClass; +$map[$obj] = 2; +var_dump($map); + +unset($obj); +var_dump($map); + +echo "\nDestructor in WeakMap value:\n"; +$obj = new stdClass; +$map[$obj] = new class { + public function __destruct() { + echo "Dtor!\n"; + } +}; + +echo "Before unset:\n"; +unset($obj); +echo "After unset:\n"; +var_dump($map); + +echo "\nDestroying map with live object:\n"; +$obj = new stdClass; +$map[$obj] = 3; +unset($map); +var_dump($obj); + +echo "\nObject freed by GC:\n"; +$map = new WeakMap; +$obj = new stdClass; +$obj->obj = $obj; +$map[$obj] = 4; +unset($obj); +var_dump($map); +gc_collect_cycles(); +var_dump($map); + +echo "\nStoring map in itself:\n"; +$map = new WeakMap; +$map[$map] = $map; +var_dump($map); +unset($map); + +?> +--EXPECT-- +object(WeakMap)#1 (0) { +} +object(WeakMap)#1 (1) { + [0]=> + array(2) { + ["key"]=> + object(stdClass)#2 (0) { + } + ["value"]=> + int(2) + } +} +object(WeakMap)#1 (0) { +} + +Destructor in WeakMap value: +Before unset: +Dtor! +After unset: +object(WeakMap)#1 (0) { +} + +Destroying map with live object: +object(stdClass)#2 (0) { +} + +Object freed by GC: +object(WeakMap)#1 (1) { + [0]=> + array(2) { + ["key"]=> + object(stdClass)#3 (1) { + ["obj"]=> + *RECURSION* + } + ["value"]=> + int(4) + } +} +object(WeakMap)#1 (0) { +} + +Storing map in itself: +object(WeakMap)#3 (1) { + [0]=> + array(2) { + ["key"]=> + *RECURSION* + ["value"]=> + *RECURSION* + } +} diff --git a/Zend/zend_weakrefs.c b/Zend/zend_weakrefs.c index d7531af285..c3f7bf5bb2 100644 --- a/Zend/zend_weakrefs.c +++ b/Zend/zend_weakrefs.c @@ -25,29 +25,145 @@ typedef struct _zend_weakref { zend_object std; } zend_weakref; +typedef struct _zend_weakmap { + HashTable ht; + zend_object std; +} zend_weakmap; + +typedef struct _zend_weakmap_iterator { + zend_object_iterator it; + uint32_t ht_iter; +} zend_weakmap_iterator; + +/* The EG(weakrefs) ht is a map from object address a tagged pointer, that may be one of + * zend_weakref*, zend_weakmap* or HashTable*. */ +#define ZEND_WEAKREF_TAG_REF 0 +#define ZEND_WEAKREF_TAG_MAP 1 +#define ZEND_WEAKREF_TAG_HT 2 +#define ZEND_WEAKREF_GET_TAG(p) (((uintptr_t) (p)) & 3) +#define ZEND_WEAKREF_GET_PTR(p) ((void *) (((uintptr_t) (p)) & ~3)) +#define ZEND_WEAKREF_ENCODE(p, t) ((void *) (((uintptr_t) (p)) | (t))) + zend_class_entry *zend_ce_weakref; +zend_class_entry *zend_ce_weakmap; static zend_object_handlers zend_weakref_handlers; +static zend_object_handlers zend_weakmap_handlers; #define zend_weakref_from(o) ((zend_weakref*)(((char*) o) - XtOffsetOf(zend_weakref, std))) #define zend_weakref_fetch(z) zend_weakref_from(Z_OBJ_P(z)) -static void zend_weakref_unref(zval *zv) { - zend_weakref *wr = (zend_weakref*) Z_PTR_P(zv); +#define zend_weakmap_from(o) ((zend_weakmap*)(((char*) o) - XtOffsetOf(zend_weakmap, std))) +#define zend_weakmap_fetch(z) zend_weakmap_from(Z_OBJ_P(z)) - GC_DEL_FLAGS(wr->referent, IS_OBJ_WEAKLY_REFERENCED); +static inline void zend_weakref_unref_single( + void *ptr, uintptr_t tag, zend_ulong obj_addr) +{ + if (tag == ZEND_WEAKREF_TAG_REF) { + zend_weakref *wr = ptr; + wr->referent = NULL; + } else { + ZEND_ASSERT(tag == ZEND_WEAKREF_TAG_MAP); + zend_weakmap *wm = ptr; + zend_hash_index_del(&wm->ht, obj_addr); + } +} - wr->referent = NULL; +static void zend_weakref_unref(zend_ulong obj_addr, void *tagged_ptr) { + void *ptr = ZEND_WEAKREF_GET_PTR(tagged_ptr); + uintptr_t tag = ZEND_WEAKREF_GET_TAG(tagged_ptr); + if (tag == ZEND_WEAKREF_TAG_HT) { + HashTable *ht = ptr; + ZEND_HASH_FOREACH_PTR(ht, tagged_ptr) { + zend_weakref_unref_single( + ZEND_WEAKREF_GET_PTR(tagged_ptr), ZEND_WEAKREF_GET_TAG(tagged_ptr), obj_addr); + } ZEND_HASH_FOREACH_END(); + zend_hash_destroy(ht); + FREE_HASHTABLE(ht); + } else { + zend_weakref_unref_single(ptr, tag, obj_addr); + } +} + +static void zend_weakref_register(zend_object *object, void *payload) { + GC_ADD_FLAGS(object, IS_OBJ_WEAKLY_REFERENCED); + + zend_ulong obj_addr = (zend_ulong) object; + zval *zv = zend_hash_index_find(&EG(weakrefs), obj_addr); + if (!zv) { + zend_hash_index_add_new_ptr(&EG(weakrefs), obj_addr, payload); + return; + } + + void *tagged_ptr = Z_PTR_P(zv); + if (ZEND_WEAKREF_GET_TAG(tagged_ptr) == ZEND_WEAKREF_TAG_HT) { + HashTable *ht = ZEND_WEAKREF_GET_PTR(tagged_ptr); + zend_hash_index_add_new_ptr(ht, (zend_ulong) payload, payload); + return; + } + + /* Convert simple pointer to hashtable. */ + HashTable *ht = emalloc(sizeof(HashTable)); + zend_hash_init(ht, 0, NULL, NULL, 0); + zend_hash_index_add_new_ptr(ht, (zend_ulong) tagged_ptr, tagged_ptr); + zend_hash_index_add_new_ptr(ht, (zend_ulong) payload, payload); + zend_hash_index_update_ptr( + &EG(weakrefs), obj_addr, ZEND_WEAKREF_ENCODE(ht, ZEND_WEAKREF_TAG_HT)); +} + +static void zend_weakref_unregister(zend_object *object, void *payload) { + zend_ulong obj_addr = (zend_ulong) object; + void *tagged_ptr = zend_hash_index_find_ptr(&EG(weakrefs), obj_addr); + ZEND_ASSERT(tagged_ptr && "Weakref not registered?"); + + void *ptr = ZEND_WEAKREF_GET_PTR(tagged_ptr); + uintptr_t tag = ZEND_WEAKREF_GET_TAG(tagged_ptr); + if (tag != ZEND_WEAKREF_TAG_HT) { + ZEND_ASSERT(tagged_ptr == payload); + zend_weakref_unref_single(ptr, tag, obj_addr); + zend_hash_index_del(&EG(weakrefs), obj_addr); + GC_DEL_FLAGS(object, IS_OBJ_WEAKLY_REFERENCED); + return; + } + + HashTable *ht = ptr; + tagged_ptr = zend_hash_index_find_ptr(ht, (zend_ulong) payload); + ZEND_ASSERT(tagged_ptr && "Weakref not registered?"); + ZEND_ASSERT(tagged_ptr == payload); + zend_weakref_unref_single( + ZEND_WEAKREF_GET_PTR(payload), ZEND_WEAKREF_GET_TAG(payload), obj_addr); + zend_hash_index_del(ht, (zend_ulong) payload); + if (zend_hash_num_elements(ht) == 0) { + GC_DEL_FLAGS(object, IS_OBJ_WEAKLY_REFERENCED); + zend_hash_destroy(ht); + FREE_HASHTABLE(ht); + zend_hash_index_del(&EG(weakrefs), obj_addr); + } } void zend_weakrefs_init() { - zend_hash_init(&EG(weakrefs), 8, NULL, zend_weakref_unref, 0); + zend_hash_init(&EG(weakrefs), 8, NULL, NULL, 0); } void zend_weakrefs_notify(zend_object *object) { - zend_hash_index_del(&EG(weakrefs), (zend_ulong) object); + /* Annoyingly we can't use the HT destructor here, because we need access to the key (which + * is the object address), which is not provided to the dtor. */ + zend_ulong obj_addr = (zend_ulong) object; + void *tagged_ptr = zend_hash_index_find_ptr(&EG(weakrefs), obj_addr); +#if ZEND_DEBUG + ZEND_ASSERT(tagged_ptr && "Tracking of the IS_OBJ_WEAKLY_REFERENCE flag should be precise"); +#endif + if (tagged_ptr) { + zend_weakref_unref(obj_addr, tagged_ptr); + zend_hash_index_del(&EG(weakrefs), obj_addr); + } } void zend_weakrefs_shutdown() { + zend_ulong obj_addr; + void *tagged_ptr; + ZEND_HASH_FOREACH_NUM_KEY_PTR(&EG(weakrefs), obj_addr, tagged_ptr) { + zend_weakref_unref(obj_addr, tagged_ptr); + } ZEND_HASH_FOREACH_END(); zend_hash_destroy(&EG(weakrefs)); } @@ -62,16 +178,32 @@ static zend_object* zend_weakref_new(zend_class_entry *ce) { } static zend_always_inline zend_bool zend_weakref_find(zval *referent, zval *return_value) { - zend_weakref *wr = zend_hash_index_find_ptr(&EG(weakrefs), (zend_ulong) Z_OBJ_P(referent)); - - if (!wr) { + void *tagged_ptr = zend_hash_index_find_ptr(&EG(weakrefs), (zend_ulong) Z_OBJ_P(referent)); + if (!tagged_ptr) { return 0; } - GC_ADDREF(&wr->std); - ZVAL_OBJ(return_value, &wr->std); + void *ptr = ZEND_WEAKREF_GET_PTR(tagged_ptr); + uintptr_t tag = ZEND_WEAKREF_GET_TAG(tagged_ptr); + if (tag == ZEND_WEAKREF_TAG_REF) { + zend_weakref *wr; +found_weakref: + wr = ptr; + GC_ADDREF(&wr->std); + ZVAL_OBJ(return_value, &wr->std); + return 1; + } - return 1; + if (tag == ZEND_WEAKREF_TAG_HT) { + ZEND_HASH_FOREACH(ptr, tagged_ptr) { + if (ZEND_WEAKREF_GET_TAG(tagged_ptr) == ZEND_WEAKREF_TAG_REF) { + ptr = ZEND_WEAKREF_GET_PTR(tagged_ptr); + goto found_weakref; + } + } ZEND_HASH_FOREACH_END(); + } + + return 0; } static zend_always_inline void zend_weakref_create(zval *referent, zval *return_value) { @@ -80,12 +212,9 @@ static zend_always_inline void zend_weakref_create(zval *referent, zval *return_ object_init_ex(return_value, zend_ce_weakref); wr = zend_weakref_fetch(return_value); - wr->referent = Z_OBJ_P(referent); - zend_hash_index_add_ptr(&EG(weakrefs), (zend_ulong) wr->referent, wr); - - GC_ADD_FLAGS(wr->referent, IS_OBJ_WEAKLY_REFERENCED); + zend_weakref_register(wr->referent, ZEND_WEAKREF_ENCODE(wr, ZEND_WEAKREF_TAG_REF)); } static zend_always_inline void zend_weakref_get(zval *weakref, zval *return_value) { @@ -101,44 +230,43 @@ static void zend_weakref_free(zend_object *zo) { zend_weakref *wr = zend_weakref_from(zo); if (wr->referent) { - zend_hash_index_del( - &EG(weakrefs), (zend_ulong) wr->referent); + zend_weakref_unregister(wr->referent, ZEND_WEAKREF_ENCODE(wr, ZEND_WEAKREF_TAG_REF)); } zend_object_std_dtor(&wr->std); } -#define zend_weakref_unsupported(thing) \ - zend_throw_error(NULL, "WeakReference objects do not support " thing); +#define zend_weakref_unsupported(object, thing) \ + zend_throw_error(NULL, "%s objects do not support " thing, ZSTR_VAL(object->ce->name)); static ZEND_COLD zval* zend_weakref_no_write(zend_object *object, zend_string *member, zval *value, void **rtc) { - zend_weakref_unsupported("properties"); + zend_weakref_unsupported(object, "properties"); return &EG(uninitialized_zval); } static ZEND_COLD zval* zend_weakref_no_read(zend_object *object, zend_string *member, int type, void **rtc, zval *rv) { if (!EG(exception)) { - zend_weakref_unsupported("properties"); + zend_weakref_unsupported(object, "properties"); } return &EG(uninitialized_zval); } static ZEND_COLD zval *zend_weakref_no_read_ptr(zend_object *object, zend_string *member, int type, void **rtc) { - zend_weakref_unsupported("property references"); + zend_weakref_unsupported(object, "property references"); return NULL; } static ZEND_COLD int zend_weakref_no_isset(zend_object *object, zend_string *member, int hse, void **rtc) { if (hse != 2) { - zend_weakref_unsupported("properties"); + zend_weakref_unsupported(object, "properties"); } return 0; } static ZEND_COLD void zend_weakref_no_unset(zend_object *object, zend_string *member, void **rtc) { - zend_weakref_unsupported("properties"); + zend_weakref_unsupported(object, "properties"); } ZEND_COLD ZEND_METHOD(WeakReference, __construct) @@ -177,6 +305,330 @@ static const zend_function_entry zend_weakref_methods[] = { ZEND_FE_END }; +static zend_object *zend_weakmap_create_object(zend_class_entry *ce) +{ + zend_weakmap *wm = zend_object_alloc(sizeof(zend_weakmap), ce); + zend_object_std_init(&wm->std, ce); + wm->std.handlers = &zend_weakmap_handlers; + + zend_hash_init(&wm->ht, 0, NULL, ZVAL_PTR_DTOR, 0); + return &wm->std; +} + +static void zend_weakmap_free_obj(zend_object *object) +{ + zend_weakmap *wm = zend_weakmap_from(object); + zend_ulong obj_addr; + ZEND_HASH_FOREACH_NUM_KEY(&wm->ht, obj_addr) { + zend_weakref_unregister( + (zend_object *) obj_addr, ZEND_WEAKREF_ENCODE(wm, ZEND_WEAKREF_TAG_MAP)); + } ZEND_HASH_FOREACH_END(); + zend_hash_destroy(&wm->ht); + zend_object_std_dtor(&wm->std); +} + +static zval *zend_weakmap_read_dimension(zend_object *object, zval *offset, int type, zval *rv) +{ + if (offset == NULL) { + zend_throw_error(NULL, "Cannot append to WeakMap"); + return NULL; + } + + if (Z_TYPE_P(offset) != IS_OBJECT) { + zend_type_error("WeakMap key must be an object"); + return NULL; + } + + zend_weakmap *wm = zend_weakmap_from(object); + zend_object *obj_key = Z_OBJ_P(offset); + zval *zv = zend_hash_index_find(&wm->ht, (zend_ulong) obj_key); + if (zv == NULL) { + if (type != BP_VAR_IS) { + zend_throw_error(NULL, + "Object %s#%d not contained in WeakMap", ZSTR_VAL(obj_key->ce->name), obj_key->handle); + return NULL; + } + return NULL; + } + + if (type == BP_VAR_W || type == BP_VAR_RW) { + ZVAL_MAKE_REF(zv); + } + return zv; +} + +static void zend_weakmap_write_dimension(zend_object *object, zval *offset, zval *value) +{ + if (offset == NULL) { + zend_throw_error(NULL, "Cannot append to WeakMap"); + return; + } + + if (Z_TYPE_P(offset) != IS_OBJECT) { + zend_type_error("WeakMap key must be an object"); + return; + } + + zend_weakmap *wm = zend_weakmap_from(object); + zend_object *obj_key = Z_OBJ_P(offset); + Z_TRY_ADDREF_P(value); + + zval *zv = zend_hash_index_find(&wm->ht, (zend_ulong) obj_key); + if (zv) { + zval_ptr_dtor(zv); + ZVAL_COPY_VALUE(zv, value); + return; + } + + zend_weakref_register(obj_key, ZEND_WEAKREF_ENCODE(wm, ZEND_WEAKREF_TAG_MAP)); + zend_hash_index_add_new(&wm->ht, (zend_ulong) obj_key, value); +} + +static int zend_weakmap_has_dimension(zend_object *object, zval *offset, int check_empty) +{ + if (Z_TYPE_P(offset) != IS_OBJECT) { + zend_type_error("WeakMap key must be an object"); + return 0; + } + + zend_weakmap *wm = zend_weakmap_from(object); + zval *zv = zend_hash_index_find(&wm->ht, (zend_ulong) Z_OBJ_P(offset)); + if (!zv) { + return 0; + } + + if (check_empty) { + return i_zend_is_true(zv); + } + return Z_TYPE_P(zv) != IS_NULL; +} + +static void zend_weakmap_unset_dimension(zend_object *object, zval *offset) +{ + if (Z_TYPE_P(offset) != IS_OBJECT) { + zend_type_error("WeakMap key must be an object"); + return; + } + + zend_weakmap *wm = zend_weakmap_from(object); + zend_object *obj_key = Z_OBJ_P(offset); + zend_weakref_unregister(obj_key, ZEND_WEAKREF_ENCODE(wm, ZEND_WEAKREF_TAG_MAP)); +} + +static int zend_weakmap_count_elements(zend_object *object, zend_long *count) +{ + zend_weakmap *wm = zend_weakmap_from(object); + *count = zend_hash_num_elements(&wm->ht); + return SUCCESS; +} + +static HashTable *zend_weakmap_get_properties_for(zend_object *object, zend_prop_purpose purpose) +{ + if (purpose != ZEND_PROP_PURPOSE_DEBUG) { + return NULL; + } + + zend_weakmap *wm = zend_weakmap_from(object); + HashTable *ht; + ALLOC_HASHTABLE(ht); + zend_hash_init(ht, zend_hash_num_elements(&wm->ht), NULL, ZVAL_PTR_DTOR, 0); + + zend_ulong obj_addr; + zval *val; + ZEND_HASH_FOREACH_NUM_KEY_VAL(&wm->ht, obj_addr, val) { + zval pair; + zval obj_zv; + array_init(&pair); + + ZVAL_OBJ(&obj_zv, (zend_object *) obj_addr); + Z_ADDREF(obj_zv); + add_assoc_zval(&pair, "key", &obj_zv); + Z_TRY_ADDREF_P(val); + add_assoc_zval(&pair, "value", val); + + zend_hash_next_index_insert(ht, &pair); + } ZEND_HASH_FOREACH_END(); + + return ht; +} + +static HashTable *zend_weakmap_get_gc(zend_object *object, zval **table, int *n) +{ + zend_weakmap *wm = zend_weakmap_from(object); + *table = NULL; + *n = 0; + return &wm->ht; +} + +static zend_object *zend_weakmap_clone_obj(zend_object *old_object) +{ + zend_object *new_object = zend_weakmap_create_object(zend_ce_weakmap); + zend_weakmap *old_wm = zend_weakmap_from(old_object); + zend_weakmap *new_wm = zend_weakmap_from(new_object); + zend_hash_copy(&new_wm->ht, &old_wm->ht, NULL); + + zend_ulong obj_addr; + zval *val; + ZEND_HASH_FOREACH_NUM_KEY_VAL(&new_wm->ht, obj_addr, val) { + zend_weakref_register( + (zend_object *) obj_addr, ZEND_WEAKREF_ENCODE(new_wm, ZEND_WEAKREF_TAG_MAP)); + zval_add_ref(val); + } ZEND_HASH_FOREACH_END(); + return new_object; +} + +static HashPosition *zend_weakmap_iterator_get_pos_ptr(zend_weakmap_iterator *iter) { + ZEND_ASSERT(iter->ht_iter != (uint32_t) -1); + return &EG(ht_iterators)[iter->ht_iter].pos; +} + +static void zend_weakmap_iterator_dtor(zend_object_iterator *obj_iter) +{ + zend_weakmap_iterator *iter = (zend_weakmap_iterator *) obj_iter; + zend_hash_iterator_del(iter->ht_iter); + zval_ptr_dtor(&iter->it.data); +} + +static int zend_weakmap_iterator_valid(zend_object_iterator *obj_iter) +{ + zend_weakmap_iterator *iter = (zend_weakmap_iterator *) obj_iter; + zend_weakmap *wm = zend_weakmap_fetch(&iter->it.data); + HashPosition *pos = zend_weakmap_iterator_get_pos_ptr(iter); + return zend_hash_has_more_elements_ex(&wm->ht, pos); +} + +static zval *zend_weakmap_iterator_get_current_data(zend_object_iterator *obj_iter) +{ + zend_weakmap_iterator *iter = (zend_weakmap_iterator *) obj_iter; + zend_weakmap *wm = zend_weakmap_fetch(&iter->it.data); + HashPosition *pos = zend_weakmap_iterator_get_pos_ptr(iter); + return zend_hash_get_current_data_ex(&wm->ht, pos); +} + +static void zend_weakmap_iterator_get_current_key(zend_object_iterator *obj_iter, zval *key) +{ + zend_weakmap_iterator *iter = (zend_weakmap_iterator *) obj_iter; + zend_weakmap *wm = zend_weakmap_fetch(&iter->it.data); + HashPosition *pos = zend_weakmap_iterator_get_pos_ptr(iter); + + zend_string *string_key; + zend_ulong num_key; + int key_type = zend_hash_get_current_key_ex(&wm->ht, &string_key, &num_key, pos); + if (key_type != HASH_KEY_IS_LONG) { + ZEND_ASSERT(0 && "Must have integer key"); + } + + ZVAL_OBJ(key, (zend_object *) num_key); + Z_ADDREF_P(key); +} + +static void zend_weakmap_iterator_move_forward(zend_object_iterator *obj_iter) +{ + zend_weakmap_iterator *iter = (zend_weakmap_iterator *) obj_iter; + zend_weakmap *wm = zend_weakmap_fetch(&iter->it.data); + HashPosition *pos = zend_weakmap_iterator_get_pos_ptr(iter); + zend_hash_move_forward_ex(&wm->ht, pos); +} + +static void zend_weakmap_iterator_rewind(zend_object_iterator *obj_iter) +{ + zend_weakmap_iterator *iter = (zend_weakmap_iterator *) obj_iter; + zend_weakmap *wm = zend_weakmap_fetch(&iter->it.data); + HashPosition *pos = zend_weakmap_iterator_get_pos_ptr(iter); + zend_hash_internal_pointer_reset_ex(&wm->ht, pos); +} + +static const zend_object_iterator_funcs zend_weakmap_iterator_funcs = { + zend_weakmap_iterator_dtor, + zend_weakmap_iterator_valid, + zend_weakmap_iterator_get_current_data, + zend_weakmap_iterator_get_current_key, + zend_weakmap_iterator_move_forward, + zend_weakmap_iterator_rewind, + NULL +}; + +static zend_object_iterator *zend_weakmap_get_iterator( + zend_class_entry *ce, zval *object, int by_ref) +{ + zend_weakmap *wm = zend_weakmap_fetch(object); + zend_weakmap_iterator *iter = emalloc(sizeof(zend_weakmap_iterator)); + zend_iterator_init(&iter->it); + iter->it.funcs = &zend_weakmap_iterator_funcs; + ZVAL_COPY(&iter->it.data, object); + iter->ht_iter = zend_hash_iterator_add(&wm->ht, 0); + return &iter->it; +} + +ZEND_METHOD(WeakMap, offsetGet) +{ + zval *key; + + if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &key) == FAILURE) { + return; + } + + zval *zv = zend_weakmap_read_dimension(Z_OBJ_P(ZEND_THIS), key, BP_VAR_R, NULL); + if (!zv) { + return; + } + + ZVAL_COPY(return_value, zv); +} + +ZEND_METHOD(WeakMap, offsetSet) +{ + zval *key, *value; + + if (zend_parse_parameters(ZEND_NUM_ARGS(), "zz", &key, &value) == FAILURE) { + return; + } + + zend_weakmap_write_dimension(Z_OBJ_P(ZEND_THIS), key, value); +} + +ZEND_METHOD(WeakMap, offsetExists) +{ + zval *key; + + if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &key) == FAILURE) { + return; + } + + RETURN_BOOL(zend_weakmap_has_dimension(Z_OBJ_P(ZEND_THIS), key, /* check_empty */ 0)); +} + +ZEND_METHOD(WeakMap, offsetUnset) +{ + zval *key; + + if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &key) == FAILURE) { + return; + } + + zend_weakmap_unset_dimension(Z_OBJ_P(ZEND_THIS), key); +} + +ZEND_METHOD(WeakMap, count) +{ + if (zend_parse_parameters_none() == FAILURE) { + return; + } + + zend_long count; + zend_weakmap_count_elements(Z_OBJ_P(ZEND_THIS), &count); + RETURN_LONG(count); +} + +static const zend_function_entry zend_weakmap_methods[] = { + ZEND_ME(WeakMap, offsetGet, arginfo_class_WeakMap_offsetGet, ZEND_ACC_PUBLIC) + ZEND_ME(WeakMap, offsetSet, arginfo_class_WeakMap_offsetSet, ZEND_ACC_PUBLIC) + ZEND_ME(WeakMap, offsetExists, arginfo_class_WeakMap_offsetExists, ZEND_ACC_PUBLIC) + ZEND_ME(WeakMap, offsetUnset, arginfo_class_WeakMap_offsetUnset, ZEND_ACC_PUBLIC) + ZEND_ME(WeakMap, count, arginfo_class_WeakMap_count, ZEND_ACC_PUBLIC) + ZEND_FE_END +}; + void zend_register_weakref_ce(void) /* {{{ */ { zend_class_entry ce; @@ -199,6 +651,36 @@ void zend_register_weakref_ce(void) /* {{{ */ zend_weakref_handlers.unset_property = zend_weakref_no_unset; zend_weakref_handlers.get_property_ptr_ptr = zend_weakref_no_read_ptr; zend_weakref_handlers.clone_obj = NULL; + + INIT_CLASS_ENTRY(ce, "WeakMap", zend_weakmap_methods); + zend_ce_weakmap = zend_register_internal_class(&ce); + zend_ce_weakmap->ce_flags |= ZEND_ACC_FINAL; + + zend_ce_weakmap->create_object = zend_weakmap_create_object; + zend_ce_weakmap->get_iterator = zend_weakmap_get_iterator; + zend_ce_weakmap->serialize = zend_class_serialize_deny; + zend_ce_weakmap->unserialize = zend_class_unserialize_deny; + + /* Must happen after get_iterator is assigned. */ + zend_class_implements( + zend_ce_weakmap, 3, zend_ce_arrayaccess, zend_ce_countable, zend_ce_traversable); + + memcpy(&zend_weakmap_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers)); + zend_weakmap_handlers.offset = XtOffsetOf(zend_weakmap, std); + zend_weakmap_handlers.free_obj = zend_weakmap_free_obj; + zend_weakmap_handlers.read_dimension = zend_weakmap_read_dimension; + zend_weakmap_handlers.write_dimension = zend_weakmap_write_dimension; + zend_weakmap_handlers.has_dimension = zend_weakmap_has_dimension; + zend_weakmap_handlers.unset_dimension = zend_weakmap_unset_dimension; + zend_weakmap_handlers.count_elements = zend_weakmap_count_elements; + zend_weakmap_handlers.get_properties_for = zend_weakmap_get_properties_for; + zend_weakmap_handlers.get_gc = zend_weakmap_get_gc; + zend_weakmap_handlers.clone_obj = zend_weakmap_clone_obj; + zend_weakmap_handlers.read_property = zend_weakref_no_read; + zend_weakmap_handlers.write_property = zend_weakref_no_write; + zend_weakmap_handlers.has_property = zend_weakref_no_isset; + zend_weakmap_handlers.unset_property = zend_weakref_no_unset; + zend_weakmap_handlers.get_property_ptr_ptr = zend_weakref_no_read_ptr; } /* }}} */ diff --git a/Zend/zend_weakrefs.stub.php b/Zend/zend_weakrefs.stub.php index 52ae81c7b8..aada11bc79 100644 --- a/Zend/zend_weakrefs.stub.php +++ b/Zend/zend_weakrefs.stub.php @@ -7,3 +7,27 @@ final class WeakReference { public function get(): ?object; } + +final class WeakMap implements ArrayAccess, Countable, Traversable { + //public function __construct(); + + /** + * @param object $object + * @return mixed + */ + public function offsetGet($object); + + /** + * @param object $object + * @param mixed $value + */ + public function offsetSet($object, $value): void; + + /** @param object $object */ + public function offsetExists($object): bool; + + /** @param object $object */ + public function offsetUnset($object): void; + + public function count(): int; +} diff --git a/Zend/zend_weakrefs_arginfo.h b/Zend/zend_weakrefs_arginfo.h index abcd0c8d99..b10c1b63b5 100644 --- a/Zend/zend_weakrefs_arginfo.h +++ b/Zend/zend_weakrefs_arginfo.h @@ -8,3 +8,23 @@ ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_WeakReference_get, 0, 0, IS_OBJECT, 1) ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_class_WeakMap_offsetGet, 0, 0, 1) + ZEND_ARG_INFO(0, object) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_WeakMap_offsetSet, 0, 2, IS_VOID, 0) + ZEND_ARG_INFO(0, object) + ZEND_ARG_INFO(0, value) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_WeakMap_offsetExists, 0, 1, _IS_BOOL, 0) + ZEND_ARG_INFO(0, object) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_WeakMap_offsetUnset, 0, 1, IS_VOID, 0) + ZEND_ARG_INFO(0, object) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_WeakMap_count, 0, 0, IS_LONG, 0) +ZEND_END_ARG_INFO() |