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)
{
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. */
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 )
{
*/
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;
}
/* }}} */
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
/* 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);
}
/* }}} */
/* }}} */
/* {{{ 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));
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;
}
/* }}} */
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",
}
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;
}
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))) {
}
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)) {
*/
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",
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()
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);
}
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;
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(¤cy_str, ¤cy_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 );
}
Returns part of a string */
PHP_FUNCTION(grapheme_substr)
{
- char *str, *sub_str;
+ char *str;
+ zend_string *u8_sub_str;
UChar *ustr;
size_t str_len;
int32_t ustr_len;
- size_t sub_str_len;
zend_long lstart = 0, length = 0;
int32_t start = 0;
int iter_val;
if ( grapheme_ascii_check((unsigned char *)str, str_len) >= 0 ) {
int32_t asub_str_len;
+ char *sub_str;
grapheme_substr_ascii(str, str_len, start, (int32_t)length, &sub_str, &asub_str_len);
if ( NULL == sub_str ) {
/* no length supplied or length is too big, return the rest of the string */
- sub_str = NULL;
- sub_str_len = 0;
status = U_ZERO_ERROR;
- intl_convert_utf16_to_utf8(&sub_str, &sub_str_len, ustr + sub_str_start_pos, ustr_len - sub_str_start_pos, &status);
+ u8_sub_str = intl_convert_utf16_to_utf8(ustr + sub_str_start_pos, ustr_len - sub_str_start_pos, &status);
if (ustr) {
efree( ustr );
}
ubrk_close( bi );
- if ( U_FAILURE( status ) ) {
+ if ( !u8_sub_str ) {
/* Set global error code. */
intl_error_set_code( NULL, status );
/* Set error messages. */
intl_error_set_custom_msg( NULL, "Error converting output string to UTF-8", 0 );
- if (sub_str) {
- efree( sub_str );
- }
-
RETURN_FALSE;
}
/* return the allocated string, not a duplicate */
- RETVAL_STRINGL(sub_str, sub_str_len);
- //???
- efree(sub_str);
+ RETVAL_NEW_STR(u8_sub_str);
return;
}
RETURN_FALSE;
}
- sub_str = NULL;
status = U_ZERO_ERROR;
- intl_convert_utf16_to_utf8(&sub_str, &sub_str_len, ustr + sub_str_start_pos, ( sub_str_end_pos - sub_str_start_pos ), &status);
+ u8_sub_str = intl_convert_utf16_to_utf8(ustr + sub_str_start_pos, ( sub_str_end_pos - sub_str_start_pos ), &status);
efree( ustr );
- if ( U_FAILURE( status ) ) {
+ if ( !u8_sub_str ) {
/* Set global error code. */
intl_error_set_code( NULL, status );
/* Set error messages. */
intl_error_set_custom_msg( NULL, "Error converting output string to UTF-8", 0 );
- if ( NULL != sub_str )
- efree( sub_str );
-
RETURN_FALSE;
}
/* return the allocated string, not a duplicate */
- RETVAL_STRINGL(sub_str, sub_str_len);
- //????
- efree(sub_str);
-
+ RETVAL_NEW_STR(u8_sub_str);
}
/* }}} */
UChar* ustring = NULL;
int ustring_len = 0;
UErrorCode status;
- char *converted_utf8;
- size_t converted_utf8_len;
+ zend_string *u8str;
UChar converted[MAXPATHLEN];
int32_t converted_ret_len;
}
status = U_ZERO_ERROR;
- intl_convert_utf16_to_utf8(&converted_utf8, &converted_utf8_len, converted, converted_ret_len, &status);
+ u8str = intl_convert_utf16_to_utf8(converted, converted_ret_len, &status);
- if (U_FAILURE(status)) {
+ if (!u8str) {
/* Set global error code. */
intl_error_set_code(NULL, status);
/* Set error messages. */
intl_error_set_custom_msg( NULL, "Error converting output string to UTF-8", 0 );
- efree(converted_utf8);
RETURN_FALSE;
}
}
/* return the allocated string, not a duplicate */
- RETVAL_STRINGL(converted_utf8, converted_utf8_len);
- //????
- efree(converted_utf8);
+ RETVAL_NEW_STR(u8str);
}
static void php_intl_idn_handoff(INTERNAL_FUNCTION_PARAMETERS, int mode)
/* {{{ intl_convert_utf16_to_utf8
* Convert given string from UTF-16 to UTF-8.
*
- * @param target Where to place the result.
- * @param target_len Result length.
* @param source String to convert.
* @param source_len Length of the source string.
* @param status Conversion status.
*
- * @return void This function does not return anything.
+ * @return zend_string
*/
-void intl_convert_utf16_to_utf8(
- char** target, size_t* target_len,
+zend_string* intl_convert_utf16_to_utf8(
const UChar* src, int32_t src_len,
UErrorCode* status )
{
- char* dst_buf = NULL;
- int32_t dst_len;
+ zend_string* dst;
+ int32_t dst_len;
/* Determine required destination buffer size (pre-flighting). */
*status = U_ZERO_ERROR;
* (U_STRING_NOT_TERMINATED_WARNING usually means that the input string is empty).
*/
if( *status != U_BUFFER_OVERFLOW_ERROR && *status != U_STRING_NOT_TERMINATED_WARNING )
- return;
+ return NULL;
/* Allocate memory for the destination buffer (it will be zero-terminated). */
- dst_buf = emalloc( dst_len+1 );
+ dst = zend_string_alloc(dst_len, 0);
/* Convert source string from UTF-8 to UTF-16. */
*status = U_ZERO_ERROR;
- u_strToUTF8( dst_buf, dst_len, NULL, src, src_len, status );
+ u_strToUTF8( ZSTR_VAL(dst), dst_len, NULL, src, src_len, status );
if( U_FAILURE( *status ) )
{
- efree( dst_buf );
- return;
+ zend_string_free(dst);
+ return NULL;
}
/* U_STRING_NOT_TERMINATED_WARNING is OK for us => reset 'status'. */
*status = U_ZERO_ERROR;
- dst_buf[dst_len] = 0;
- *target = dst_buf;
- *target_len = (size_t)dst_len;
+ ZSTR_VAL(dst)[dst_len] = 0;
+ return dst;
}
/* }}} */
const char* src, size_t src_len,
UErrorCode* status );
-void intl_convert_utf16_to_utf8(
- char** target, size_t* target_len,
+zend_string* intl_convert_utf16_to_utf8(
const UChar* src, int32_t src_len,
UErrorCode* status );
/* }}} */
/* {{{ intl_charFromString
- * faster than doing intl_convert_utf16_to_utf8(&res, &res_len,
+ * faster than doing intl_convert_utf16_to_utf8(
* from.getBuffer(), from.length(), &status),
* but consumes more memory */
-int intl_charFromString(const UnicodeString &from, char **res, size_t *res_len, UErrorCode *status)
+zend_string* intl_charFromString(const UnicodeString &from, UErrorCode *status)
{
+ zend_string *u8res;
+
if (from.isBogus()) {
- return FAILURE;
+ return NULL;
}
//the number of UTF-8 code units is not larger than that of UTF-16 code
- //units * 3 + 1 for the terminator
- int32_t capacity = from.length() * 3 + 1;
+ //units * 3
+ int32_t capacity = from.length() * 3;
if (from.isEmpty()) {
- *res = (char*)emalloc(1);
- **res = '\0';
- *res_len = 0;
- return SUCCESS;
+ return ZSTR_EMPTY_ALLOC();
}
- *res = (char*)emalloc(capacity);
- *res_len = 0; //tbd
+ u8res = zend_string_alloc(capacity, 0);
const UChar *utf16buf = from.getBuffer();
int32_t actual_len;
- u_strToUTF8WithSub(*res, capacity - 1, &actual_len, utf16buf, from.length(),
+ u_strToUTF8WithSub(ZSTR_VAL(u8res), capacity, &actual_len, utf16buf, from.length(),
U_SENTINEL, NULL, status);
if (U_FAILURE(*status)) {
- efree(*res);
- *res = NULL;
- return FAILURE;
+ zend_string_free(u8res);
+ return NULL;
}
- (*res)[actual_len] = '\0';
- *res_len = actual_len;
+ ZSTR_VAL(u8res)[actual_len] = '\0';
+ ZSTR_LEN(u8res) = actual_len;
- return SUCCESS;
+ return u8res;
}
/* }}} */
#error Should be included only in C++ Files
#endif
+#include <zend_types.h>
#include <unicode/unistr.h>
int intl_stringFromChar(UnicodeString &ret, char *str, size_t str_len, UErrorCode *status);
-int intl_charFromString(const UnicodeString &from, char **res, size_t *res_len, UErrorCode *status);
+zend_string* intl_charFromString(const UnicodeString &from, UErrorCode *status);
#endif /* INTL_CONVERTCPP_H */
#define INTL_METHOD_RETVAL_UTF8(obj, ustring, ulen, free_it) \
{ \
- char *u8value; \
- size_t u8len; \
- intl_convert_utf16_to_utf8(&u8value, &u8len, ustring, ulen, &INTL_DATA_ERROR_CODE((obj))); \
+ zend_string *u8str; \
+ u8str = intl_convert_utf16_to_utf8(ustring, ulen, &INTL_DATA_ERROR_CODE((obj))); \
if((free_it)) { \
efree(ustring); \
} \
INTL_METHOD_CHECK_STATUS((obj), "Error converting value to UTF-8"); \
- RETVAL_STRINGL(u8value, u8len); \
- efree(u8value); \
+ RETVAL_NEW_STR(u8str); \
}
#define INTL_MAX_LOCALE_LEN 80
smart_str intl_parse_error_to_string( UParseError* pe )
{
- smart_str ret = {0};
- char *buf;
- size_t u8len;
- UErrorCode status;
- int any = 0;
+ smart_str ret = {0};
+ zend_string *u8str;
+ UErrorCode status;
+ int any = 0;
assert( pe != NULL );
smart_str_appends( &ret, ", " );
smart_str_appends( &ret, "after \"" );
- intl_convert_utf16_to_utf8( &buf, &u8len, pe->preContext, -1, &status );
- if( U_FAILURE( status ) )
+ u8str = intl_convert_utf16_to_utf8(pe->preContext, -1, &status );
+ if( !u8str )
{
smart_str_appends( &ret, "(could not convert parser error pre-context to UTF-8)" );
}
else {
- smart_str_appendl( &ret, buf, u8len );
- efree( buf );
+ smart_str_append( &ret, u8str );
+ zend_string_release( u8str );
}
smart_str_appends( &ret, "\"" );
any = 1;
smart_str_appends( &ret, ", " );
smart_str_appends( &ret, "before or at \"" );
- intl_convert_utf16_to_utf8( &buf, &u8len, pe->postContext, -1, &status );
- if( U_FAILURE( status ) )
+ u8str = intl_convert_utf16_to_utf8(pe->postContext, -1, &status );
+ if( !u8str )
{
smart_str_appends( &ret, "(could not convert parser error post-context to UTF-8)" );
}
else
{
- smart_str_appendl( &ret, buf, u8len );
- efree( buf );
+ smart_str_append( &ret, u8str );
+ zend_string_release( u8str );
}
smart_str_appends( &ret, "\"" );
any = 1;
int32_t buflen = 512;
UErrorCode status = U_ZERO_ERROR;
- char* utf8value = NULL;
- size_t utf8value_len = 0;
+ zend_string* u8str;
char* msg = NULL;
int grOffset = 0;
disp_loc_name = NULL;
}
/* Convert display locale name from UTF-16 to UTF-8. */
- intl_convert_utf16_to_utf8( &utf8value, &utf8value_len, disp_name, buflen, &status );
+ u8str = intl_convert_utf16_to_utf8(disp_name, buflen, &status );
efree( disp_name );
- if( U_FAILURE( status ) )
+ if( !u8str )
{
spprintf(&msg, 0, "locale_get_display_%s :error converting display name for %s to UTF-8", tag_name , tag_name );
intl_error_set( NULL, status, msg , 1 );
RETURN_FALSE;
}
- RETVAL_STRINGL( utf8value, utf8value_len );
- //????
- efree(utf8value);
-
+ RETVAL_NEW_STR( u8str );
}
/* }}} */
ICU uloc.h #define ULOC_KEYWORD_AND_VALUES_CAPACITY 100
hence the kw_value buffer size is 100
*/
- char* kw_value = NULL;
- int32_t kw_value_len = 100;
+ zend_string *kw_value_str;
+ int32_t kw_value_len = 100;
intl_error_reset( NULL );
array_init( return_value );
while( ( kw_key = uenum_next( e, &kw_key_len, &status ) ) != NULL ){
- kw_value = ecalloc( 1 , kw_value_len );
+ kw_value_len = 100;
+ kw_value_str = zend_string_alloc(kw_value_len, 0);
/* Get the keyword value for each keyword */
- kw_value_len=uloc_getKeywordValue( loc_name,kw_key, kw_value, kw_value_len , &status );
+ kw_value_len=uloc_getKeywordValue( loc_name, kw_key, ZSTR_VAL(kw_value_str), kw_value_len, &status );
if (status == U_BUFFER_OVERFLOW_ERROR) {
status = U_ZERO_ERROR;
- kw_value = erealloc( kw_value , kw_value_len+1);
- kw_value_len=uloc_getKeywordValue( loc_name,kw_key, kw_value, kw_value_len+1 , &status );
+ kw_value_str = zend_string_extend(kw_value_str, kw_value_len, 0);
+ kw_value_len=uloc_getKeywordValue( loc_name,kw_key, ZSTR_VAL(kw_value_str), kw_value_len+1, &status );
} else if(!U_FAILURE(status)) {
- kw_value = erealloc( kw_value , kw_value_len+1);
+ kw_value_str = zend_string_truncate(kw_value_str, kw_value_len, 0);
}
if (U_FAILURE(status)) {
- intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "locale_get_keywords: Error encountered while getting the keyword value for the keyword", 0 );
- if( kw_value){
- efree( kw_value );
+ intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "locale_get_keywords: Error encountered while getting the keyword value for the keyword", 0 );
+ if( kw_value_str){
+ zend_string_free( kw_value_str );
}
zval_dtor(return_value);
RETURN_FALSE;
}
- // TODO: avoid reallocation ???
- add_assoc_stringl( return_value, (char *)kw_key, kw_value , kw_value_len);
- efree(kw_value);
+ add_assoc_str( return_value, (char *)kw_key, kw_value_str);
} /* end of while */
} /* end of if e!=NULL */
* returns the lookup result to lookup_loc_range_src_php
* internal function
*/
-static char* lookup_loc_range(const char* loc_range, HashTable* hash_arr, int canonicalize )
+static zend_string* lookup_loc_range(const char* loc_range, HashTable* hash_arr, int canonicalize )
{
int i = 0;
int cur_arr_len = 0;
char* can_loc_range = NULL;
int saved_pos = 0;
- char* return_value = NULL;
+ zend_string* return_value = NULL;
cur_arr = ecalloc(zend_hash_num_elements(hash_arr)*2, sizeof(char *));
ZEND_HASH_FOREACH_VAL(hash_arr, ele_value) {
for(i=0; i< cur_arr_len; i++){
if(cur_arr[i*2] != NULL && strlen(cur_arr[i*2]) == saved_pos && strncmp(cur_loc_range, cur_arr[i*2], saved_pos) == 0) {
/* Match found */
- return_value = estrdup(canonicalize?cur_arr[i*2]:cur_arr[i*2+1]);
+ char *str = canonicalize ? cur_arr[i*2] : cur_arr[i*2+1];
+ return_value = zend_string_init(str, strlen(str), 0);
efree(cur_loc_range);
LOOKUP_CLEAN_RETURN(return_value);
}
*/
PHP_FUNCTION(locale_lookup)
{
- char* fallback_loc = NULL;
- size_t fallback_loc_len = 0;
+ zend_string* fallback_loc_str = NULL;
const char* loc_range = NULL;
size_t loc_range_len = 0;
zval* arr = NULL;
HashTable* hash_arr = NULL;
zend_bool boolCanonical = 0;
- char* result =NULL;
+ zend_string* result_str = NULL;
intl_error_reset( NULL );
- if(zend_parse_parameters( ZEND_NUM_ARGS(), "as|bs", &arr, &loc_range, &loc_range_len,
- &boolCanonical, &fallback_loc, &fallback_loc_len) == FAILURE) {
+ if(zend_parse_parameters( ZEND_NUM_ARGS(), "as|bS", &arr, &loc_range, &loc_range_len,
+ &boolCanonical, &fallback_loc_str) == FAILURE) {
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "locale_lookup: unable to parse input params", 0 );
RETURN_FALSE;
}
RETURN_EMPTY_STRING();
}
- result = lookup_loc_range(loc_range, hash_arr, boolCanonical);
- if(result == NULL || result[0] == '\0') {
- if( fallback_loc ) {
- result = estrndup(fallback_loc, fallback_loc_len);
+ result_str = lookup_loc_range(loc_range, hash_arr, boolCanonical);
+ if(result_str == NULL || ZSTR_VAL(result_str)[0] == '\0') {
+ if( fallback_loc_str ) {
+ result_str = zend_string_copy(fallback_loc_str);
} else {
RETURN_EMPTY_STRING();
}
}
- RETVAL_STRINGL(result, strlen(result));
- //????
- efree(result);
+ RETURN_STR(result_str);
}
/* }}} */
{
double dd = intl_zval_to_millis(elem, &err, "msgfmt_format");
if (U_FAILURE(err.code)) {
- char *message, *key_char;
- size_t key_len;
+ char *message;
+ zend_string *u8key;
UErrorCode status = UErrorCode();
- if (intl_charFromString(key, &key_char, &key_len, &status) == SUCCESS) {
+ u8key = intl_charFromString(key, &status);
+ if (u8key) {
spprintf(&message, 0, "The argument for key '%s' "
- "cannot be used as a date or time", key_char);
+ "cannot be used as a date or time", ZSTR_VAL(u8key));
intl_errors_set(&err, err.code, message, 1);
- efree(key_char);
+ zend_string_release(u8key);
efree(message);
}
continue;
goto string_arg;
default:
{
- char *message, *key_char;
- size_t key_len;
+ char *message;
+ zend_string *u8key;
UErrorCode status = UErrorCode();
- if (intl_charFromString(key, &key_char, &key_len,
- &status) == SUCCESS) {
+ u8key = intl_charFromString(key, &status);
+ if (u8key) {
spprintf(&message, 0, "No strategy to convert the "
"value given for the argument with key '%s' "
- "is available", key_char);
+ "is available", ZSTR_VAL(u8key));
intl_errors_set(&err,
U_ILLEGAL_ARGUMENT_ERROR, message, 1);
- efree(key_char);
+ zend_string_release(u8key);
efree(message);
}
}
int64_t aInt64;
double aDate;
UnicodeString temp;
- char *stmp;
- size_t stmp_len;
+ zend_string *u8str;
switch(fargs[i].getType()) {
case Formattable::kDate:
case Formattable::kString:
fargs[i].getString(temp);
- intl_convert_utf16_to_utf8(&stmp, &stmp_len, temp.getBuffer(), temp.length(), status);
- if(U_FAILURE(*status)) {
+ u8str = intl_convert_utf16_to_utf8(temp.getBuffer(), temp.length(), status);
+ if(!u8str) {
cleanup_zvals();
return;
}
- ZVAL_STRINGL(&(*args)[i], stmp, stmp_len);
- //???
- efree(stmp);
+ ZVAL_NEW_STR(&(*args)[i], u8str);
break;
case Formattable::kObject:
UChar* uret_buf = NULL;
int32_t uret_len = 0;
- char* ret_buf = NULL;
- size_t ret_len = 0;
+ zend_string* u8str;
int32_t size_needed;
uret_len = size_needed;
/* Convert normalized string from UTF-16 to UTF-8. */
- intl_convert_utf16_to_utf8( &ret_buf, &ret_len, uret_buf, uret_len, &status );
+ u8str = intl_convert_utf16_to_utf8(uret_buf, uret_len, &status );
efree( uret_buf );
- if( U_FAILURE( status ) )
+ if( !u8str )
{
intl_error_set( NULL, status,
"normalizer_normalize: error converting normalized text UTF-8", 0 );
}
/* Return it. */
- RETVAL_STRINGL( ret_buf, ret_len );
- //???
- efree(ret_buf);
+ RETVAL_NEW_STR( u8str );
}
/* }}} */
//convert offset from milliseconds to minutes
tzobj->tzi.utc_offset = -1 * timeZone->getRawOffset() / (60 * 1000);
} else {
- char *str;
- size_t str_len;
+ zend_string *u8str;
/* Call the constructor! */
- if (intl_charFromString(id, &str, &str_len, &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);
goto error;
}
- ZVAL_STRINGL(&arg, str, str_len);
- //???
- efree(str);
+ ZVAL_STR(&arg, u8str);
zend_call_method_with_1_params(ret, NULL, NULL, "__construct", NULL, &arg);
if (EG(exception)) {
spprintf(&message, 0,
TimeZone_object *to;
const TimeZone *tz;
UnicodeString ustr;
- char *str;
- size_t str_len;
+ zend_string *u8str;
HashTable *debug_info;
UErrorCode uec = U_ZERO_ERROR;
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)) {
+ if (!u8str) {
return debug_info;
}
- ZVAL_STRINGL(&zv, str, str_len);
+ ZVAL_NEW_STR(&zv, u8str);
zend_hash_str_update(debug_info, "id", sizeof("id") - 1, &zv);
- // TODO: avoid reallocation ???
- efree(str);
int32_t rawOffset, dstOffset;
UDate now = Calendar::getNow();
TimeZone::getCanonicalID(id, result, isSystemID, status);
INTL_CHECK_STATUS(status, "intltz_get_canonical_id: error obtaining canonical ID");
- char *str;
- size_t str_len;
- intl_convert_utf16_to_utf8(&str, &str_len, result.getBuffer(), result.length(), &status);
+ zend_string *u8str =intl_convert_utf16_to_utf8(result.getBuffer(), result.length(), &status);
INTL_CHECK_STATUS(status,
"intltz_get_canonical_id: could not convert time zone id to UTF-16");
- RETVAL_STRINGL(str, str_len);
- //????
- efree(str);
+ RETVAL_NEW_STR(u8str);
if (is_systemid) { /* by-ref argument passed */
ZVAL_DEREF(is_systemid);
}
const UnicodeString result = TimeZone::getEquivalentID(id, (int32_t)index);
- char *str;
- size_t str_len;
+ zend_string *u8str;
- intl_convert_utf16_to_utf8(&str, &str_len, result.getBuffer(), result.length(), &status);
+ u8str = intl_convert_utf16_to_utf8(result.getBuffer(), result.length(), &status);
INTL_CHECK_STATUS(status, "intltz_get_equivalent_id: "
"could not convert resulting time zone id to UTF-16");
- RETVAL_STRINGL(str, str_len);
- //????
- efree(str);
+ RETVAL_NEW_STR(u8str);
}
U_CFUNC PHP_FUNCTION(intltz_get_id)
UnicodeString id_us;
to->utimezone->getID(id_us);
- char *id = NULL;
- size_t id_len = 0;
+ zend_string *u8str;
- intl_convert_utf16_to_utf8(&id, &id_len,
+ u8str = intl_convert_utf16_to_utf8(
id_us.getBuffer(), id_us.length(), TIMEZONE_ERROR_CODE_P(to));
INTL_METHOD_CHECK_STATUS(to, "intltz_get_id: Could not convert id to UTF-8");
- RETVAL_STRINGL(id, id_len);
- //???
- efree(id);
+ RETVAL_NEW_STR(u8str);
}
U_CFUNC PHP_FUNCTION(intltz_use_daylight_time)
to->utimezone->getDisplayName((UBool)daylight, (TimeZone::EDisplayType)display_type,
Locale::createFromName(locale_str), result);
- char *str;
- size_t str_len;
- intl_convert_utf16_to_utf8(&str, &str_len, result.getBuffer(), result.length(), TIMEZONE_ERROR_CODE_P(to));
+ zend_string *u8str = intl_convert_utf16_to_utf8(result.getBuffer(), result.length(), TIMEZONE_ERROR_CODE_P(to));
INTL_METHOD_CHECK_STATUS(to, "intltz_get_display_name: "
"could not convert resulting time zone id to UTF-16");
- RETVAL_STRINGL(str, str_len);
- //????
- efree(str);
+ RETVAL_NEW_STR(u8str);
}
U_CFUNC PHP_FUNCTION(intltz_get_dst_savings)
{
const UChar *ustr_id;
int32_t ustr_id_len;
- char *str_id;
- size_t str_id_len;
+ zend_string *u8str;
+ zval tmp;
Transliterator_object *to;
TRANSLITERATOR_METHOD_FETCH_OBJECT_NO_CHECK;
to->utrans = utrans;
ustr_id = utrans_getUnicodeID( utrans, &ustr_id_len );
- intl_convert_utf16_to_utf8( &str_id, &str_id_len, ustr_id, (int ) ustr_id_len, status );
- if( U_FAILURE( *status ) )
+ u8str = intl_convert_utf16_to_utf8(ustr_id, (int ) ustr_id_len, status );
+ if( !u8str )
{
return FAILURE;
}
- zend_update_property_stringl(Transliterator_ce_ptr, object,
- "id", sizeof( "id" ) - 1, str_id, str_id_len );
- efree( str_id );
+ ZVAL_NEW_STR(&tmp, u8str);
+ zend_update_property(Transliterator_ce_ptr, object,
+ "id", sizeof( "id" ) - 1, &tmp );
+ GC_REFCOUNT(u8str)--;
return SUCCESS;
}
/* }}} */
array_init( return_value );
while( (elem = uenum_unext( en, &elem_len, &status )) )
{
- char *el_char = NULL;
- size_t el_len = 0;
+ zend_string *el = intl_convert_utf16_to_utf8(elem, elem_len, &status );
- intl_convert_utf16_to_utf8( &el_char, &el_len, elem, elem_len, &status );
-
- if( U_FAILURE( status ) )
+ if( !el )
{
- efree( el_char );
break;
}
else
{
- // TODO: avoid reallocation ???
- add_next_index_stringl( return_value, el_char, el_len);
- efree(el_char);
+ add_next_index_str( return_value, el);
}
}
uenum_close( en );
UChar32 cp;
zval *zcp;
UChar *closure;
- char *ret;
+ zend_string *u8str;
int32_t closure_len;
- size_t ret_len;
UErrorCode error = U_ZERO_ERROR;
if ((zend_parse_parameters(ZEND_NUM_ARGS(), "z", &zcp) == FAILURE) ||
}
error = U_ZERO_ERROR;
- intl_convert_utf16_to_utf8(&ret, &ret_len, closure, closure_len, &error);
+ u8str = intl_convert_utf16_to_utf8(closure, closure_len, &error);
efree(closure);
INTL_CHECK_STATUS(error, "Failed converting output to UTF8");
- RETVAL_STRINGL(ret, ret_len);
- efree(ret);
+ RETVAL_NEW_STR(u8str);
}
/* }}} */
projects / php / commitdiff