Refactoring ext/intl (only compilerable now, far to finish :<)

Author: laruence

ext/intl/breakiterator/breakiterator_class.cpp

@@ -135,7 +135,7 @@ static zend_object *BreakIterator_clone_obj(zval *object TSRMLS_DC)
 /* {{{ get_debug_info handler for BreakIterator */
 static HashTable *BreakIterator_get_debug_info(zval *object, int *is_temp TSRMLS_DC)
 {
-	zval					zv = zval_used_for_init;
+	zval					zv;
 	BreakIterator_object	*bio;
 	const BreakIterator		*biter;
 

ext/intl/breakiterator/breakiterator_iterators.cpp

@@ -39,8 +39,7 @@ static zend_object_handlers IntlPartsIterator_handlers;
 inline BreakIterator *_breakiter_prolog(zend_object_iterator *iter TSRMLS_DC)
 {
 	BreakIterator_object *bio;
-	bio = (BreakIterator_object*)zend_object_store_get_object(
-			(const zval*)iter->data TSRMLS_CC);
+	bio = Z_INTL_BREAKITERATOR_P(&iter->data);
 	intl_errors_reset(BREAKITER_ERROR_P(bio) TSRMLS_CC);
 	if (bio->biter == NULL) {
 		intl_errors_set(BREAKITER_ERROR_P(bio), U_INVALID_STATE_ERROR,
@@ -52,7 +51,7 @@ inline BreakIterator *_breakiter_prolog(zend_object_iterator *iter TSRMLS_DC)
 
 static void _breakiterator_destroy_it(zend_object_iterator *iter TSRMLS_DC)
 {
-	zval_ptr_dtor((zval**)&iter->data);
+	zval_ptr_dtor(&iter->data);
 }
 
 static void _breakiterator_move_forward(zend_object_iterator *iter TSRMLS_DC)
@@ -68,8 +67,7 @@ static void _breakiterator_move_forward(zend_object_iterator *iter TSRMLS_DC)
 
 	int32_t pos = biter->next();
 	if (pos != BreakIterator::DONE) {
-		MAKE_STD_ZVAL(zoi_iter->current);
-		ZVAL_LONG(zoi_iter->current, (long)pos);
+		ZVAL_LONG(&zoi_iter->current, (long)pos);
 	} //else we've reached the end of the enum, nothing more is required
 }
 
@@ -79,8 +77,7 @@ static void _breakiterator_rewind(zend_object_iterator *iter TSRMLS_DC)
 	zoi_with_current *zoi_iter = (zoi_with_current*)iter;
 
 	int32_t pos = biter->first();
-	MAKE_STD_ZVAL(zoi_iter->current);
-	ZVAL_LONG(zoi_iter->current, (long)pos);
+	ZVAL_LONG(&zoi_iter->current, (long)pos);
 }
 
 static zend_object_iterator_funcs breakiterator_iterator_funcs = {
@@ -103,7 +100,7 @@ U_CFUNC zend_object_iterator *_breakiterator_get_iterator(
 		return NULL;
 	}
 
-	bio = (BreakIterator_object*)zend_object_store_get_object(object TSRMLS_CC);
+	bio = Z_INTL_BREAKITERATOR_P(object);
 	BreakIterator *biter = bio->biter;
 
 	if (biter == NULL) {
@@ -112,16 +109,14 @@ U_CFUNC zend_object_iterator *_breakiterator_get_iterator(
 		return NULL;
 	}
 
-	zoi_with_current *zoi_iter =
-		static_cast<zoi_with_current*>(emalloc(sizeof *zoi_iter));
-	zoi_iter->zoi.data = static_cast<void*>(object);
+	zoi_with_current *zoi_iter = static_cast<zoi_with_current*>(emalloc(sizeof *zoi_iter));
+	zend_iterator_init(&zoi_iter->zoi TSRMLS_CC);
+	ZVAL_COPY(&zoi_iter->zoi.data, object);
 	zoi_iter->zoi.funcs = &breakiterator_iterator_funcs;
 	zoi_iter->zoi.index = 0;
 	zoi_iter->destroy_it = _breakiterator_destroy_it;
-	zoi_iter->wrapping_obj = NULL; /* not used; object is in zoi.data */
-	zoi_iter->current = NULL;
-
-	zval_add_ref(&object);
+	ZVAL_UNDEF(&zoi_iter->wrapping_obj); /* not used; object is in zoi.data */
+	ZVAL_UNDEF(&zoi_iter->current);
 
 	return reinterpret_cast<zend_object_iterator *>(zoi_iter);
 }
@@ -136,7 +131,7 @@ typedef struct zoi_break_iter_parts {
 
 static void _breakiterator_parts_destroy_it(zend_object_iterator *iter TSRMLS_DC)
 {
-	zval_ptr_dtor(reinterpret_cast<zval**>(&iter->data));
+	zval_ptr_dtor(&iter->data);
 }
 
 static void _breakiterator_parts_get_current_key(zend_object_iterator *iter, zval *key TSRMLS_DC)
@@ -172,31 +167,28 @@ static void _breakiterator_parts_move_forward(zend_object_iterator *iter TSRMLS_
 	/* else zoi_bit->key_type == PARTS_ITERATOR_KEY_SEQUENTIAL
 	 * No need to do anything, the engine increments ->index */
 
-	const char	*s = Z_STRVAL_P(bio->text);
-	int32_t		slen = Z_STRLEN_P(bio->text),
-				len;
-	char		*res;
+	const char	*s = Z_STRVAL(bio->text);
+	int32_t		slen = Z_STRLEN(bio->text);
+	zend_string	*res;
 
 	if (next == BreakIterator::DONE) {
 		next = slen;
 	}
 	assert(next <= slen && next >= cur);
-	len = next - cur;
-	res = static_cast<char*>(emalloc(len + 1));
+	res = STR_ALLOC(next - cur, 0);
 
-	memcpy(res, &s[cur], len);
-	res[len] = '\0';
+	memcpy(res->val, &s[cur], res->len);
+	res->val[res->len] = '\0';
 
-	MAKE_STD_ZVAL(zoi_bit->zoi_cur.current);
-	ZVAL_STRINGL(zoi_bit->zoi_cur.current, res, len, 0);
+	ZVAL_STR(&zoi_bit->zoi_cur.current, res);
 }
 
 static void _breakiterator_parts_rewind(zend_object_iterator *iter TSRMLS_DC)
 {
 	zoi_break_iter_parts *zoi_bit = (zoi_break_iter_parts*)iter;
 	BreakIterator_object *bio = zoi_bit->bio;
 
-	if (zoi_bit->zoi_cur.current) {
+	if (!Z_ISUNDEF(zoi_bit->zoi_cur.current)) {
 		iter->funcs->invalidate_current(iter TSRMLS_CC);
 	}
 
@@ -221,72 +213,60 @@ void IntlIterator_from_BreakIterator_parts(zval *break_iter_zv,
 {
 	IntlIterator_object *ii;
 
-	zval_add_ref(&break_iter_zv);
-
 	object_init_ex(object, IntlPartsIterator_ce_ptr);
-	ii = (IntlIterator_object*)zend_object_store_get_object(object TSRMLS_CC);
+	ii = Z_INTL_ITERATOR_P(object);
 
 	ii->iterator = (zend_object_iterator*)emalloc(sizeof(zoi_break_iter_parts));
-	ii->iterator->data = break_iter_zv;
+	zend_iterator_init(ii->iterator TSRMLS_CC);
+	ZVAL_COPY(&ii->iterator->data, break_iter_zv);
 	ii->iterator->funcs = &breakiterator_parts_it_funcs;
 	ii->iterator->index = 0;
 	((zoi_with_current*)ii->iterator)->destroy_it = _breakiterator_parts_destroy_it;
-	((zoi_with_current*)ii->iterator)->wrapping_obj = object;
-	((zoi_with_current*)ii->iterator)->current = NULL;
+	ZVAL_COPY_VALUE(&((zoi_with_current*)ii->iterator)->wrapping_obj, object);
+	ZVAL_UNDEF(&((zoi_with_current*)ii->iterator)->current);
 
-	((zoi_break_iter_parts*)ii->iterator)->bio = (BreakIterator_object*)
-		zend_object_store_get_object(break_iter_zv TSRMLS_CC);
+	((zoi_break_iter_parts*)ii->iterator)->bio = Z_INTL_BREAKITERATOR_P(break_iter_zv);
 	assert(((zoi_break_iter_parts*)ii->iterator)->bio->biter != NULL);
 	((zoi_break_iter_parts*)ii->iterator)->key_type = key_type;
 }
 
-U_CFUNC zend_object_value IntlPartsIterator_object_create(zend_class_entry *ce TSRMLS_DC)
+U_CFUNC zend_object *IntlPartsIterator_object_create(zend_class_entry *ce TSRMLS_DC)
 {
-	zend_object_value		retval;
-
-	retval = IntlIterator_ce_ptr->create_object(ce TSRMLS_CC);
-	retval.handlers = &IntlPartsIterator_handlers;
+	zend_object* retval = IntlIterator_ce_ptr->create_object(ce TSRMLS_CC);
+	retval->handlers = &IntlPartsIterator_handlers;
 
 	return retval;
 }
 
-U_CFUNC zend_function *IntlPartsIterator_get_method(zval **object_ptr,
-		char *method, int method_len, const zend_literal *key TSRMLS_DC)
+U_CFUNC zend_function *IntlPartsIterator_get_method(zend_object **object_ptr, zend_string *method, const zval *key TSRMLS_DC)
 {
-	zend_literal local_literal = {0};
 	zend_function *ret;
-	ALLOCA_FLAG(use_heap)
+	zend_string *lc_method_name;
+	ALLOCA_FLAG(use_heap);
 
 	if (key == NULL) {
-		Z_STRVAL(local_literal.constant) = static_cast<char*>(
-				do_alloca(method_len + 1, use_heap));
-		zend_str_tolower_copy(Z_STRVAL(local_literal.constant),
-				method, method_len);
-		local_literal.hash_value = zend_hash_func(
-				Z_STRVAL(local_literal.constant), method_len + 1);
-		key = &local_literal;
+		STR_ALLOCA_ALLOC(lc_method_name, method->len, use_heap);
+		zend_str_tolower_copy(lc_method_name->val, method->val, method->len);
+	} else {
+		lc_method_name = Z_STR_P(key);
 	}
 
-	if ((key->hash_value & 0xFFFFFFFF) == 0xA2B486A1 /* hash of getrulestatus\0 */
-			&& method_len == sizeof("getrulestatus") - 1
-			&& memcmp("getrulestatus", Z_STRVAL(key->constant),	method_len) == 0) {
-		IntlIterator_object *obj = (IntlIterator_object*)
-				zend_object_store_get_object(*object_ptr TSRMLS_CC);
-		if (obj->iterator && obj->iterator->data) {
-			zval *break_iter_zv = static_cast<zval*>(obj->iterator->data);
-			*object_ptr = break_iter_zv;
-			ret = Z_OBJ_HANDLER_P(break_iter_zv, get_method)(object_ptr,
-					method, method_len, key TSRMLS_CC);
+	if (method->len == sizeof("getrulestatus") - 1
+			&& memcmp("getrulestatus", Z_STRVAL_P(key),	method->len) == 0) {
+		IntlIterator_object *obj = php_intl_iterator_fetch_object(*object_ptr);
+		if (obj->iterator && !Z_ISUNDEF(obj->iterator->data)) {
+			zval *break_iter_zv = &obj->iterator->data;
+			*object_ptr = Z_OBJ_P(break_iter_zv);
+			ret = Z_OBJ_HANDLER_P(break_iter_zv, get_method)(object_ptr, method, key TSRMLS_CC);
 			goto end;
 		}
 	}
 
-	ret = std_object_handlers.get_method(object_ptr,
-			method, method_len, key TSRMLS_CC);
+	ret = std_object_handlers.get_method(object_ptr, method, key TSRMLS_CC);
 
 end:
-	if (key == &local_literal) {
-		free_alloca(Z_STRVAL(local_literal.constant), use_heap);
+	if (key == NULL) {
+	 	STR_ALLOCA_FREE(lc_method_name, use_heap);
 	}
 
 	return ret;
@@ -304,7 +284,7 @@ U_CFUNC PHP_METHOD(IntlPartsIterator, getBreakIterator)
 
 	INTLITERATOR_METHOD_FETCH_OBJECT;
 
-	zval *biter_zval = static_cast<zval*>(ii->iterator->data);
+	zval *biter_zval = &ii->iterator->data;
 	RETURN_ZVAL(biter_zval, 1, 0);
 }
 

ext/intl/breakiterator/breakiterator_methods.cpp

@@ -139,10 +139,10 @@ U_CFUNC PHP_FUNCTION(breakiter_get_text)
 
 	BREAKITER_METHOD_FETCH_OBJECT;
 
-	if (bio->text == NULL) {
+	if (Z_ISUNDEF(bio->text)) {
 		RETURN_NULL();
 	} else {
-		RETURN_ZVAL(bio->text, 1, 0);
+		ZVAL_COPY(return_value, &bio->text);
 	}
 }
 
@@ -151,7 +151,7 @@ U_CFUNC PHP_FUNCTION(breakiter_set_text)
 	char	*text;
 	int		text_len;
 	UText	*ut = NULL;
-	zval	**textzv;
+	zval	*textzv;
 	BREAKITER_METHOD_INIT_VARS;
 	object = getThis();
 
@@ -169,7 +169,7 @@ U_CFUNC PHP_FUNCTION(breakiter_set_text)
 
 	/* assert it's safe to use text and text_len because zpp changes the
 	 * arguments in the stack */
-	assert(text == Z_STRVAL_PP(textzv));
+	assert(text == Z_STRVAL_P(textzv));
 
 	ut = utext_openUTF8(ut, text, text_len, BREAKITER_ERROR_CODE_P(bio));
 	INTL_CTOR_CHECK_STATUS(bio, "breakiter_set_text: error opening UText");
@@ -182,11 +182,8 @@ U_CFUNC PHP_FUNCTION(breakiter_set_text)
 	/* When ICU clones the UText, it does not copy the buffer, so we have to
 	 * keep the string buffer around by holding a reference to its zval. This
 	 * also allows a faste implementation of getText() */
-	if (bio->text != NULL) {
-		zval_ptr_dtor(&bio->text);
-	}
-	bio->text = *textzv;
-	zval_add_ref(&bio->text);
+	zval_ptr_dtor(&bio->text);
+	ZVAL_COPY(&bio->text, textzv);
 
 	RETURN_TRUE;
 }
@@ -274,12 +271,12 @@ U_CFUNC PHP_FUNCTION(breakiter_next)
 	if (ZEND_NUM_ARGS() == 0) {
 		no_arg_version = true;
 	} else if (ZEND_NUM_ARGS() == 1) {
-		zval **arg;
+		zval *arg;
 		int res = zend_get_parameters_ex(1, &arg);
 		assert(res == SUCCESS);
-		if (Z_TYPE_PP(arg) == IS_NULL) {
+		if (Z_TYPE_P(arg) == IS_NULL) {
 			no_arg_version = true;
-			ht = 0; /* pretend we don't have any argument */
+			ZEND_NUM_ARGS() = 0; /* pretend we don't have any argument */
 		} else {
 			no_arg_version = false;
 		}
@@ -380,7 +377,7 @@ U_CFUNC PHP_FUNCTION(breakiter_get_locale)
 	INTL_METHOD_CHECK_STATUS(bio,
 		"breakiter_get_locale: Call to ICU method has failed");
 
-	RETURN_STRING(locale.getName(), 1);
+	RETURN_STRING(locale.getName());
 }
 
 U_CFUNC PHP_FUNCTION(breakiter_get_parts_iterator)
@@ -421,7 +418,7 @@ U_CFUNC PHP_FUNCTION(breakiter_get_error_code)
 	}
 
 	/* Fetch the object (without resetting its last error code ). */
-	bio = (BreakIterator_object*)zend_object_store_get_object(object TSRMLS_CC);
+	bio = Z_INTL_BREAKITERATOR_P(object);
 	if (bio == NULL)
 		RETURN_FALSE;
 
@@ -430,7 +427,7 @@ U_CFUNC PHP_FUNCTION(breakiter_get_error_code)
 
 U_CFUNC PHP_FUNCTION(breakiter_get_error_message)
 {
-	const char* message = NULL;
+	zend_string* message = NULL;
 	BREAKITER_METHOD_INIT_VARS;
 	object = getThis();
 
@@ -442,11 +439,11 @@ U_CFUNC PHP_FUNCTION(breakiter_get_error_message)
 
 
 	/* Fetch the object (without resetting its last error code ). */
-	bio = (BreakIterator_object*)zend_object_store_get_object(object TSRMLS_CC);
+	bio = Z_INTL_BREAKITERATOR_P(object);
 	if (bio == NULL)
 		RETURN_FALSE;
 
 	/* Return last error message. */
 	message = intl_error_get_message(BREAKITER_ERROR_P(bio) TSRMLS_CC);
-	RETURN_STRING(message, 0);
+	RETURN_STR(message);
 }

ext/intl/breakiterator/rulebasedbreakiterator_methods.cpp

@@ -66,7 +66,7 @@ static void _php_intlrbbi_constructor_body(INTERNAL_FUNCTION_PARAMETERS)
 			smart_str parse_error_str;
 			parse_error_str = intl_parse_error_to_string(&parseError);
 			spprintf(&msg, 0, "rbbi_create_instance: unable to create "
-				"RuleBasedBreakIterator from rules (%s)", parse_error_str.c);
+				"RuleBasedBreakIterator from rules (%s)", parse_error_str.s? parse_error_str.s->val : "");
 			smart_str_free(&parse_error_str);
 			intl_error_set_custom_msg(NULL, msg, 1 TSRMLS_CC);
 			efree(msg);
@@ -101,7 +101,7 @@ U_CFUNC PHP_METHOD(IntlRuleBasedBreakIterator, __construct)
 	_php_intlrbbi_constructor_body(INTERNAL_FUNCTION_PARAM_PASSTHRU);
 
 	if (Z_TYPE_P(return_value) == IS_NULL) {
-		zend_object_store_ctor_failed(&orig_this TSRMLS_CC);
+		zend_object_store_ctor_failed(Z_OBJ(orig_this) TSRMLS_CC);
 		zval_dtor(&orig_this);
 	}
 }
@@ -119,17 +119,20 @@ U_CFUNC PHP_FUNCTION(rbbi_get_rules)
 
 	BREAKITER_METHOD_FETCH_OBJECT;
 
+	char *str;
+	int str_len;
 	const UnicodeString rules = fetch_rbbi(bio)->getRules();
 
-	Z_TYPE_P(return_value) = IS_STRING;
-	if (intl_charFromString(rules, &Z_STRVAL_P(return_value),
-			&Z_STRLEN_P(return_value), BREAKITER_ERROR_CODE_P(bio)) == FAILURE)
+	if (intl_charFromString(rules, &str, &str_len, BREAKITER_ERROR_CODE_P(bio)) == FAILURE)
 	{
 		intl_errors_set(BREAKITER_ERROR_P(bio), BREAKITER_ERROR_CODE(bio),
 				"rbbi_hash_code: Error converting result to UTF-8 string",
 				0 TSRMLS_CC);
 		RETURN_FALSE;
 	}
+	RETVAL_STRINGL(str, str_len);
+	//???
+	efree(str);
 }
 
 U_CFUNC PHP_FUNCTION(rbbi_get_rule_status)

ext/intl/calendar/calendar_class.cpp

@@ -146,7 +146,7 @@ static const struct {
 /* {{{ get_debug_info handler for Calendar */
 static HashTable *Calendar_get_debug_info(zval *object, int *is_temp TSRMLS_DC)
 {
-	zval			zv = zval_used_for_init,
+	zval			zv,
 					zfields;
 	Calendar_object	*co;
 	const Calendar	*cal;
@@ -169,7 +169,7 @@ static HashTable *Calendar_get_debug_info(zval *object, int *is_temp TSRMLS_DC)
 		const_cast<char*>(cal->getType()));
 
 	{
-		zval		   ztz = zval_used_for_init,
+		zval		   ztz,
 					   ztz_debug;
 		int			   is_tmp;
 		HashTable	   *debug_info;