Cleanup (avoid string reallocations)

Author: dstogov

Diff for: ext/intl/breakiterator/rulebasedbreakiterator_methods.cpp

@@ -114,20 +114,18 @@ U_CFUNC PHP_FUNCTION(rbbi_get_rules)
 
 	BREAKITER_METHOD_FETCH_OBJECT;
 
-	char *str;
-	size_t str_len;
+	zend_string *u8str;
 	const UnicodeString rules = fetch_rbbi(bio)->getRules();
 
-	if (intl_charFromString(rules, &str, &str_len, BREAKITER_ERROR_CODE_P(bio)) == FAILURE)
+	u8str = intl_charFromString(rules, BREAKITER_ERROR_CODE_P(bio));
+	if (!u8str)
 	{
 		intl_errors_set(BREAKITER_ERROR_P(bio), BREAKITER_ERROR_CODE(bio),
 				"rbbi_hash_code: Error converting result to UTF-8 string",
 				0);
 		RETURN_FALSE;
 	}
-	RETVAL_STRINGL(str, str_len);
-	//???
-	efree(str);
+	RETVAL_STR(u8str);
 }
 
 U_CFUNC PHP_FUNCTION(rbbi_get_rule_status)

Diff for: ext/intl/collator/collator_convert.c

@@ -87,8 +87,7 @@ static void collator_convert_hash_item_from_utf16_to_utf8(
 {
 	const char* old_val;
 	size_t      old_val_len;
-	char*       new_val      = NULL;
-	size_t      new_val_len  = 0;
+	zend_string* u8str;
 	zval        znew_val;
 
 	/* Process string values only. */
@@ -99,15 +98,13 @@ static void collator_convert_hash_item_from_utf16_to_utf8(
 	old_val_len = Z_STRLEN_P( hashData );
 
 	/* Convert it from UTF-16LE to UTF-8 and save the result to new_val[_len]. */
-	intl_convert_utf16_to_utf8( &new_val, &new_val_len,
+	u8str = intl_convert_utf16_to_utf8(
 		(UChar*)old_val, UCHARS(old_val_len), status );
-	if( U_FAILURE( *status ) )
+	if( !u8str )
 		return;
 
 	/* Update current hash item with the converted value. */
-	ZVAL_STRINGL( &znew_val, new_val, new_val_len);
-	//???
-	efree(new_val);
+	ZVAL_NEW_STR( &znew_val, u8str);
 
 	if( hashKey )
 	{
@@ -169,23 +166,19 @@ void collator_convert_hash_from_utf16_to_utf8( HashTable* hash, UErrorCode* stat
  */
 zval* collator_convert_zstr_utf16_to_utf8( zval* utf16_zval, zval *rv )
 {
-	zval* utf8_zval   = NULL;
-	char* str         = NULL;
-	size_t str_len    = 0;
+	zend_string* u8str;
 	UErrorCode status = U_ZERO_ERROR;
 
 	/* Convert to utf8 then. */
-	intl_convert_utf16_to_utf8( &str, &str_len,
+	u8str = intl_convert_utf16_to_utf8(
 		(UChar*) Z_STRVAL_P(utf16_zval), UCHARS( Z_STRLEN_P(utf16_zval) ), &status );
-	if( U_FAILURE( status ) )
+	if( !u8str ) {
 		php_error( E_WARNING, "Error converting utf16 to utf8 in collator_convert_zval_utf16_to_utf8()" );
-
-	utf8_zval = rv;
-	ZVAL_STRINGL( utf8_zval, str, str_len);
-	//???
-	efree(str);
-
-	return utf8_zval;
+		ZVAL_EMPTY_STRING( rv );
+	} else {
+		ZVAL_NEW_STR( rv, u8str );
+	}
+	return rv;
 }
 /* }}} */
 

Diff for: ext/intl/collator/collator_sort.c

@@ -549,8 +549,8 @@ PHP_FUNCTION( collator_get_sort_key )
 	size_t           str_len  = 0;
 	UChar*           ustr     = NULL;
 	int32_t          ustr_len = 0;
-	uint8_t*         key     = NULL;
 	int              key_len = 0;
+	zend_string*     key_str;
 
 	COLLATOR_METHOD_INIT_VARS
 
@@ -597,20 +597,19 @@ PHP_FUNCTION( collator_get_sort_key )
 
 	/* ucol_getSortKey is exception in that the key length includes the
 	 * NUL terminator*/
-	key_len = ucol_getSortKey(co->ucoll, ustr, ustr_len, key, 0);
+	key_len = ucol_getSortKey(co->ucoll, ustr, ustr_len, NULL, 0);
 	if(!key_len) {
 		efree( ustr );
 		RETURN_FALSE;
 	}
-	key = emalloc(key_len);
-	key_len = ucol_getSortKey(co->ucoll, ustr, ustr_len, key, key_len);
+	key_str = zend_string_alloc(key_len, 0);
+	key_len = ucol_getSortKey(co->ucoll, ustr, ustr_len, (uint8_t*)ZSTR_VAL(key_str), key_len);
 	efree( ustr );
 	if(!key_len) {
 		RETURN_FALSE;
 	}
-	RETVAL_STRINGL((char *)key, key_len - 1);
-	//????
-	efree(key);
+	ZSTR_LEN(key_str) = key_len - 1;
+	RETVAL_NEW_STR(key_str);
 }
 /* }}} */
 

Diff for: ext/intl/converter/converter.c

@@ -652,27 +652,26 @@ static PHP_METHOD(UConverter, getSubstChars) {
 /* }}} */
 
 /* {{{ php_converter_do_convert */
-static zend_bool php_converter_do_convert(UConverter *dest_cnv, char **pdest, int32_t *pdest_len,
-                                          UConverter *src_cnv,  const char *src, int32_t src_len,
-                                          php_converter_object *objval
-                                         ) {
+static zend_string* php_converter_do_convert(UConverter *dest_cnv,
+                                             UConverter *src_cnv,  const char *src, int32_t src_len,
+                                             php_converter_object *objval
+                                            ) {
 	UErrorCode	error = U_ZERO_ERROR;
-	int32_t		dest_len,
-				temp_len;
-	char		*dest;
+	int32_t		temp_len, ret_len;
+	zend_string	*ret;
 	UChar		*temp;
 
 	if (!src_cnv || !dest_cnv) {
 		php_converter_throw_failure(objval, U_INVALID_STATE_ERROR,
 		                            "Internal converters not initialized");
-		return 0;
+		return NULL;
 	}
 
 	/* Get necessary buffer size first */
 	temp_len = 1 + ucnv_toUChars(src_cnv, NULL, 0, src, src_len, &error);
 	if (U_FAILURE(error) && error != U_BUFFER_OVERFLOW_ERROR) {
 		THROW_UFAILURE(objval, "ucnv_toUChars", error);
-		return 0;
+		return NULL;
 	}
 	temp = safe_emalloc(sizeof(UChar), temp_len, sizeof(UChar));
 
@@ -682,36 +681,31 @@ static zend_bool php_converter_do_convert(UConverter *dest_cnv, char **pdest, in
 	if (U_FAILURE(error)) {
 		THROW_UFAILURE(objval, "ucnv_toUChars", error);
 		efree(temp);
-		return 0;
+		return NULL;
 	}
 	temp[temp_len] = 0;
 
 	/* Get necessary output buffer size */
-	dest_len = 1 + ucnv_fromUChars(dest_cnv, NULL, 0, temp, temp_len, &error);
+	ret_len = ucnv_fromUChars(dest_cnv, NULL, 0, temp, temp_len, &error);
 	if (U_FAILURE(error) && error != U_BUFFER_OVERFLOW_ERROR) {
 		THROW_UFAILURE(objval, "ucnv_fromUChars", error);
 		efree(temp);
-		return 0;
+		return NULL;
 	}
 
-	dest = safe_emalloc(sizeof(char), dest_len, sizeof(char));
+	ret = zend_string_alloc(ret_len, 0);
 
 	/* Convert to final encoding */
 	error = U_ZERO_ERROR;
-	dest_len = ucnv_fromUChars(dest_cnv, dest, dest_len, temp, temp_len, &error);
+	ZSTR_LEN(ret) = ucnv_fromUChars(dest_cnv, ZSTR_VAL(ret), ret_len+1, temp, temp_len, &error);
 	efree(temp);
 	if (U_FAILURE(error)) {
 		THROW_UFAILURE(objval, "ucnv_fromUChars", error);
-		efree(dest);
-		return 0;
+		zend_string_free(ret);
+		return NULL;
 	}
 
-	*pdest = dest;
-	if (pdest_len) {
-		*pdest_len = dest_len;
-	}
-
-	return 1;
+	return ret;
 }
 /* }}} */
 
@@ -752,9 +746,9 @@ ZEND_END_ARG_INFO();
 
 static PHP_METHOD(UConverter, convert) {
         php_converter_object *objval = CONV_GET(getThis());
-	char *str, *dest;
+	char *str;
 	size_t str_len;
-	int32_t dest_len;
+	zend_string *ret;
 	zend_bool reverse = 0;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|b",
@@ -765,15 +759,12 @@ static PHP_METHOD(UConverter, convert) {
 	}
 	intl_errors_reset(&objval->error);
 
-	if (php_converter_do_convert(reverse ? objval->src : objval->dest,
-	                             &dest, &dest_len,
-                                 reverse ? objval->dest : objval->src,
-	                             str,   str_len,
-	                             objval)) {
-		RETVAL_STRINGL(dest, dest_len);
-		//???
-		efree(dest);
-		return;
+	ret = php_converter_do_convert(reverse ? objval->src : objval->dest,
+	                               reverse ? objval->dest : objval->src,
+	                               str,   str_len,
+	                               objval);
+	if (ret) {
+		RETURN_NEW_STR(ret);
 	} else {
 		RETURN_FALSE;
 	}
@@ -804,8 +795,7 @@ static PHP_METHOD(UConverter, transcode) {
 
 	if (php_converter_set_encoding(NULL, &src_cnv,  src,  src_len) &&
 	    php_converter_set_encoding(NULL, &dest_cnv, dest, dest_len)) {
-		char *out = NULL;
-		int out_len = 0;
+	    zend_string *ret;
 		UErrorCode error = U_ZERO_ERROR;
 
 		if (options && zend_hash_num_elements(Z_ARRVAL_P(options))) {
@@ -826,11 +816,8 @@ static PHP_METHOD(UConverter, transcode) {
 		}
 
 		if (U_SUCCESS(error) &&
-			php_converter_do_convert(dest_cnv, &out, &out_len, src_cnv, str, str_len, NULL)) {
-			RETVAL_STRINGL(out, out_len);
-			//???
-			efree(out);
-			return;
+			(ret = php_converter_do_convert(dest_cnv, src_cnv, str, str_len, NULL)) != NULL) {
+			RETURN_NEW_STR(ret);
 		}
 
 		if (U_FAILURE(error)) {

Diff for: ext/intl/dateformat/dateformat_attrcpp.cpp

@@ -44,8 +44,7 @@ static inline DateFormat *fetch_datefmt(IntlDateFormatter_object *dfo) {
  */
 U_CFUNC PHP_FUNCTION(datefmt_get_timezone_id)
 {
-	char *str;
-	size_t str_len;
+	zend_string *u8str;
 	DATE_FORMAT_METHOD_INIT_VARS;
 
 	if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "O",
@@ -59,12 +58,10 @@ U_CFUNC PHP_FUNCTION(datefmt_get_timezone_id)
 
 	UnicodeString res = UnicodeString();
 	fetch_datefmt(dfo)->getTimeZone().getID(res);
-	intl_charFromString(res, &str, &str_len, &INTL_DATA_ERROR_CODE(dfo));
+	u8str = intl_charFromString(res, &INTL_DATA_ERROR_CODE(dfo));
 	INTL_METHOD_CHECK_STATUS(dfo, "Could not convert time zone id to UTF-8");
 
-	RETVAL_STRINGL(str, str_len);
-	//????
-	efree(str);
+	RETVAL_STR(u8str);
 }
 
 /* {{{ proto IntlTimeZone IntlDateFormatter::getTimeZone()

Diff for: ext/intl/dateformat/dateformat_format_object.cpp

@@ -221,21 +221,19 @@ U_CFUNC PHP_FUNCTION(datefmt_format_object)
 	timeZone = NULL;
 
 	{
-		char *ret_str;
-		size_t ret_str_len;
+		zend_string *u8str;
 		UnicodeString result = UnicodeString();
 		df->format(date, result);
 
-		if (intl_charFromString(result, &ret_str, &ret_str_len, &status) == FAILURE) {
+		u8str = intl_charFromString(result, &status);
+		if (!u8str) {
 			intl_error_set(NULL, status,
 					"datefmt_format_object: error converting result to UTF-8",
 					0);
 			RETVAL_FALSE;
 			goto cleanup;
 		}
-		RETVAL_STRINGL(ret_str, ret_str_len);
-		//???
-		efree(ret_str);
+		RETVAL_STR(u8str);
 	}
 
 

Diff for: ext/intl/formatter/formatter_parse.c

@@ -129,8 +129,7 @@ PHP_FUNCTION( numfmt_parse_currency )
 	UChar currency[5] = {0};
 	UChar* sstr = NULL;
 	int32_t sstr_len = 0;
-	char *currency_str = NULL;
-	size_t currency_len = 0;
+	zend_string *u8str;
 	char *str;
 	size_t str_len;
 	int32_t* position_p = NULL;
@@ -173,12 +172,10 @@ PHP_FUNCTION( numfmt_parse_currency )
 	INTL_METHOD_CHECK_STATUS( nfo, "Number parsing failed" );
 
 	/* Convert parsed currency to UTF-8 and pass it back to caller. */
-	intl_convert_utf16_to_utf8(&currency_str, &currency_len, currency, u_strlen(currency), &INTL_DATA_ERROR_CODE(nfo));
+	u8str = intl_convert_utf16_to_utf8(currency, u_strlen(currency), &INTL_DATA_ERROR_CODE(nfo));
 	INTL_METHOD_CHECK_STATUS( nfo, "Currency conversion to UTF-8 failed" );
 	zval_dtor( zcurrency );
-	ZVAL_STRINGL(zcurrency, currency_str, currency_len);
-	//????
-	efree(currency_str);
+	ZVAL_NEW_STR(zcurrency, u8str);
 
 	RETVAL_DOUBLE( number );
 }