1 files changed, 116 insertions, 120 deletions

diff --git a/ext/intl/timezone/timezone_class.cpp b/ext/intl/timezone/timezone_class.cpp
index 374b163851..d1e8e2e0a6 100644
--- a/ext/intl/timezone/timezone_class.cpp
+++ b/ext/intl/timezone/timezone_class.cpp
@@ -1,6 +1,6 @@
 /*
    +----------------------------------------------------------------------+
-   | PHP Version 5                                                        |
+   | PHP Version 7                                                        |
    +----------------------------------------------------------------------+
    | This source file is subject to version 3.01 of the PHP license,      |
    | that is bundled with this package in the file LICENSE, and is        |
@@ -45,7 +45,7 @@ U_CDECL_END
 /* }}} */
 
 /* {{{ timezone_object_construct */
-U_CFUNC void timezone_object_construct(const TimeZone *zone, zval *object, int owned TSRMLS_DC)
+U_CFUNC void timezone_object_construct(const TimeZone *zone, zval *object, int owned)
 {
 	TimeZone_object	*to;
 
@@ -60,25 +60,23 @@ U_CFUNC void timezone_object_construct(const TimeZone *zone, zval *object, int o
  *	   Convert from TimeZone to DateTimeZone object */
 U_CFUNC zval *timezone_convert_to_datetimezone(const TimeZone *timeZone,
 											   intl_error *outside_error,
-											   const char *func TSRMLS_DC)
+											   const char *func, zval *ret)
 {
-	zval				*ret = NULL;
 	UnicodeString		id;
 	char				*message = NULL;
 	php_timezone_obj	*tzobj;
-	zval				arg = zval_used_for_init;
+	zval				arg;
 
 	timeZone->getID(id);
 	if (id.isBogus()) {
 		spprintf(&message, 0, "%s: could not obtain TimeZone id", func);
 		intl_errors_set(outside_error, U_ILLEGAL_ARGUMENT_ERROR,
-			message, 1 TSRMLS_CC);
+			message, 1);
 		goto error;
 	}
 
-	MAKE_STD_ZVAL(ret);
 	object_init_ex(ret, php_date_get_timezone_ce());
-	tzobj = (php_timezone_obj *)zend_objects_get_address(ret TSRMLS_CC);
+	tzobj = Z_PHPTIMEZONE_P(ret);
 
 	if (id.compare(0, 3, UnicodeString("GMT", sizeof("GMT")-1, US_INV)) == 0) {
 		/* The DateTimeZone constructor doesn't support offset time zones,
@@ -88,31 +86,33 @@ U_CFUNC zval *timezone_convert_to_datetimezone(const TimeZone *timeZone,
 		//convert offset from milliseconds to minutes
 		tzobj->tzi.utc_offset = -1 * timeZone->getRawOffset() / (60 * 1000);
 	} else {
+		zend_string *u8str;
 		/* Call the constructor! */
-		Z_TYPE(arg) = IS_STRING;
-		if (intl_charFromString(id, &Z_STRVAL(arg), &Z_STRLEN(arg),
-				&INTL_ERROR_CODE(*outside_error)) == FAILURE) {
+		u8str = intl_charFromString(id, &INTL_ERROR_CODE(*outside_error));
+		if (!u8str) {
 			spprintf(&message, 0, "%s: could not convert id to UTF-8", func);
 			intl_errors_set(outside_error, INTL_ERROR_CODE(*outside_error),
-				message, 1 TSRMLS_CC);
+				message, 1);
 			goto error;
 		}
-		zend_call_method_with_1_params(&ret, NULL, NULL, "__construct",
-			NULL, &arg);
+		ZVAL_STR(&arg, u8str);
+		zend_call_method_with_1_params(ret, NULL, NULL, "__construct", NULL, &arg);
 		if (EG(exception)) {
 			spprintf(&message, 0,
 				"%s: DateTimeZone constructor threw exception", func);
 			intl_errors_set(outside_error, U_ILLEGAL_ARGUMENT_ERROR,
-				message, 1 TSRMLS_CC);
-			zend_object_store_ctor_failed(ret TSRMLS_CC);
+				message, 1);
+			zend_object_store_ctor_failed(Z_OBJ_P(ret));
+			zval_ptr_dtor(&arg);
 			goto error;
 		}
+		zval_ptr_dtor(&arg);
 	}
 
 	if (0) {
 error:
 		if (ret) {
-			zval_ptr_dtor(&ret);
+			zval_ptr_dtor(ret);
 		}
 		ret = NULL;
 	}
