Esempio n. 1
0
/* {{{ phpg_read_property() */
zval* phpg_read_property(zval *object, zval *member, int type PHPGTK_PROPERTY_END)
{
	phpg_head_t *poh = NULL;
	zval tmp_member;
	zval result, *result_ptr = NULL;
	prop_info_t *pi = NULL;
	int ret;

 	if (member->type != IS_STRING) {
		tmp_member = *member;
		zval_copy_ctor(&tmp_member);
		convert_to_string(&tmp_member);
		member = &tmp_member;
	}

	ret = FAILURE;

	poh = (phpg_head_t *) zend_object_store_get_object(object TSRMLS_CC);
	if (poh->pi_hash) {
		ret = zend_hash_find(poh->pi_hash, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, (void **) &pi);
	}

	if (ret == SUCCESS) {
        memset(&result, 0, sizeof(zval));
        ZVAL_NULL(&result);
		ret = pi->read(poh, &result TSRMLS_CC);
		if (ret == SUCCESS) {
			ALLOC_ZVAL(result_ptr);
			*result_ptr = result;
            //INIT_PZVAL(result_ptr);
			Z_SET_REFCOUNT_P(result_ptr, 0);
			Z_UNSET_ISREF_P(result_ptr);
        } else {
            result_ptr = EG(uninitialized_zval_ptr);
        }
	} else {
	#if PHP_VERSION_ID < 50399
		result_ptr = zend_get_std_object_handlers()->read_property(object, member, type TSRMLS_CC);
	#else	
		result_ptr = zend_get_std_object_handlers()->read_property(object, member, type, NULL TSRMLS_CC);
	#endif
	}

	if (member == &tmp_member) {
		zval_dtor(member);
	}

	return result_ptr;
}
Esempio n. 2
0
int php_runkit_init_sandbox_parent(INIT_FUNC_ARGS)
{
	zend_class_entry ce;

	INIT_CLASS_ENTRY(ce, PHP_RUNKIT_SANDBOX_PARENT_CLASSNAME, php_runkit_sandbox_parent_functions);
	php_runkit_sandbox_parent_entry = zend_register_internal_class(&ce);
	php_runkit_sandbox_parent_entry->create_object = php_runkit_sandbox_parent_ctor;

	/* Make a new object handler struct with a couple minor changes */
	memcpy(&php_runkit_sandbox_parent_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
	php_runkit_sandbox_parent_handlers.read_property			= php_runkit_sandbox_parent_read_property;
	php_runkit_sandbox_parent_handlers.write_property			= php_runkit_sandbox_parent_write_property;
	php_runkit_sandbox_parent_handlers.has_property				= php_runkit_sandbox_parent_has_property;
	php_runkit_sandbox_parent_handlers.unset_property			= php_runkit_sandbox_parent_unset_property;

	/* No dimension access for parent (initially) */
	php_runkit_sandbox_parent_handlers.read_dimension			= NULL;
	php_runkit_sandbox_parent_handlers.write_dimension			= NULL;
	php_runkit_sandbox_parent_handlers.has_dimension			= NULL;
	php_runkit_sandbox_parent_handlers.unset_dimension			= NULL;

	/* ZE has no concept of modifying properties in place via zval** across contexts */
	php_runkit_sandbox_parent_handlers.get_property_ptr_ptr		= NULL;

	return SUCCESS;
}
Esempio n. 3
0
void zend_register_closure_ce(void) /* {{{ */
{
	zend_class_entry ce;

	INIT_CLASS_ENTRY(ce, "Closure", closure_functions);
	zend_ce_closure = zend_register_internal_class(&ce);
	zend_ce_closure->ce_flags |= ZEND_ACC_FINAL;
	zend_ce_closure->create_object = zend_closure_new;
	zend_ce_closure->serialize = zend_class_serialize_deny;
	zend_ce_closure->unserialize = zend_class_unserialize_deny;

	memcpy(&closure_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
	closure_handlers.free_obj = zend_closure_free_storage;
	closure_handlers.get_constructor = zend_closure_get_constructor;
	closure_handlers.get_method = zend_closure_get_method;
	closure_handlers.write_property = zend_closure_write_property;
	closure_handlers.read_property = zend_closure_read_property;
	closure_handlers.get_property_ptr_ptr = zend_closure_get_property_ptr_ptr;
	closure_handlers.has_property = zend_closure_has_property;
	closure_handlers.unset_property = zend_closure_unset_property;
	closure_handlers.compare_objects = zend_closure_compare_objects;
	closure_handlers.clone_obj = zend_closure_clone;
	closure_handlers.get_debug_info = zend_closure_get_debug_info;
	closure_handlers.get_closure = zend_closure_get_closure;
	closure_handlers.get_gc = zend_closure_get_gc;
}
Esempio n. 4
0
/* {{{ mysqli_read_property */
zval *mysqli_read_property(zval *object, zval *member, int type, void **cache_slot, zval *rv)
{
	zval tmp_member;
	zval *retval;
	mysqli_object *obj;
	mysqli_prop_handler *hnd = NULL;

	obj = Z_MYSQLI_P(object);

	if (Z_TYPE_P(member) != IS_STRING) {
		ZVAL_COPY(&tmp_member, member);
		convert_to_string(&tmp_member);
		member = &tmp_member;
	}

	if (obj->prop_handler != NULL) {
		hnd = zend_hash_find_ptr(obj->prop_handler, Z_STR_P(member));
	}

	if (hnd) {
		retval = hnd->read_func(obj, rv);
		if (retval == NULL) {
			retval = &EG(uninitialized_zval);
		}
	} else {
		zend_object_handlers *std_hnd = zend_get_std_object_handlers();
		retval = std_hnd->read_property(object, member, type, cache_slot, rv);
	}

	if (member == &tmp_member) {
		zval_dtor(member);
	}

	return retval;
}
Esempio n. 5
0
/* {{{ xmlreader_get_property_ptr_ptr */
zval *xmlreader_get_property_ptr_ptr(zval *object, zval *member, int type, void **cache_slot)
{
	xmlreader_object *obj;
	zval tmp_member;
	zval *retval = NULL;
	xmlreader_prop_handler *hnd = NULL;
	zend_object_handlers *std_hnd;

 	if (Z_TYPE_P(member) != IS_STRING) {
		tmp_member = *member;
		zval_copy_ctor(&tmp_member);
		convert_to_string(&tmp_member);
		member = &tmp_member;
	}

	obj = Z_XMLREADER_P(object);

	if (obj->prop_handler != NULL) {
		hnd = zend_hash_find_ptr(obj->prop_handler, Z_STR_P(member));
	}

	if (hnd == NULL) {
		std_hnd = zend_get_std_object_handlers();
		retval = std_hnd->get_property_ptr_ptr(object, member, type, cache_slot);
	}

	if (member == &tmp_member) {
		zval_dtor(member);
	}

	return retval;
}
Esempio n. 6
0
/* {{{ xmlreader_write_property */
void xmlreader_write_property(zval *object, zval *member, zval *value, void **cache_slot)
{
	xmlreader_object *obj;
	zval tmp_member;
	xmlreader_prop_handler *hnd = NULL;
	zend_object_handlers *std_hnd;

 	if (Z_TYPE_P(member) != IS_STRING) {
		tmp_member = *member;
		zval_copy_ctor(&tmp_member);
		convert_to_string(&tmp_member);
		member = &tmp_member;
	}

	obj = Z_XMLREADER_P(object);

	if (obj->prop_handler != NULL) {
		hnd = zend_hash_find_ptr(obj->prop_handler, Z_STR_P(member));
	}
	if (hnd != NULL) {
		php_error_docref(NULL, E_WARNING, "Cannot write to read-only property");
	} else {
		std_hnd = zend_get_std_object_handlers();
		std_hnd->write_property(object, member, value, cache_slot);
	}

	if (member == &tmp_member) {
		zval_dtor(member);
	}
}
Esempio n. 7
0
/* {{{ mysqli_write_property */
void mysqli_write_property(zval *object, zval *member, zval *value, void **cache_slot)
{
	zval tmp_member;
	mysqli_object *obj;
	mysqli_prop_handler *hnd = NULL;

	if (Z_TYPE_P(member) != IS_STRING) {
		ZVAL_COPY(&tmp_member, member);
		convert_to_string(&tmp_member);
		member = &tmp_member;
	}

	obj = Z_MYSQLI_P(object);

	if (obj->prop_handler != NULL) {
		hnd = zend_hash_find_ptr(obj->prop_handler, Z_STR_P(member));
	}

	if (hnd) {
		hnd->write_func(obj, value);
	} else {
		zend_object_handlers *std_hnd = zend_get_std_object_handlers();
		std_hnd->write_property(object, member, value, cache_slot);
	}

	if (member == &tmp_member) {
		zval_dtor(member);
	}
}
Esempio n. 8
0
int php_krb5_register_kadm5_principal(TSRMLS_D) {
	zend_class_entry kadm5_principal;
	INIT_CLASS_ENTRY(kadm5_principal, "KADM5Principal", krb5_kadm5_principal_functions);
	krb5_ce_kadm5_principal = zend_register_internal_class(&kadm5_principal TSRMLS_CC);
	krb5_ce_kadm5_principal->create_object = php_krb5_kadm5_principal_object_new;
	memcpy(&krb5_kadm5_principal_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
	return SUCCESS;
}
Esempio n. 9
0
int php_krb5_register_kadm5_policy(TSRMLS_D) {
	zend_class_entry kadm5_policy;
	INIT_CLASS_ENTRY(kadm5_policy, "KADM5Policy", krb5_kadm5_policy_functions);
	krb5_ce_kadm5_policy = zend_register_internal_class(&kadm5_policy TSRMLS_CC);
	krb5_ce_kadm5_policy->create_object = php_krb5_kadm5_policy_object_new;
	memcpy(&krb5_kadm5_policy_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
	return SUCCESS;
}
Esempio n. 10
0
void mhcontroller_init(TSRMLS_D)
{
	zend_class_entry ce;
	INIT_CLASS_ENTRY(ce, "MHController", php_microhouse_mhcontroller_class_functions);
	memcpy(&mhcontroller_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
	mhcontroller_object_handlers.clone_obj = NULL;
	mhcontroller_ce = zend_register_internal_class(&ce TSRMLS_CC);
}
Esempio n. 11
0
static void vector_write_property(zval *object, zval *member, zval *value, void **cache_slot) /* {{{ */
{
	zval tmp;

	if (zend_hash_exists(&Z_OBJCE_P(object)->properties_info, Z_STR_P(member))) {
		ZVAL_DOUBLE(&tmp, zval_get_double(value));
		zend_get_std_object_handlers()->write_property(object, member, &tmp, cache_slot);
	}
}
Esempio n. 12
0
void register_ws_connection_class(TSRMLS_DC)
{
	zend_class_entry tmp_ws_connection_ce;

	INIT_NS_CLASS_ENTRY(tmp_ws_connection_ce, "WebSocket", "Connection", obj_ws_connection_funcs);
	ws_connection_ce = zend_register_internal_class(&tmp_ws_connection_ce TSRMLS_CC);
	ws_connection_ce->create_object = ws_connection_create_object_handler;
	memcpy(&ws_connection_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
	ws_connection_object_handlers.free_obj = (zend_object_free_obj_t) ws_connection_free_object_storage_handler;
}
Esempio n. 13
0
void init_distance_map(TSRMLS_D) {
    zend_class_entry ce;

    INIT_CLASS_ENTRY(ce, "distance_map", distance_map_methods);
    distance_map_ce = zend_register_internal_class(&ce TSRMLS_CC);
    distance_map_ce->create_object = create_distance_map_object;

    memcpy(&distance_map_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
    distance_map_handlers.clone_obj = clone_distance_map_object;
}
Esempio n. 14
0
void grpc_init_timeval() {
  zend_class_entry ce;
  INIT_CLASS_ENTRY(ce, "Grpc\\Timeval", timeval_methods);
  ce.create_object = create_wrapped_grpc_timeval;
  grpc_ce_timeval = zend_register_internal_class(&ce);
  memcpy(&timeval_object_handlers_timeval, zend_get_std_object_handlers(),
         sizeof(zend_object_handlers));
  timeval_object_handlers_timeval.offset =
    XtOffsetOf(wrapped_grpc_timeval, std);
  timeval_object_handlers_timeval.free_obj = free_wrapped_grpc_timeval;
}
Esempio n. 15
0
void grpc_init_call() {
  zend_class_entry ce;
  INIT_CLASS_ENTRY(ce, "Grpc\\Call", call_methods);
  ce.create_object = create_wrapped_grpc_call;
  grpc_ce_call = zend_register_internal_class(&ce);
  memcpy(&call_object_handlers_call, zend_get_std_object_handlers(),
         sizeof(zend_object_handlers));
  call_object_handlers_call.offset = XtOffsetOf(wrapped_grpc_call, std);
  call_object_handlers_call.free_obj = free_wrapped_grpc_call;
  return;
}
Esempio n. 16
0
static int phalcon_translate_adapter_gettext_has_dimension(zval *object, zval *offset, int check_empty TSRMLS_DC)
{
	char *msgstr;

	if (!is_phalcon_class(Z_OBJCE_P(object))) {
		return zend_get_std_object_handlers()->has_dimension(object, offset, check_empty TSRMLS_CC);
	}

	msgstr = gettext(Z_STRVAL_P(offset));

	return (1 == check_empty) ? strlen(msgstr) : 1;
}
Esempio n. 17
0
void MAPIAppointmentRegisterClass(TSRMLS_D)
{
	zend_class_entry	ce;

	INIT_CLASS_ENTRY(ce, "MAPIAppointment", mapi_appointment_class_functions);
	mapi_appointment_ce = zend_register_internal_class_ex(&ce, NULL, "mapimessage" TSRMLS_CC);

	mapi_appointment_ce->create_object = mapi_message_create_handler;

	memcpy(&mapi_appointment_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
	mapi_appointment_object_handlers.clone_obj = NULL;
}
Esempio n. 18
0
void message_init(TSRMLS_D) {
  zend_class_entry class_type;
  INIT_CLASS_ENTRY(class_type, "Google\\Protobuf\\Internal\\Message",
                   message_methods);
  message_type = zend_register_internal_class(&class_type TSRMLS_CC);

  message_handlers = PEMALLOC(zend_object_handlers);
  memcpy(message_handlers, zend_get_std_object_handlers(),
         sizeof(zend_object_handlers));
  message_handlers->write_property = message_set_property;
  message_handlers->read_property = message_get_property;
  message_handlers->get_property_ptr_ptr = message_get_property_ptr_ptr;
}
Esempio n. 19
0
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();
  }
}
Esempio n. 20
0
void grpc_init_server_credentials() {
  zend_class_entry ce;
  INIT_CLASS_ENTRY(ce, "Grpc\\ServerCredentials", server_credentials_methods);
  ce.create_object = create_wrapped_grpc_server_credentials;
  grpc_ce_server_credentials = zend_register_internal_class(&ce);
  memcpy(&server_credentials_ce_handlers,
         zend_get_std_object_handlers(),
         sizeof(zend_object_handlers));
  server_credentials_ce_handlers.offset =
    XtOffsetOf(wrapped_grpc_server_credentials, std);
  server_credentials_ce_handlers.free_obj =
    free_wrapped_grpc_server_credentials;
}
Esempio n. 21
0
/* {{{ timezone_register_IntlTimeZone_class
 * Initialize 'IntlTimeZone' class
 */
U_CFUNC void timezone_register_IntlTimeZone_class(void)
{
	zend_class_entry ce;

	/* Create and register 'IntlTimeZone' class. */
	INIT_CLASS_ENTRY(ce, "IntlTimeZone", TimeZone_class_functions);
	ce.create_object = TimeZone_object_create;
	TimeZone_ce_ptr = zend_register_internal_class(&ce);
	if (!TimeZone_ce_ptr) {
		//can't happen now without bigger problems before
		php_error_docref0(NULL, E_ERROR,
			"IntlTimeZone: class registration has failed.");
		return;
	}

	memcpy(&TimeZone_handlers, zend_get_std_object_handlers(),
		sizeof TimeZone_handlers);
	TimeZone_handlers.offset = XtOffsetOf(TimeZone_object, zo);
	TimeZone_handlers.clone_obj = TimeZone_clone_obj;
	TimeZone_handlers.compare_objects = TimeZone_compare_objects;
	TimeZone_handlers.get_debug_info = TimeZone_get_debug_info;
	TimeZone_handlers.dtor_obj = TimeZone_objects_dtor;
	TimeZone_handlers.free_obj = TimeZone_objects_free;


	/* Declare 'IntlTimeZone' class constants */
#define TIMEZONE_DECL_LONG_CONST(name, val) \
	zend_declare_class_constant_long(TimeZone_ce_ptr, name, sizeof(name) - 1, \
		val)

	TIMEZONE_DECL_LONG_CONST("DISPLAY_SHORT", TimeZone::SHORT);
	TIMEZONE_DECL_LONG_CONST("DISPLAY_LONG", TimeZone::LONG);

#if U_ICU_VERSION_MAJOR_NUM * 10 + U_ICU_VERSION_MINOR_NUM >= 44
	TIMEZONE_DECL_LONG_CONST("DISPLAY_SHORT_GENERIC", TimeZone::SHORT_GENERIC);
	TIMEZONE_DECL_LONG_CONST("DISPLAY_LONG_GENERIC", TimeZone::LONG_GENERIC);
	TIMEZONE_DECL_LONG_CONST("DISPLAY_SHORT_GMT", TimeZone::SHORT_GMT);
	TIMEZONE_DECL_LONG_CONST("DISPLAY_LONG_GMT", TimeZone::LONG_GMT);
	TIMEZONE_DECL_LONG_CONST("DISPLAY_SHORT_COMMONLY_USED", TimeZone::SHORT_COMMONLY_USED);
	TIMEZONE_DECL_LONG_CONST("DISPLAY_GENERIC_LOCATION", TimeZone::GENERIC_LOCATION);
#endif

#if U_ICU_VERSION_MAJOR_NUM * 10 + U_ICU_VERSION_MINOR_NUM >= 48
	TIMEZONE_DECL_LONG_CONST("TYPE_ANY", UCAL_ZONE_TYPE_ANY);
	TIMEZONE_DECL_LONG_CONST("TYPE_CANONICAL", UCAL_ZONE_TYPE_CANONICAL);
	TIMEZONE_DECL_LONG_CONST("TYPE_CANONICAL_LOCATION", UCAL_ZONE_TYPE_CANONICAL_LOCATION);
#endif

	/* Declare 'IntlTimeZone' class properties */

}
Esempio n. 22
0
void php_ds_register_queue_handlers()
{
    memcpy(&php_queue_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));

    php_queue_handlers.offset = XtOffsetOf(php_ds_queue_t, std);

    php_queue_handlers.dtor_obj          = zend_objects_destroy_object;
    php_queue_handlers.free_obj          = ds_queue_free_object;
    php_queue_handlers.clone_obj         = ds_queue_clone_obj;
    php_queue_handlers.cast_object       = ds_default_cast_object;
    php_queue_handlers.get_debug_info    = ds_queue_get_debug_info;
    php_queue_handlers.count_elements    = ds_queue_count_elements;
    php_queue_handlers.write_dimension   = ds_queue_write_dimension;
}
Esempio n. 23
0
void php_lua_closure_register() /* {{{ */
{
	zend_class_entry ce;

	INIT_CLASS_ENTRY(ce, "LuaClosure", lua_closure_methods);
	lua_closure_ce = zend_register_internal_class(&ce);
	lua_closure_ce->create_object = php_lua_closure_create_object;
	lua_closure_ce->ce_flags |= ZEND_ACC_FINAL;

	memcpy(&lua_closure_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
	lua_closure_handlers.offset = XtOffsetOf(lua_closure_object, std);
	lua_closure_handlers.clone_obj = NULL;
	lua_closure_handlers.free_obj = php_lua_closure_free_obj;
} /* }}} */
Esempio n. 24
0
extern int oauth_provider_register_class() /* {{{ */
{
	zend_class_entry osce;

	INIT_CLASS_ENTRY(osce, "OAuthProvider", oauth_provider_methods);
	osce.create_object = oauth_provider_new;
	oauthprovider = zend_register_internal_class(&osce);

	memcpy(&oauth_provider_obj_hndlrs, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
	oauth_provider_obj_hndlrs.offset = XtOffsetOf(php_oauth_provider, zo);
	oauth_provider_obj_hndlrs.free_obj = oauth_provider_free_storage;

	return SUCCESS;
}
Esempio n. 25
0
void php_ds_register_set_handlers()
{
    memcpy(&php_ds_set_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));

    php_ds_set_handlers.offset = XtOffsetOf(php_ds_set_t, std);

    php_ds_set_handlers.free_obj            = ds_set_free_object;
    php_ds_set_handlers.clone_obj           = ds_set_clone_obj;
    php_ds_set_handlers.get_debug_info      = ds_set_get_debug_info;
    php_ds_set_handlers.count_elements      = ds_set_count_elements;
    php_ds_set_handlers.read_dimension      = ds_set_read_dimension;
    php_ds_set_handlers.write_dimension     = ds_set_write_dimension;
    php_ds_set_handlers.cast_object         = ds_default_cast_object;
    // php_ds_set_handlers.do_operation        = ds_set_do_operation;
}
Esempio n. 26
0
/* {{{ spoofchecker_register_Spoofchecker_class
 * Initialize 'Spoofchecker' class
 */
void spoofchecker_register_Spoofchecker_class(void)
{
	zend_class_entry ce;

	/* Create and register 'Spoofchecker' class. */
	INIT_CLASS_ENTRY(ce, "Spoofchecker", Spoofchecker_class_functions);
	ce.create_object = Spoofchecker_object_create;
	Spoofchecker_ce_ptr = zend_register_internal_class(&ce);

	memcpy(&Spoofchecker_handlers, zend_get_std_object_handlers(),
		sizeof Spoofchecker_handlers);
	Spoofchecker_handlers.offset = XtOffsetOf(Spoofchecker_object, zo);
	Spoofchecker_handlers.clone_obj = spoofchecker_clone_obj;
	Spoofchecker_handlers.free_obj = Spoofchecker_objects_free;
}
Esempio n. 27
0
static zval* phalcon_translate_adapter_gettext_read_dimension(zval *object, zval *offset, int type TSRMLS_DC)
{
	zval *translation;
	char *msgstr;

	if (!is_phalcon_class(Z_OBJCE_P(object))) {
		return zend_get_std_object_handlers()->read_dimension(object, offset, type TSRMLS_CC);
	}

	msgstr = gettext(Z_STRVAL_P(offset));

	PHALCON_INIT_VAR(translation);
	ZVAL_STRING(translation, msgstr, 1);

	return translation;
}
Esempio n. 28
0
void mongo_init_Mongo(TSRMLS_D)
{
	zend_class_entry ce;

	INIT_CLASS_ENTRY(ce, "Mongo", mongo_methods); /* FIXME: Use mongo_methods here */
	ce.create_object = php_mongoclient_new;
	mongo_ce_Mongo = zend_register_internal_class_ex(&ce, mongo_ce_MongoClient, NULL TSRMLS_CC);

	/* make mongoclient object uncloneable, and with its own read_property */
	memcpy(&mongoclient_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
	mongoclient_handlers.clone_obj = NULL;
	mongoclient_handlers.read_property = mongo_read_property;
#if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION >= 3
	mongoclient_handlers.get_debug_info = mongo_get_debug_info;
#endif
}
Esempio n. 29
0
/* {{{ dateformat_register_class
 * Initialize 'IntlDateFormatter' class
 */
void dateformat_register_IntlDateFormatter_class( void )
{
	zend_class_entry ce;

	/* Create and register 'IntlDateFormatter' class. */
	INIT_CLASS_ENTRY( ce, "IntlDateFormatter", IntlDateFormatter_class_functions );
	ce.create_object = IntlDateFormatter_object_create;
	IntlDateFormatter_ce_ptr = zend_register_internal_class( &ce );

	memcpy(&IntlDateFormatter_handlers, zend_get_std_object_handlers(),
		sizeof IntlDateFormatter_handlers);
	IntlDateFormatter_handlers.offset = XtOffsetOf(IntlDateFormatter_object, zo);
	IntlDateFormatter_handlers.clone_obj = IntlDateFormatter_object_clone;
	IntlDateFormatter_handlers.dtor_obj = IntlDateFormatter_object_dtor;
	IntlDateFormatter_handlers.free_obj = IntlDateFormatter_object_free;
}
Esempio n. 30
0
void register_map_handlers()
{
    memcpy(&map_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));

    map_handlers.offset = XtOffsetOf(Map, std);

    map_handlers.dtor_obj            = zend_objects_destroy_object;
    map_handlers.free_obj            = map_free_object;
    map_handlers.clone_obj           = map_clone_obj;
    map_handlers.get_debug_info      = map_get_debug_info;
    map_handlers.count_elements      = map_count_elements;
    map_handlers.read_dimension      = map_read_dimension;
    map_handlers.write_dimension     = map_write_dimension;
    map_handlers.has_dimension       = map_has_dimension;
    map_handlers.unset_dimension     = map_unset_dimension;
    map_handlers.cast_object         = ds_default_cast_object;
    // map_handlers.get_properties      = map_get_properties;
}