static void init_generated_pool_once(TSRMLS_D) {
if (generated_pool_php == NULL) {
MAKE_STD_ZVAL(generated_pool_php);
Z_TYPE_P(generated_pool_php) = IS_OBJECT;
generated_pool = ALLOC(DescriptorPool);
descriptor_pool_init_c_instance(generated_pool TSRMLS_CC);
Z_OBJ_HANDLE_P(generated_pool_php) = zend_objects_store_put(
generated_pool, NULL,
(zend_objects_free_object_storage_t)descriptor_pool_free,
NULL TSRMLS_CC);
Z_OBJ_HT_P(generated_pool_php) = zend_get_std_object_handlers();
}
}
static zend_object_value money_create_object(zend_class_entry *ce)
{
zend_object_value retval;
zend_object *obj;
obj = emalloc(sizeof(zend_object));
zend_object_std_init(obj, ce);
object_properties_init(obj, ce);
retval.handle = zend_objects_store_put(obj, (zend_objects_store_dtor_t) zend_objects_destroy_object, (zend_objects_free_object_storage_t)zend_objects_free_object_storage, NULL);
retval.handlers = &money_object_handlers;
return retval;
}
static zend_object_value php_runkit_sandbox_parent_ctor(zend_class_entry *ce)
{
php_runkit_sandbox_parent_object *objval;
zend_object_value retval;
if (RUNKIT_G(current_sandbox)) {
objval = ecalloc(1, sizeof(php_runkit_sandbox_parent_object));
objval->obj.ce = ce;
objval->self = RUNKIT_G(current_sandbox);
} else {
/* Assign a "blind" stdClass when invoked from the top-scope */
objval = ecalloc(1, sizeof(zend_object));
objval->obj.ce = zend_standard_class_def;
}
ALLOC_HASHTABLE(objval->obj.properties);
zend_hash_init(objval->obj.properties, 0, NULL, ZVAL_PTR_DTOR, 0);
retval.handle = zend_objects_store_put(objval, NULL, (zend_objects_free_object_storage_t)php_runkit_sandbox_parent_dtor, NULL);
retval.handlers = RUNKIT_G(current_sandbox) ? &php_runkit_sandbox_parent_handlers : zend_get_std_object_handlers();
return retval;
}
void server_websocket_route_handle_request(zval *zroute, zval *zrequest, zval *params TSRMLS_DC);
static void server_dtor(void *object TSRMLS_DC);
static zend_object_value server_ctor(zend_class_entry *ce TSRMLS_DC)
{
struct php_can_server *server;
zend_object_value retval;
server = ecalloc(1, sizeof(*server));
server->logformat = NULL;
server->logfile = NULL;
server->router = NULL;
zend_object_std_init(&server->std, ce TSRMLS_CC);
PHP_CAN_INIT_OBJ_PROPS(server, ce);
retval.handle = zend_objects_store_put(server,
(zend_objects_store_dtor_t)zend_objects_destroy_object,
server_dtor,
NULL TSRMLS_CC);
retval.handlers = &server_obj_handlers;
return retval;
}
static void server_dtor(void *object TSRMLS_DC)
{
struct php_can_server *server = (struct php_can_server*)object;
if (server->http) {
free(server->http);
server->http = NULL;
}
zend_objects_store_del_ref(&server->refhandle TSRMLS_CC);
#else
// not in thread mode: no special parameter for the tsrm_ls variable
using DestructType = void(zend_object*,unsigned int);
using FreeType = void(zend_object*);
#endif
// store the two destruct methods in temporary vars
DestructType *destructMethod = &ClassBase::destructObject;
FreeType *freeMethod = &ClassBase::freeObject;
// the destructor and clone handlers are set to NULL. I dont know why, but they do not
// seem to be necessary...
_handle = zend_objects_store_put(result, (zend_objects_store_dtor_t)destructMethod, (zend_objects_free_object_storage_t)freeMethod, NULL TSRMLS_CC);
// done
return result;
}
/**
* Overridable method that is called right before an object is destructed
*/
void Base::__destruct() const
{
// throw exception, so that the PHP-CPP library will check if the user
// somehow registered an explicit __destruct method
throw NotImplemented();
}
zend_object_value spl_ds_linked_list_create_handler(zend_class_entry *class_type TSRMLS_DC)
{
zend_object_value retval;
spl_ds_dll_object *obj;
obj = emalloc(sizeof(spl_ds_dll_object));
zend_object_std_init(&obj->std, class_type TSRMLS_CC);
object_properties_init(&obj->std, class_type);
obj->list = spl_ds_dll_create();
retval.handle = zend_objects_store_put(obj, NULL,
(zend_objects_free_object_storage_t) spl_ds_dll_object_free_storage,
(zend_objects_store_clone_t) spl_ds_dll_object_clone_storage
TSRMLS_CC
);
retval.handlers = &spl_ds_handlers_LinkedList;
return retval;
}
SPL_DS_METHOD(LinkedList, getFirst)
{
spl_ds_dll *list;
zval *item;
if (zend_parse_parameters_none() == FAILURE) {
return;
}
/* {{{ finfo_objects_new
*/
PHP_FILEINFO_API zend_object_value finfo_objects_new(zend_class_entry *class_type TSRMLS_DC)
{
zend_object_value retval;
struct finfo_object *intern;
intern = emalloc(sizeof(struct finfo_object));
memset(intern, 0, sizeof(struct finfo_object));
zend_object_std_init(&intern->zo, class_type TSRMLS_CC);
object_properties_init(&intern->zo, class_type);
intern->ptr = NULL;
retval.handle = zend_objects_store_put(intern, finfo_objects_dtor, NULL, NULL TSRMLS_CC);
retval.handlers = (zend_object_handlers *) &finfo_object_handlers;
return retval;
}
/* }}} */
/* {{{ arginfo */
ZEND_BEGIN_ARG_INFO_EX(arginfo_finfo_open, 0, 0, 0)
ZEND_ARG_INFO(0, options)
ZEND_ARG_INFO(0, arg)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_INFO_EX(arginfo_finfo_close, 0, 0, 1)
ZEND_ARG_INFO(0, finfo)
ZEND_END_ARG_INFO()
zend_object_value v8_create_object(zend_class_entry* class_type TSRMLS_DC)
{
zend_object_value retval;
v8context_object* obj = (v8context_object*)emalloc(sizeof(v8context_object));
memset(obj, 0, sizeof(v8context_object));
zend_object_std_init(&obj->std, class_type TSRMLS_CC);
zend_hash_copy(obj->std.properties, &class_type->default_properties
,reinterpret_cast<copy_ctor_func_t>(zval_add_ref), static_cast<void*>(0), sizeof(zval*));
obj->intern = new v8context;
retval.handle = zend_objects_store_put(obj, reinterpret_cast<zend_objects_store_dtor_t>(zend_objects_destroy_object)
, reinterpret_cast<zend_objects_free_object_storage_t>(v8_object_dtor)
, NULL TSRMLS_CC);
retval.handlers = &v8context_object_handlers;
return retval;
}
PHP_METHOD(V8Context, __construct)
{
}
zend_object_value webkitgtk_webresource_new(zend_class_entry *class_type TSRMLS_DC)
{
WebKitWebResource_object *intern;
zend_object_value retval;
intern = emalloc(sizeof(WebKitWebResource_object));
memset(intern, 0, sizeof(WebKitWebResource_object));
intern->webResource = NULL;
zend_object_std_init(&intern->std, class_type TSRMLS_CC);
object_properties_init(&intern->std, class_type);
retval.handle = zend_objects_store_put(intern, (zend_objects_store_dtor_t)zend_objects_destroy_object,
(zend_objects_free_object_storage_t) webkitgtk_object_free_storage_webresource, NULL TSRMLS_CC);
retval.handlers = &webkitgtk_object_handlers_webresource;
return retval;
}
void webkitgtk_object_free_storage_webresource(void *object TSRMLS_DC)
{
WebKitWebResource_object *intern = (WebKitWebResource_object *)object;
// FIXME: Trocar para o destroy do webkit
if (intern->webResource && GTK_IS_WIDGET(intern->webResource)) {
gtk_widget_destroy(intern->webResource);
}
zend_object_std_dtor(&intern->std TSRMLS_CC);
//add properties table
#if PHP_VERSION_ID < 50399
zend_hash_copy(
intern->std.properties, &class_type->default_properties,
(copy_ctor_func_t)zval_add_ref,
(void *)&tmp,
sizeof tmp
);
#else
object_properties_init(&intern->std, class_type);
#endif
// create a destructor for this struct
retval.handle = zend_objects_store_put(
intern,
(zend_objects_store_dtor_t) zend_objects_destroy_object,
free_kafka_connection,
NULL TSRMLS_CC
);
retval.handlers = zend_get_std_object_handlers();
return retval;
}
//clean current connections
void free_kafka_connection(void *object TSRMLS_DC)
{
int interval = 1;
kafka_connection *connection = ((kafka_connection *) object);
//no confirmation, wait to close connection a bit longer, for what it's worth
if (connection->delivery_confirm_mode == PHP_KAFKA_CONFIRM_OFF)
interval = 50;
}
static zend_object_value collator_object_create(zend_class_entry *ce TSRMLS_DC)
{
php_collator_obj *intern;
zend_object_value retval;
zval *tmp;
intern = emalloc(sizeof(php_collator_obj));
memset(intern, 0, sizeof(php_collator_obj));
zend_object_std_init(&intern->std, ce TSRMLS_CC);
zend_hash_copy(intern->std.properties, &ce->default_properties, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
retval.handle = zend_objects_store_put(intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, (zend_objects_free_object_storage_t) collator_object_free_storage, NULL TSRMLS_CC);
retval.handlers = &unicode_object_handlers_collator;
return retval;
}
static void collator_object_free_storage(void *object TSRMLS_DC)
{
php_collator_obj *intern = (php_collator_obj *)object;
if (intern->zcoll) {
zend_collator_destroy(intern->zcoll);
}
zend_object_std_dtor(&intern->std TSRMLS_CC);
efree(object);
}
// Constructor
zend_object_value TestExtObj_object_new(zend_class_entry *ce TSRMLS_DC)
{
zend_object_value retval;
TestExtObj_object *intern;
intern = ecalloc(1, sizeof(TestExtObj_object));
zend_object_std_init(&(intern->std), ce TSRMLS_CC);
zend_hash_copy(intern->std.properties, &ce->default_properties, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
intern->is_loser = 0;
retval.handle = zend_objects_store_put(intern, TestExtObj_object_dtor, NULL, NULL TSRMLS_CC);
retval.handlers = &TestExtObj_handlers;
return retval;
}
static void *myrealloc(void *ptr, size_t size)
{
/* There might be a realloc() out there that doesn't like reallocing
NULL pointers, so we take care of it here */
if(ptr)
return realloc(ptr, size);
else
return malloc(size);
}
static size_t WriteMemoryCallback(void *ptr, size_t size, size_t nmemb, void *data)
};
static zend_object_value mongo_mongo_cursor_new(zend_class_entry *class_type TSRMLS_DC) {
zend_object_value retval;
mongo_cursor *intern;
zval *tmp;
intern = (mongo_cursor*)emalloc(sizeof(mongo_cursor));
memset(intern, 0, sizeof(mongo_cursor));
zend_object_std_init(&intern->std, class_type TSRMLS_CC);
zend_hash_copy(intern->std.properties, &class_type->default_properties, (copy_ctor_func_t) zval_add_ref,
(void *) &tmp, sizeof(zval *));
retval.handle = zend_objects_store_put(intern, (zend_objects_store_dtor_t) zend_objects_destroy_object, mongo_mongo_cursor_free, NULL TSRMLS_CC);
retval.handlers = &mongo_default_handlers;
return retval;
}
// tell db to destroy its cursor
static void kill_cursor(mongo_cursor *cursor TSRMLS_DC) {
unsigned char quickbuf[128];
buffer buf;
mongo_msg_header header;
// we allocate a cursor even if no results are returned,
// but the database will throw an assertion if we try to
// kill a non-existant cursor
memcpy(&distance_map_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
distance_map_handlers.clone_obj = clone_distance_map_object;
}
zend_object_value create_distance_map_object(zend_class_entry *class_type TSRMLS_DC) {
zend_object_value retval;
distance_map_object *intern = emalloc(sizeof(distance_map_object));
memset(intern, 0, sizeof(distance_map_object));
// create a table for class properties
zend_object_std_init(&intern->std, class_type TSRMLS_CC);
object_properties_init(&intern->std, class_type);
// create a destructor for this struct
retval.handle = zend_objects_store_put(intern, (zend_objects_store_dtor_t) zend_objects_destroy_object, (zend_objects_free_object_storage_t)free_distance_map_object, NULL TSRMLS_CC);
retval.handlers = zend_get_std_object_handlers();
return retval;
}
static zend_object_value clone_distance_map_object(zval *object TSRMLS_DC) {
distance_map_object *old_object = zend_object_store_get_object(object TSRMLS_CC);
zend_object_value new_object_val = create_distance_map_object(Z_OBJCE_P(object) TSRMLS_CC);
distance_map_object *new_object = zend_object_store_get_object_by_handle(new_object_val.handle TSRMLS_CC);
zend_objects_clone_members(
&new_object->std, new_object_val,
&old_object->std, Z_OBJ_HANDLE_P(object) TSRMLS_CC
);
ZEND_GET_MODULE(opendkim)
#endif
/* opendkim handlers */
PHP_OPENDKIM_EXPORT(zend_object_value) opendkim_object_handler_new(zend_class_entry *class_type TSRMLS_DC)
{
zend_object_value retval;
opendkim_object_handler *intern;
intern = emalloc(sizeof(opendkim_object_handler));
memset(intern, 0, sizeof(opendkim_object_handler));
intern->handler = NULL;
zend_object_std_init(&intern->zo, class_type TSRMLS_CC);
retval.handle = zend_objects_store_put(intern, (zend_objects_store_dtor_t) zend_objects_destroy_object, opendkim_object_handler_free_storage, NULL TSRMLS_CC);
retval.handlers = zend_get_std_object_handlers();
return retval;
}
static void opendkim_object_handler_free_storage(void *object TSRMLS_DC)
{
zend_object *zo = (zend_object *)object;
opendkim_object_handler *intern = (opendkim_object_handler *)object;
DKIM *dkim;
dkim = intern->handler;
if (dkim) {
dkim_free(dkim);
}
rtv_ce_rtvtemplate = zend_register_internal_class(&ce TSRMLS_CC);
/* fields */
zend_declare_property_bool(rtv_ce_rtvtemplate,"html", strlen("html"),1,ZEND_ACC_PUBLIC TSRMLS_CC);
}
zend_object_value create_rtv_template_fragments(zend_class_entry *class_type TSRMLS_DC){
zend_object_value retval;
rtv_template_fragments *intern;
zval *tmp;
intern = (rtv_template_fragments*)emalloc(sizeof(rtv_template_fragments));
memset(intern,0,sizeof(rtv_template_fragments));
zend_object_std_init(&intern->std, class_type TSRMLS_CC);
zend_hash_copy(intern->std.properties, &class_type->default_properties,(copy_ctor_func_t) zval_add_ref,(void*) &tmp, sizeof(zval *));
retval.handle = zend_objects_store_put(intern,(zend_objects_store_dtor_t) zend_objects_destroy_object, free_rtv_template_fragments, NULL TSRMLS_CC);
retval.handlers = zend_get_std_object_handlers();
return retval;
}
void free_rtv_template_fragments(void *object TSRMLS_DC){
rtv_template_fragments *fragments =(rtv_template_fragments*) object;
if(fragments->code){
efree(fragments->code);
}
efree(fragments);
}
/**
* Constructor
zend_iterator_class_entry.name = "__iterator_wrapper";
}
static void iter_wrapper_dtor(void *object, zend_object_handle handle TSRMLS_DC)
{
zend_object_iterator *iter = (zend_object_iterator*)object;
iter->funcs->dtor(iter TSRMLS_CC);
}
ZEND_API zval *zend_iterator_wrap(zend_object_iterator *iter TSRMLS_DC)
{
zval *wrapped;
MAKE_STD_ZVAL(wrapped);
Z_TYPE_P(wrapped) = IS_OBJECT;
Z_OBJ_HANDLE_P(wrapped) = zend_objects_store_put(iter, iter_wrapper_dtor, NULL, NULL TSRMLS_CC);
Z_OBJ_HT_P(wrapped) = &iterator_object_handlers;
return wrapped;
}
ZEND_API enum zend_object_iterator_kind zend_iterator_unwrap(
zval *array_ptr, zend_object_iterator **iter TSRMLS_DC)
{
switch (Z_TYPE_P(array_ptr)) {
case IS_OBJECT:
if (Z_OBJ_HT_P(array_ptr) == &iterator_object_handlers) {
*iter = (zend_object_iterator *)zend_object_store_get_object(array_ptr TSRMLS_CC);
return ZEND_ITER_OBJECT;
}
if (Z_OBJPROP_P(array_ptr)) {
void wingdi_region_object_destroy(void * object TSRMLS_DC);
/* {{{ zend_object_value wingdi_region_object_new(zend_class_entry *ce TSRMLS_DC)
Create new object and store it in objects store; boilerplate boredom.
*/
zend_object_value wingdi_region_object_new(zend_class_entry *ce TSRMLS_DC)
{
zend_object_value ret;
wingdi_region_object *reg;
reg = emalloc(sizeof(wingdi_region_object));
reg->std.ce = ce;
reg->handle = zend_objects_store_put(
reg,
(zend_objects_store_dtor_t)zend_objects_destroy_object,
(zend_objects_free_object_storage_t)wingdi_region_object_destroy,
NULL
TSRMLS_CC
);
reg->region_handle = NULL;
reg->constructed = 0;
ret.handle = reg->handle;
ret.handlers = zend_get_std_object_handlers();
object_properties_init(®->std, ce);
return ret;
}
/* }}} */
zval_dtor(&retval);
}
static zend_object_value createUVTimerResource(zend_class_entry *ce TSRMLS_DC) {
zend_object_value retval;
uv_timer_ext_t *resource;
resource = (uv_timer_ext_t *) emalloc(sizeof(uv_timer_ext_t));
memset(resource, 0, sizeof(uv_timer_ext_t));
uv_timer_init(uv_default_loop(), &resource->uv_timer);
zend_object_std_init(&resource->zo, ce TSRMLS_CC);
object_properties_init(&resource->zo, ce);
retval.handle = zend_objects_store_put(
&resource->zo,
(zend_objects_store_dtor_t) zend_objects_destroy_object,
freeUVTimerResource,
NULL TSRMLS_CC);
retval.handlers = &OBJECT_HANDLER(UVTimer);
return retval;
}
void freeUVTimerResource(void *object TSRMLS_DC) {
uv_timer_ext_t *resource;
resource = FETCH_RESOURCE(object, uv_timer_ext_t);
if(resource->start){
uv_timer_stop((uv_timer_t *) resource);
}
uv_unref((uv_handle_t *) resource);
zend_object_value splclassloader_create_object(zend_class_entry* class_type TSRMLS_DC)
{
zend_object_value retval;
splclassloader_object* obj = (splclassloader_object*)emalloc(sizeof(splclassloader_object));
memset(obj, 0, sizeof(splclassloader_object));
zend_object_std_init(&obj->std, class_type TSRMLS_CC);
zend_hash_copy(obj->std.properties, &class_type->default_properties, (copy_ctor_func_t) zval_add_ref, (void*)0, sizeof(zval*));
obj->file_ext = estrndup(".php", sizeof(".php")-1);
obj->file_ext_len = sizeof(".php")-1;
retval.handle = zend_objects_store_put(obj, (zend_objects_store_dtor_t)zend_objects_destroy_object, (void*)splclassloader_object_dtor, NULL TSRMLS_CC);
retval.handlers = &splclassloader_object_handlers;
return retval;
}
/* {{{ proto void SplClassLoader::__construct([string $namespace [, string $include_path]])
Constructor */
PHP_METHOD(SplClassLoader, __construct)
{
char* ns = NULL;
int ns_len = 0;
char* inc_path = NULL;
int inc_path_len = 0;
splclassloader_object* obj;
memset(&object->data, 0, sizeof(kadm5_policy_ent_rec));
object->conn = NULL;
object->update_mask = 0;
zend_object_std_init(&(object->std), ce TSRMLS_CC);
#if PHP_VERSION_ID < 50399
zend_hash_copy(object->std.properties, &ce->default_properties,
(copy_ctor_func_t) zval_add_ref, NULL,
sizeof(zval*));
#else
object_properties_init(&(object->std), ce);
#endif
retval.handle = zend_objects_store_put(object, php_krb5_kadm5_policy_object_dtor, NULL, NULL TSRMLS_CC);
retval.handlers = &krb5_kadm5_policy_handlers;
return retval;
}
PHP_METHOD(KADM5Policy, __construct)
{
char *spolicy = NULL;
int spolicy_len;
krb5_kadm5_policy_object *obj;
zval *connobj = NULL;
zval *dummy_retval, *func;
}
zend_object_value create_php_file(zend_class_entry *class_type TSRMLS_DC) {
zend_object_value retval;
php_file *intern;
zval *tmp;
intern = (php_file*)emalloc(sizeof(php_file));
memset(intern, 0, sizeof(php_file));
zend_object_std_init(&intern->std, class_type TSRMLS_CC);
object_properties_init(&intern->std, class_type);
retval.handle = zend_objects_store_put(
intern,
(zend_objects_store_dtor_t) zend_objects_destroy_object,
free_php_file,
NULL TSRMLS_CC
);
retval.handlers = zend_get_std_object_handlers();
return retval;
}
void free_php_file(void *object TSRMLS_DC) {
php_file *file = (php_file*)object;
if (file->file) {
int rc = file_free(file->file);
assert(rc == 0);
}
efree(file);
}
zval *tmp; #endif /* Create the object. */ obj = (sync_Mutex_object *)ecalloc(1, sizeof(sync_Mutex_object)); /* Initialize Zend. */ zend_object_std_init(&obj->std, ce TSRMLS_CC); #if PHP_VERSION_ID < 50399 zend_hash_copy(obj->std.properties, &ce->default_properties, (copy_ctor_func_t)zval_add_ref, (void *)&tmp, sizeof(zval *)); #else object_properties_init(&obj->std, ce); #endif /* Initialize destructor callback. */ retval.handle = zend_objects_store_put((void *)obj, (zend_objects_store_dtor_t)zend_objects_destroy_object, sync_Mutex_free_object, NULL TSRMLS_CC); retval.handlers = zend_get_std_object_handlers(); /* Initialize Mutex information. */ #if defined(PHP_WIN32) obj->MxWinMutex = NULL; InitializeCriticalSection(&obj->MxWinCritSection); #else obj->MxSemMutex = SEM_FAILED; obj->MxAllocated = 0; pthread_mutex_init(&obj->MxPthreadCritSection, NULL); #endif obj->MxOwnerID = 0; obj->MxCount = 0; return retval;
/* {{{ ResourceBundle_object_create */
static zend_object_value ResourceBundle_object_create( zend_class_entry *ce TSRMLS_DC )
{
zend_object_value retval;
ResourceBundle_object *rb;
rb = ecalloc( 1, sizeof(ResourceBundle_object) );
zend_object_std_init( (zend_object *) rb, ce TSRMLS_CC );
intl_error_init( INTL_DATA_ERROR_P(rb) TSRMLS_CC );
rb->me = NULL;
rb->child = NULL;
retval.handlers = &ResourceBundle_object_handlers;
retval.handle = zend_objects_store_put( rb, ResourceBundle_object_destroy, NULL, NULL TSRMLS_CC );
return retval;
}
/* }}} */
/* {{{ ResourceBundle_ctor */
static void resourcebundle_ctor(INTERNAL_FUNCTION_PARAMETERS)
{
char * bundlename;
int bundlename_len = 0;
char * locale;
int locale_len = 0;
zend_bool fallback = 1;
char * pbuf;
static zend_object_value server_websocket_route_ctor(zend_class_entry *ce TSRMLS_DC)
{
struct php_can_server_route *route;
zend_object_value retval;
route = ecalloc(1, sizeof(*route));
zend_object_std_init(&route->std, ce TSRMLS_CC);
PHP_CAN_INIT_OBJ_PROPS(route, ce);
route->handler = NULL;
route->methods = PHP_CAN_SERVER_ROUTE_METHOD_GET;
route->regexp = NULL;
route->route = NULL;
route->casts = NULL;
retval.handle = zend_objects_store_put(route,
(zend_objects_store_dtor_t)zend_objects_destroy_object,
server_websocket_route_dtor,
NULL TSRMLS_CC);
retval.handlers = &server_websocket_route_obj_handlers;
return retval;
}
static void server_websocket_route_dtor(void *object TSRMLS_DC)
{
struct php_can_server_route *route = (struct php_can_server_route*)object;
if (route->handler) {
zval_ptr_dtor(&route->handler);
}
if (route->regexp) {
efree(route->regexp);
zend_iterator_class_entry.name = "__iterator_wrapper";
}
static void iter_wrapper_dtor(void *object, zend_object_handle handle TSRMLS_DC)
{
zend_object_iterator *iter = (zend_object_iterator*)object;
iter->funcs->dtor(iter TSRMLS_CC);
}
ZEND_API zval *zend_iterator_wrap(zend_object_iterator *iter TSRMLS_DC)
{
zval *wrapped;
MAKE_STD_ZVAL(wrapped);
Z_TYPE_P(wrapped) = IS_OBJECT;
wrapped->value.obj.handle = zend_objects_store_put(iter, iter_wrapper_dtor, NULL, NULL TSRMLS_CC);
wrapped->value.obj.handlers = &iterator_object_handlers;
return wrapped;
}
ZEND_API enum zend_object_iterator_kind zend_iterator_unwrap(
zval *array_ptr, zend_object_iterator **iter TSRMLS_DC)
{
switch (Z_TYPE_P(array_ptr)) {
case IS_OBJECT:
if (Z_OBJ_HT_P(array_ptr) == &iterator_object_handlers) {
*iter = (zend_object_iterator *)zend_object_store_get_object(array_ptr TSRMLS_CC);
return ZEND_ITER_OBJECT;
}
if (HASH_OF(array_ptr)) {