@@ -120,117 +120,119 @@ error:
 	if (message) {
 		efree(message);
 	}
-	if (Z_TYPE(arg) == IS_STRING) {
-		zval_dtor(&arg);
-	}
 	return ret;
 }
 /* }}} */
 
 /* {{{ timezone_process_timezone_argument
  * TimeZone argument processor. outside_error may be NULL (for static functions/constructors) */
-U_CFUNC TimeZone *timezone_process_timezone_argument(zval **zv_timezone,
+U_CFUNC TimeZone *timezone_process_timezone_argument(zval *zv_timezone,
 													 intl_error *outside_error,
-													 const char *func TSRMLS_DC)
+													 const char *func)
 {
-	zval		local_zv_tz		= zval_used_for_init,
-				*local_zv_tz_p	= &local_zv_tz;
+	zval		local_zv_tz;
 	char		*message = NULL;
 	TimeZone	*timeZone;
 
-	if (zv_timezone == NULL || Z_TYPE_PP(zv_timezone) == IS_NULL) {
-		timelib_tzinfo *tzinfo = get_timezone_info(TSRMLS_C);
-		ZVAL_STRING(&local_zv_tz, tzinfo->name, 0);
-		zv_timezone = &local_zv_tz_p;
+	if (zv_timezone == NULL || Z_TYPE_P(zv_timezone) == IS_NULL) {
+		timelib_tzinfo *tzinfo = get_timezone_info();
+		ZVAL_STRING(&local_zv_tz, tzinfo->name);
+		zv_timezone = &local_zv_tz;
+	} else {
+		ZVAL_NULL(&local_zv_tz);
 	}
 
-	if (Z_TYPE_PP(zv_timezone) == IS_OBJECT &&
-			instanceof_function(Z_OBJCE_PP(zv_timezone), TimeZone_ce_ptr TSRMLS_CC)) {
-		TimeZone_object *to = (TimeZone_object*)zend_objects_get_address(
-			*zv_timezone TSRMLS_CC);
+	if (Z_TYPE_P(zv_timezone) == IS_OBJECT &&
+			instanceof_function(Z_OBJCE_P(zv_timezone), TimeZone_ce_ptr)) {
+		TimeZone_object *to = Z_INTL_TIMEZONE_P(zv_timezone);
 		if (to->utimezone == NULL) {
 			spprintf(&message, 0, "%s: passed IntlTimeZone is not "
 				"properly constructed", func);
 			if (message) {
-				intl_errors_set(outside_error, U_ILLEGAL_ARGUMENT_ERROR, message, 1 TSRMLS_CC);
+				intl_errors_set(outside_error, U_ILLEGAL_ARGUMENT_ERROR, message, 1);
 				efree(message);
 			}
+			zval_dtor(&local_zv_tz);
 			return NULL;
 		}
 		timeZone = to->utimezone->clone();
 		if (timeZone == NULL) {
 			spprintf(&message, 0, "%s: could not clone TimeZone", func);
 			if (message) {
-				intl_errors_set(outside_error, U_MEMORY_ALLOCATION_ERROR, message, 1 TSRMLS_CC);
+				intl_errors_set(outside_error, U_MEMORY_ALLOCATION_ERROR, message, 1);
 				efree(message);
 			}
+			zval_dtor(&local_zv_tz);
 			return NULL;
 		}
-	} else if (Z_TYPE_PP(zv_timezone) == IS_OBJECT &&
-			instanceof_function(Z_OBJCE_PP(zv_timezone), php_date_get_timezone_ce() TSRMLS_CC)) {
+	} else if (Z_TYPE_P(zv_timezone) == IS_OBJECT &&
+			instanceof_function(Z_OBJCE_P(zv_timezone), php_date_get_timezone_ce())) {
 
-		php_timezone_obj *tzobj = (php_timezone_obj *)zend_objects_get_address(
-				*zv_timezone TSRMLS_CC);
+		php_timezone_obj *tzobj = Z_PHPTIMEZONE_P(zv_timezone);
 
+		zval_dtor(&local_zv_tz);
 		return timezone_convert_datetimezone(tzobj->type, tzobj, 0,
-			outside_error, func TSRMLS_CC);
+			outside_error, func);
 	} else {
 		UnicodeString	id,
 						gottenId;
 		UErrorCode		status = U_ZERO_ERROR; /* outside_error may be NULL */
 		convert_to_string_ex(zv_timezone);
-		if (intl_stringFromChar(id, Z_STRVAL_PP(zv_timezone), Z_STRLEN_PP(zv_timezone),
+		if (intl_stringFromChar(id, Z_STRVAL_P(zv_timezone), Z_STRLEN_P(zv_timezone),
 				&status) == FAILURE) {
 			spprintf(&message, 0, "%s: Time zone identifier given is not a "
 				"valid UTF-8 string", func);
 			if (message) {
-				intl_errors_set(outside_error, status, message, 1 TSRMLS_CC);
+				intl_errors_set(outside_error, status, message, 1);
 				efree(message);
 			}
+			zval_dtor(&local_zv_tz);
 			return NULL;
 		}
 		timeZone = TimeZone::createTimeZone(id);
 		if (timeZone == NULL) {
 			spprintf(&message, 0, "%s: could not create time zone", func);
 			if (message) {
-				intl_errors_set(outside_error, U_MEMORY_ALLOCATION_ERROR, message, 1 TSRMLS_CC);
+				intl_errors_set(outside_error, U_MEMORY_ALLOCATION_ERROR, message, 1);
 				efree(message);
 			}
+			zval_dtor(&local_zv_tz);
 			return NULL;
 		}
 		if (timeZone->getID(gottenId) != id) {
 			spprintf(&message, 0, "%s: no such time zone: '%s'",
-				func, Z_STRVAL_PP(zv_timezone));
+				func, Z_STRVAL_P(zv_timezone));
 			if (message) {
-				intl_errors_set(outside_error, U_ILLEGAL_ARGUMENT_ERROR, message, 1 TSRMLS_CC);
+				intl_errors_set(outside_error, U_ILLEGAL_ARGUMENT_ERROR, message, 1);
 				efree(message);
 			}
+			zval_dtor(&local_zv_tz);
 			delete timeZone;
 			return NULL;
 		}
 	}
 
+	zval_dtor(&local_zv_tz);
+
 	return timeZone;
 }
 /* }}} */
 
 /* {{{ clone handler for TimeZone */
-static zend_object_value TimeZone_clone_obj(zval *object TSRMLS_DC)
+static zend_object *TimeZone_clone_obj(zval *object)
 {
 	TimeZone_object		*to_orig,
 						*to_new;
-	zend_object_value   ret_val;
-	intl_error_reset(NULL TSRMLS_CC);
+	zend_object			*ret_val;
+	intl_error_reset(NULL);
 
-	to_orig = (TimeZone_object*)zend_object_store_get_object(object TSRMLS_CC);
-	intl_error_reset(TIMEZONE_ERROR_P(to_orig) TSRMLS_CC);
+	to_orig = Z_INTL_TIMEZONE_P(object);
+	intl_error_reset(TIMEZONE_ERROR_P(to_orig));
 
-	ret_val = TimeZone_ce_ptr->create_object(Z_OBJCE_P(object) TSRMLS_CC);
-	to_new  = (TimeZone_object*)zend_object_store_get_object_by_handle(
-		ret_val.handle TSRMLS_CC);
+	ret_val = TimeZone_ce_ptr->create_object(Z_OBJCE_P(object));
+	to_new  = php_intl_timezone_fetch_object(ret_val);
 
-	zend_objects_clone_members(&to_new->zo, ret_val,
-		&to_orig->zo, Z_OBJ_HANDLE_P(object) TSRMLS_CC);
+	zend_objects_clone_members(&to_new->zo, &to_orig->zo);
 
 	if (to_orig->utimezone != NULL) {
 		TimeZone	*newTimeZone;
@@ -238,19 +240,19 @@ static zend_object_value TimeZone_clone_obj(zval *object TSRMLS_DC)
 		newTimeZone = to_orig->utimezone->clone();
 		to_new->should_delete = 1;
 		if (!newTimeZone) {
-			char *err_msg;
+			zend_string *err_msg;
 			intl_errors_set_code(TIMEZONE_ERROR_P(to_orig),
-				U_MEMORY_ALLOCATION_ERROR TSRMLS_CC);
+				U_MEMORY_ALLOCATION_ERROR);
 			intl_errors_set_custom_msg(TIMEZONE_ERROR_P(to_orig),
-				"Could not clone IntlTimeZone", 0 TSRMLS_CC);
-			err_msg = intl_error_get_message(TIMEZONE_ERROR_P(to_orig) TSRMLS_CC);
-			zend_throw_exception(NULL, err_msg, 0 TSRMLS_CC);
-			efree(err_msg);
+				"Could not clone IntlTimeZone", 0);
+			err_msg = intl_error_get_message(TIMEZONE_ERROR_P(to_orig));
+			zend_throw_exception(NULL, ZSTR_VAL(err_msg), 0);
+			zend_string_free(err_msg);
 		} else {
 			to_new->utimezone = newTimeZone;
 		}
 	} else {
-		zend_throw_exception(NULL, "Cannot clone unconstructed IntlTimeZone", 0 TSRMLS_CC);
+		zend_throw_exception(NULL, "Cannot clone unconstructed IntlTimeZone", 0);
 	}
 
 	return ret_val;
@@ -259,137 +261,127 @@ static zend_object_value TimeZone_clone_obj(zval *object TSRMLS_DC)
 
 /* {{{ compare_objects handler for TimeZone
  *     Can't be used for >, >=, <, <= comparisons */
-static int TimeZone_compare_objects(zval *object1, zval *object2 TSRMLS_DC)
+static int TimeZone_compare_objects(zval *object1, zval *object2)
 {
 	TimeZone_object		*to1,
 						*to2;
-	to1 = (TimeZone_object*)zend_object_store_get_object(object1 TSRMLS_CC);
-	to2 = (TimeZone_object*)zend_object_store_get_object(object2 TSRMLS_CC);
+	to1 = Z_INTL_TIMEZONE_P(object1);
+	to2 = Z_INTL_TIMEZONE_P(object2);
 
 	if (to1->utimezone == NULL || to2->utimezone == NULL) {
 		zend_throw_exception(NULL, "Comparison with at least one unconstructed "
-				"IntlTimeZone operand", 0 TSRMLS_CC);
+				"IntlTimeZone operand", 0);
 		/* intentionally not returning */
 	} else {
 		if (*to1->utimezone == *to2->utimezone) {
 			return 0;
 		}
 	}
-	
+
 	return 1;
 }
 /* }}} */
 
 /* {{{ get_debug_info handler for TimeZone */
