Registering constants to internal classes (ZE2)

Hi, Perhaps I'm missing something, but I noticed the current ZE2 implementation doesn't seem to correctly handle constants registered to internal classes. I tracked down the cause of this problem, and finally figured out that those constants are destroyed by the ordinary zval_ptr_dtor_wrapper() at the destruction of the constant hash after the deactivation of the memory manager. Then I'm putting forward the following ideas to avoid this. 1. Unify the calls of pefree() / efree() by a function pointer followed by the actual memory block which directs to the actual free() implementation the memory block should be freed by. Here's the example stuff I'm referring to: typedef struct _memblk_t { void (*free_fn)(void *ptr); byte blk[]; } memblk_t; void efree_impl(void *ptr) { ... } void pefree_impl(void *ptr) { free(ptr); } void *pemalloc_impl(size_t sz) { return malloc(sz); } void *pemalloc(size_t sz, int persistent) { void *ptr; if (persistent) { ptr = emalloc_impl(sz + sizeof(memblk_t)); ptr->free_fn = efree_impl; } else { ptr = pemalloc_impl(sz + sizeof(memblk_t)); ptr->free_fn = pefree_impl; } return (void *)ptr->blk; } void efree(void *ptr) { memblk_t *actual_head; actual_head = (memblk_t *)((byte *)ptr - &((memblk_t *)0)->blk); actual_head->free_fn((void *)actual_head); } 2. Add some new constructors / destructors dedicated to the persistent zvals, like ALLOC_INIT_PERSISTENT_ZVAL(), persistent_zval_dtor(), or persistent_zval_ptr_dtor(). I don't like this idea though. Any opinions? Moriyoshi