mirror of
https://github.com/php/php-src.git
synced 2025-08-15 13:38:49 +02:00
b8fa1657ff
Introduces intl_convert_utf8_to_utf16_zstr() to convert a UTF-8 string to a UTF-16 string zend_string* instance. This way we avoid a double copy later from a UChar* into a zend_string*.
376 lines
9.7 KiB
C
376 lines
9.7 KiB
C
/*
|
|
+----------------------------------------------------------------------+
|
|
| 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 |
|
|
| available through the world-wide-web at the following url: |
|
|
| https://www.php.net/license/3_01.txt |
|
|
| If you did not receive a copy of the PHP license and are unable to |
|
|
| obtain it through the world-wide-web, please send a note to |
|
|
| license@php.net so we can mail you a copy immediately. |
|
|
+----------------------------------------------------------------------+
|
|
| Authors: Vadim Savchuk <vsavchuk@productengine.com> |
|
|
| Dmitry Lakhtyuk <dlakhtyuk@productengine.com> |
|
|
+----------------------------------------------------------------------+
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif
|
|
|
|
#include "php_intl.h"
|
|
#include "collator_class.h"
|
|
#include "collator_is_numeric.h"
|
|
#include "collator_convert.h"
|
|
#include "intl_convert.h"
|
|
|
|
#include <unicode/ustring.h>
|
|
#include <php.h>
|
|
|
|
#define COLLATOR_CONVERT_RETURN_FAILED(retval) { \
|
|
Z_TRY_ADDREF_P(retval); \
|
|
return retval; \
|
|
}
|
|
|
|
/* {{{ collator_convert_hash_item_from_utf8_to_utf16 */
|
|
static void collator_convert_hash_item_from_utf8_to_utf16(
|
|
HashTable* hash, zval *hashData, zend_string *hashKey, zend_ulong hashIndex,
|
|
UErrorCode* status )
|
|
{
|
|
const char* old_val;
|
|
size_t old_val_len;
|
|
zval znew_val;
|
|
|
|
/* Process string values only. */
|
|
if( Z_TYPE_P( hashData ) != IS_STRING )
|
|
return;
|
|
|
|
old_val = Z_STRVAL_P( hashData );
|
|
old_val_len = Z_STRLEN_P( hashData );
|
|
|
|
/* Convert it from UTF-8 to UTF-16LE. */
|
|
zend_string *zstr = intl_convert_utf8_to_utf16_zstr( old_val, old_val_len, status );
|
|
if( U_FAILURE( *status ) )
|
|
return;
|
|
|
|
/* Update current hash item with the converted value. */
|
|
ZVAL_NEW_STR( &znew_val, zstr );
|
|
|
|
if( hashKey)
|
|
{
|
|
zend_hash_update( hash, hashKey, &znew_val);
|
|
}
|
|
else /* hashKeyType == HASH_KEY_IS_LONG */
|
|
{
|
|
zend_hash_index_update( hash, hashIndex, &znew_val);
|
|
}
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ collator_convert_hash_item_from_utf16_to_utf8 */
|
|
static void collator_convert_hash_item_from_utf16_to_utf8(
|
|
HashTable* hash, zval * hashData, zend_string* hashKey, zend_ulong hashIndex,
|
|
UErrorCode* status )
|
|
{
|
|
const char* old_val;
|
|
size_t old_val_len;
|
|
zend_string* u8str;
|
|
zval znew_val;
|
|
|
|
/* Process string values only. */
|
|
if( Z_TYPE_P( hashData ) != IS_STRING )
|
|
return;
|
|
|
|
old_val = Z_STRVAL_P( hashData );
|
|
old_val_len = Z_STRLEN_P( hashData );
|
|
|
|
/* Convert it from UTF-16LE to UTF-8 and save the result to new_val[_len]. */
|
|
u8str = intl_convert_utf16_to_utf8(
|
|
(UChar*)old_val, UCHARS(old_val_len), status );
|
|
if( !u8str )
|
|
return;
|
|
|
|
/* Update current hash item with the converted value. */
|
|
ZVAL_NEW_STR( &znew_val, u8str);
|
|
|
|
if( hashKey )
|
|
{
|
|
zend_hash_update( hash, hashKey, &znew_val);
|
|
}
|
|
else /* hashKeyType == HASH_KEY_IS_LONG */
|
|
{
|
|
zend_hash_index_update( hash, hashIndex, &znew_val);
|
|
}
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ collator_convert_hash_from_utf8_to_utf16
|
|
* Convert values of the given hash from UTF-8 encoding to UTF-16LE.
|
|
*/
|
|
void collator_convert_hash_from_utf8_to_utf16( HashTable* hash, UErrorCode* status )
|
|
{
|
|
zend_ulong hashIndex;
|
|
zval *hashData;
|
|
zend_string *hashKey;
|
|
|
|
ZEND_HASH_FOREACH_KEY_VAL(hash, hashIndex, hashKey, hashData) {
|
|
/* Convert current hash item from UTF-8 to UTF-16LE. */
|
|
collator_convert_hash_item_from_utf8_to_utf16(
|
|
hash, hashData, hashKey, hashIndex, status );
|
|
if( U_FAILURE( *status ) )
|
|
return;
|
|
} ZEND_HASH_FOREACH_END();
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ collator_convert_hash_from_utf16_to_utf8
|
|
* Convert values of the given hash from UTF-16LE encoding to UTF-8.
|
|
*/
|
|
void collator_convert_hash_from_utf16_to_utf8( HashTable* hash, UErrorCode* status )
|
|
{
|
|
zend_ulong hashIndex;
|
|
zend_string *hashKey;
|
|
zval *hashData;
|
|
|
|
ZEND_HASH_FOREACH_KEY_VAL(hash, hashIndex, hashKey, hashData) {
|
|
/* Convert current hash item from UTF-16LE to UTF-8. */
|
|
collator_convert_hash_item_from_utf16_to_utf8(
|
|
hash, hashData, hashKey, hashIndex, status );
|
|
if( U_FAILURE( *status ) ) {
|
|
return;
|
|
}
|
|
} ZEND_HASH_FOREACH_END();
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ collator_convert_zstr_utf16_to_utf8
|
|
*
|
|
* Convert string from utf16 to utf8.
|
|
*
|
|
* @param zval* utf16_zval String to convert.
|
|
*
|
|
* @return zval* Converted string.
|
|
*/
|
|
zval* collator_convert_zstr_utf16_to_utf8( zval* utf16_zval, zval *rv )
|
|
{
|
|
zend_string* u8str;
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
|
|
/* Convert to utf8 then. */
|
|
u8str = intl_convert_utf16_to_utf8(
|
|
(UChar*) Z_STRVAL_P(utf16_zval), UCHARS( Z_STRLEN_P(utf16_zval) ), &status );
|
|
if( !u8str ) {
|
|
php_error( E_WARNING, "Error converting utf16 to utf8 in collator_convert_zval_utf16_to_utf8()" );
|
|
ZVAL_EMPTY_STRING( rv );
|
|
} else {
|
|
ZVAL_NEW_STR( rv, u8str );
|
|
}
|
|
return rv;
|
|
}
|
|
/* }}} */
|
|
|
|
zend_string *collator_convert_zstr_utf8_to_utf16(zend_string *utf8_str)
|
|
{
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
|
|
/* Convert the string to UTF-16. */
|
|
zend_string *zstr = intl_convert_utf8_to_utf16_zstr(
|
|
ZSTR_VAL(utf8_str), ZSTR_LEN(utf8_str),
|
|
&status);
|
|
// FIXME Or throw error or use intl internal error handler
|
|
if (U_FAILURE(status)) {
|
|
php_error(E_WARNING,
|
|
"Error casting object to string in collator_convert_zstr_utf8_to_utf16()");
|
|
zstr = ZSTR_EMPTY_ALLOC();
|
|
}
|
|
|
|
return zstr;
|
|
}
|
|
|
|
/* {{{ collator_convert_object_to_string
|
|
* Convert object to UTF16-encoded string.
|
|
*/
|
|
zval* collator_convert_object_to_string( zval* obj, zval *rv )
|
|
{
|
|
zval* zstr = NULL;
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
|
|
/* Bail out if it's not an object. */
|
|
if( Z_TYPE_P( obj ) != IS_OBJECT )
|
|
{
|
|
COLLATOR_CONVERT_RETURN_FAILED( obj );
|
|
}
|
|
|
|
/* Try object's handlers. */
|
|
zstr = rv;
|
|
|
|
if( Z_OBJ_HT_P(obj)->cast_object( Z_OBJ_P(obj), zstr, IS_STRING ) == FAILURE )
|
|
{
|
|
/* cast_object failed => bail out. */
|
|
zval_ptr_dtor( zstr );
|
|
COLLATOR_CONVERT_RETURN_FAILED( obj );
|
|
}
|
|
|
|
/* Object wasn't successfully converted => bail out. */
|
|
if( zstr == NULL )
|
|
{
|
|
COLLATOR_CONVERT_RETURN_FAILED( obj );
|
|
}
|
|
|
|
/* Convert the string to UTF-16. */
|
|
zend_string *converted_str = intl_convert_utf8_to_utf16_zstr(
|
|
Z_STRVAL_P( zstr ), Z_STRLEN_P( zstr ),
|
|
&status );
|
|
// FIXME Or throw error or use intl internal error handler
|
|
if( U_FAILURE( status ) ) {
|
|
php_error( E_WARNING, "Error casting object to string in collator_convert_object_to_string()" );
|
|
converted_str = ZSTR_EMPTY_ALLOC();
|
|
}
|
|
|
|
/* Cleanup zstr to hold utf16 string. */
|
|
zval_ptr_dtor_str( zstr );
|
|
|
|
/* Set string. */
|
|
ZVAL_STR( zstr, converted_str );
|
|
|
|
return zstr;
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ collator_convert_string_to_number
|
|
*
|
|
* Convert string to number.
|
|
*
|
|
* @param zval* str String to convert.
|
|
*
|
|
* @return zval* Number. If str is not numeric string return number zero.
|
|
*/
|
|
zval* collator_convert_string_to_number( zval* str, zval *rv )
|
|
{
|
|
zval* num = collator_convert_string_to_number_if_possible( str, rv );
|
|
if( num == str )
|
|
{
|
|
/* String wasn't converted => return zero. */
|
|
zval_ptr_dtor( num );
|
|
|
|
num = rv;
|
|
ZVAL_LONG( num, 0 );
|
|
}
|
|
|
|
return num;
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ collator_convert_string_to_double
|
|
*
|
|
* Convert string to double.
|
|
*
|
|
* @param zval* str String to convert.
|
|
*
|
|
* @return zval* Number. If str is not numeric string return number zero.
|
|
*/
|
|
zval* collator_convert_string_to_double( zval* str, zval *rv )
|
|
{
|
|
zval* num = collator_convert_string_to_number( str, rv );
|
|
if( Z_TYPE_P(num) == IS_LONG )
|
|
{
|
|
ZVAL_DOUBLE( num, Z_LVAL_P( num ) );
|
|
}
|
|
|
|
return num;
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ collator_convert_string_to_number_if_possible
|
|
*
|
|
* Convert string to numer.
|
|
*
|
|
* @param zval* str String to convert.
|
|
*
|
|
* @return zval* Number if str is numeric string. Otherwise
|
|
* original str param.
|
|
*/
|
|
zval* collator_convert_string_to_number_if_possible( zval* str, zval *rv )
|
|
{
|
|
uint8_t is_numeric = 0;
|
|
zend_long lval = 0;
|
|
double dval = 0;
|
|
|
|
if( Z_TYPE_P( str ) != IS_STRING )
|
|
{
|
|
COLLATOR_CONVERT_RETURN_FAILED( str );
|
|
}
|
|
|
|
if ( ( is_numeric = collator_is_numeric( (UChar*) Z_STRVAL_P(str), UCHARS( Z_STRLEN_P(str) ), &lval, &dval, /* allow_errors */ false ) ) )
|
|
{
|
|
if( is_numeric == IS_LONG ) {
|
|
ZVAL_LONG(rv, lval);
|
|
}
|
|
if( is_numeric == IS_DOUBLE )
|
|
ZVAL_DOUBLE(rv, dval);
|
|
}
|
|
else
|
|
{
|
|
COLLATOR_CONVERT_RETURN_FAILED( str );
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
/* }}} */
|
|
|
|
/* Returns string from input zval.
|
|
*
|
|
* @param zval* arg zval to get string from
|
|
*
|
|
* @return zend_string* UTF16 string.
|
|
*/
|
|
zend_string *collator_zval_to_string(zval *arg)
|
|
{
|
|
// TODO: This is extremely weird in that it leaves pre-existing strings alone and does not
|
|
// perform a UTF-8 to UTF-16 conversion for them. The assumption is that values that are
|
|
// already strings have already been converted beforehand. It would be good to clean this up.
|
|
if (Z_TYPE_P(arg) == IS_STRING) {
|
|
return zend_string_copy(Z_STR_P(arg));
|
|
}
|
|
|
|
zend_string *utf8_str = zval_get_string(arg);
|
|
zend_string *utf16_str = collator_convert_zstr_utf8_to_utf16(utf8_str);
|
|
zend_string_release(utf8_str);
|
|
return utf16_str;
|
|
}
|
|
|
|
/* {{{ collator_normalize_sort_argument
|
|
*
|
|
* Normalize argument to use in sort's compare function.
|
|
*
|
|
* @param zval* arg Sort's argument to normalize.
|
|
*
|
|
* @return zval* Normalized copy of arg or unmodified arg
|
|
* if normalization is not needed.
|
|
*/
|
|
zval* collator_normalize_sort_argument( zval* arg, zval *rv )
|
|
{
|
|
zval* n_arg = NULL;
|
|
|
|
if( Z_TYPE_P( arg ) != IS_STRING )
|
|
{
|
|
/* If it's not a string then nothing to do.
|
|
* Return original arg.
|
|
*/
|
|
COLLATOR_CONVERT_RETURN_FAILED( arg );
|
|
}
|
|
|
|
/* Try convert to number. */
|
|
n_arg = collator_convert_string_to_number_if_possible( arg, rv );
|
|
|
|
if( n_arg == arg )
|
|
{
|
|
/* Conversion to number failed. */
|
|
zval_ptr_dtor( n_arg );
|
|
|
|
/* Convert string to utf8. */
|
|
n_arg = collator_convert_zstr_utf16_to_utf8( arg, rv );
|
|
}
|
|
|
|
return n_arg;
|
|
}
|
|
/* }}} */
|