-static HashTable *TimeZone_get_debug_info(zval *object, int *is_temp TSRMLS_DC)
+static HashTable *TimeZone_get_debug_info(zval *object, int *is_temp)
 {
-	zval			zv = zval_used_for_init;
+	zval			zv;
 	TimeZone_object	*to;
 	const TimeZone	*tz;
 	UnicodeString	ustr;
-	char			*str;
-	int				str_len;
+	zend_string     *u8str;
+	HashTable 		*debug_info;
 	UErrorCode		uec = U_ZERO_ERROR;
 
 	*is_temp = 1;
-	
-	array_init_size(&zv, 4);
 
-	to = (TimeZone_object*)zend_object_store_get_object(object TSRMLS_CC);
+	ALLOC_HASHTABLE(debug_info);
+	zend_hash_init(debug_info, 8, NULL, ZVAL_PTR_DTOR, 0);
+
+	to = Z_INTL_TIMEZONE_P(object);
 	tz = to->utimezone;
 
 	if (tz == NULL) {
-		add_assoc_bool_ex(&zv, "valid", sizeof("valid"), 0);
-		return Z_ARRVAL(zv);
+		ZVAL_FALSE(&zv);
+		zend_hash_str_update(debug_info, "valid", sizeof("valid") - 1, &zv);
+		return debug_info;
 	}
 
-	add_assoc_bool_ex(&zv, "valid", sizeof("valid"), 1);
+	ZVAL_TRUE(&zv);
+	zend_hash_str_update(debug_info, "valid", sizeof("valid") - 1, &zv);
 
 	tz->getID(ustr);
-	intl_convert_utf16_to_utf8(&str, &str_len,
+	u8str = intl_convert_utf16_to_utf8(
 		ustr.getBuffer(), ustr.length(), &uec);
-	if (U_FAILURE(uec)) {
-		return Z_ARRVAL(zv);
+	if (!u8str) {
+		return debug_info;
 	}
-	add_assoc_stringl_ex(&zv, "id", sizeof("id"), str, str_len, 0);
+	ZVAL_NEW_STR(&zv, u8str);
+	zend_hash_str_update(debug_info, "id", sizeof("id") - 1, &zv);
 
 	int32_t rawOffset, dstOffset;
 	UDate now = Calendar::getNow();
 	tz->getOffset(now, FALSE, rawOffset, dstOffset, uec);
 	if (U_FAILURE(uec)) {
-		return Z_ARRVAL(zv);
+		return debug_info;
 	}
-	
-	add_assoc_long_ex(&zv, "rawOffset", sizeof("rawOffset"), (long)rawOffset);
-	add_assoc_long_ex(&zv, "currentOffset", sizeof("currentOffset"),
-		(long)(rawOffset + dstOffset));
 
-	return Z_ARRVAL(zv);
+	ZVAL_LONG(&zv, (zend_long)rawOffset);
+	zend_hash_str_update(debug_info,"rawOffset", sizeof("rawOffset") - 1, &zv);
+	ZVAL_LONG(&zv, (zend_long)(rawOffset + dstOffset));
+	zend_hash_str_update(debug_info,"currentOffset", sizeof("currentOffset") - 1, &zv);
+
+	return debug_info;
 }
 /* }}} */
 
 /* {{{ void TimeZone_object_init(TimeZone_object* to)
  * Initialize internals of TImeZone_object not specific to zend standard objects.
  */
-static void TimeZone_object_init(TimeZone_object *to TSRMLS_DC)
+static void TimeZone_object_init(TimeZone_object *to)
 {
-	intl_error_init(TIMEZONE_ERROR_P(to) TSRMLS_CC);
+	intl_error_init(TIMEZONE_ERROR_P(to));
 	to->utimezone = NULL;
 	to->should_delete = 0;
 }
 /* }}} */
 
 /* {{{ TimeZone_objects_dtor */
-static void TimeZone_objects_dtor(zend_object *object,
-								   zend_object_handle handle TSRMLS_DC)
+static void TimeZone_objects_dtor(zend_object *object)
 {
-	zend_objects_destroy_object(object, handle TSRMLS_CC);
+	zend_objects_destroy_object(object);
 }
 /* }}} */
 
 /* {{{ TimeZone_objects_free */
-static void TimeZone_objects_free(zend_object *object TSRMLS_DC)
+static void TimeZone_objects_free(zend_object *object)
 {
-	TimeZone_object* to = (TimeZone_object*) object;
+	TimeZone_object* to = php_intl_timezone_fetch_object(object);
 
 	if (to->utimezone && to->should_delete) {
 		delete to->utimezone;
 		to->utimezone = NULL;
 	}
-	intl_error_reset(TIMEZONE_ERROR_P(to) TSRMLS_CC);
-
-	zend_object_std_dtor(&to->zo TSRMLS_CC);
+	intl_error_reset(TIMEZONE_ERROR_P(to));
 
-	efree(to);
+	zend_object_std_dtor(&to->zo);
 }
 /* }}} */
 
 /* {{{ TimeZone_object_create */
-static zend_object_value TimeZone_object_create(zend_class_entry *ce TSRMLS_DC)
+static zend_object *TimeZone_object_create(zend_class_entry *ce)
 {
-	zend_object_value   retval;
 	TimeZone_object*	intern;
 
-	intern = (TimeZone_object*)ecalloc(1, sizeof(TimeZone_object));
-	
-	zend_object_std_init(&intern->zo, ce TSRMLS_CC);
-#if PHP_VERSION_ID < 50399
-    zend_hash_copy(intern->zo.properties, &(ce->default_properties),
-        (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval*));
-#else
-    object_properties_init((zend_object*) intern, ce);
-#endif
-	TimeZone_object_init(intern TSRMLS_CC);
+	intern = (TimeZone_object*)ecalloc(1, sizeof(TimeZone_object) + sizeof(zval) * (ce->default_properties_count - 1));
 
-	retval.handle = zend_objects_store_put(
-		intern,
-		(zend_objects_store_dtor_t) TimeZone_objects_dtor,
-		(zend_objects_free_object_storage_t) TimeZone_objects_free,
-		NULL TSRMLS_CC);
+	zend_object_std_init(&intern->zo, ce);
+    object_properties_init(&intern->zo, ce);
+	TimeZone_object_init(intern);
 
-	retval.handlers = &TimeZone_handlers;
+	intern->zo.handlers = &TimeZone_handlers;
 
-	return retval;
+	return &intern->zo;
 }
 /* }}} */
 
@@ -490,31 +482,35 @@ static zend_function_entry TimeZone_class_functions[] = {
 /* {{{ timezone_register_IntlTimeZone_class
  * Initialize 'IntlTimeZone' class
  */
-U_CFUNC void timezone_register_IntlTimeZone_class(TSRMLS_D)
+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 TSRMLS_CC);
+	TimeZone_ce_ptr = zend_register_internal_class(&ce);
 	if (!TimeZone_ce_ptr) {
 		//can't happen now without bigger problems before
-		php_error_docref0(NULL TSRMLS_CC, E_ERROR,
+		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 TSRMLS_CC)
+		val)
 
 	TIMEZONE_DECL_LONG_CONST("DISPLAY_SHORT", TimeZone::SHORT);
 	TIMEZONE_DECL_LONG_CONST("DISPLAY_LONG", TimeZone::LONG);