mirror of
https://github.com/php/php-src.git
synced 2026-10-29 10:22:06 +08:00
Gina Peter Banyard
c0250bac3a
Except for arginfo header as PHP_FUNCTION/PHP_METHOD are marked as U_CFUNC and the `ext/date/php_date.h` header doesn't use extern C. We now specificy the header symbols that _need_ to follow the C function ABI, meaning in some places we drop U_CFUNC declarations and in others we add it. Also use the `BEGIN_EXTERN_C()` portability macro when possible so that searching for this is easier.
329 lines
8.4 KiB
C++
329 lines
8.4 KiB
C++
/*
|
|
+----------------------------------------------------------------------+
|
|
| Copyright © The PHP Group and Contributors. |
|
|
+----------------------------------------------------------------------+
|
|
| This source file is subject to the Modified BSD License that is |
|
|
| bundled with this package in the file LICENSE, and is available |
|
|
| through the World Wide Web at <https://www.php.net/license/>. |
|
|
| |
|
|
| SPDX-License-Identifier: BSD-3-Clause |
|
|
+----------------------------------------------------------------------+
|
|
| Authors: Ed Batutis <ed@batutis.com> |
|
|
+----------------------------------------------------------------------+
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif
|
|
|
|
#if __cplusplus >= 201703L
|
|
#include <string_view>
|
|
#include <unicode/unistr.h>
|
|
#endif
|
|
|
|
#include "php_intl.h"
|
|
#include <unicode/unorm2.h>
|
|
#include "normalizer.h"
|
|
#include "normalizer_class.h"
|
|
#include "intl_convert.h"
|
|
#include <unicode/utf8.h>
|
|
|
|
|
|
static const UNormalizer2 *intl_get_normalizer(zend_long form, UErrorCode *err)
|
|
{/*{{{*/
|
|
switch (form)
|
|
{
|
|
case NORMALIZER_FORM_C:
|
|
return unorm2_getNFCInstance(err);
|
|
case NORMALIZER_FORM_D:
|
|
return unorm2_getNFDInstance(err);
|
|
case NORMALIZER_FORM_KC:
|
|
return unorm2_getNFKCInstance(err);
|
|
case NORMALIZER_FORM_KD:
|
|
return unorm2_getNFKDInstance(err);
|
|
case NORMALIZER_FORM_KC_CF:
|
|
return unorm2_getNFKCCasefoldInstance(err);
|
|
}
|
|
|
|
*err = U_ILLEGAL_ARGUMENT_ERROR;
|
|
return NULL;
|
|
}/*}}}*/
|
|
|
|
static int32_t intl_normalize(zend_long form, const UChar *src, int32_t src_len, UChar *dst, int32_t dst_len, UErrorCode *err)
|
|
{/*{{{*/
|
|
const UNormalizer2 *norm = intl_get_normalizer(form, err);
|
|
if (UNEXPECTED(U_FAILURE(*err))) {
|
|
return -1;
|
|
}
|
|
|
|
return unorm2_normalize(norm, src, src_len, dst, dst_len, err);
|
|
}/*}}}*/
|
|
|
|
static UBool intl_is_normalized(zend_long form, const UChar *uinput, int32_t uinput_len, UErrorCode *err)
|
|
{/*{{{*/
|
|
const UNormalizer2 *norm = intl_get_normalizer(form, err);
|
|
|
|
if (UNEXPECTED(U_FAILURE(*err))) {
|
|
return false;
|
|
}
|
|
|
|
return unorm2_isNormalized(norm, uinput, uinput_len, err);
|
|
}/*}}}*/
|
|
|
|
/* {{{ Normalize a string. */
|
|
PHP_INTL_FUNCTION_WITH_ERROR_RESET(normalizer_normalize)
|
|
{
|
|
char* input = NULL;
|
|
/* form is optional, defaults to FORM_C */
|
|
zend_long form = NORMALIZER_DEFAULT;
|
|
size_t input_len = 0;
|
|
|
|
UChar* uinput = NULL;
|
|
int32_t uinput_len = 0;
|
|
int expansion_factor = 1;
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
|
|
UChar* uret_buf = NULL;
|
|
int32_t uret_len = 0;
|
|
|
|
zend_string* u8str;
|
|
|
|
int32_t size_needed;
|
|
|
|
|
|
/* Parse parameters. */
|
|
if( zend_parse_method_parameters( ZEND_NUM_ARGS(), getThis(), "s|l",
|
|
&input, &input_len, &form ) == FAILURE )
|
|
{
|
|
RETURN_THROWS();
|
|
}
|
|
|
|
expansion_factor = 1;
|
|
|
|
switch(form) {
|
|
case NORMALIZER_FORM_D:
|
|
expansion_factor = 3;
|
|
break;
|
|
case NORMALIZER_FORM_KD:
|
|
expansion_factor = 3;
|
|
break;
|
|
case NORMALIZER_FORM_C:
|
|
case NORMALIZER_FORM_KC:
|
|
case NORMALIZER_FORM_KC_CF:
|
|
break;
|
|
default:
|
|
zend_argument_value_error(2, "must be a valid normalization form");
|
|
RETURN_THROWS();
|
|
}
|
|
|
|
/*
|
|
* Normalize string (converting it to UTF-16 first).
|
|
*/
|
|
|
|
/* First convert the string to UTF-16. */
|
|
intl_convert_utf8_to_utf16(&uinput, &uinput_len, input, input_len, &status );
|
|
|
|
if( U_FAILURE( status ) )
|
|
{
|
|
/* Set global error code. */
|
|
intl_error_set_code( NULL, status );
|
|
|
|
/* Set error messages. */
|
|
intl_error_set_custom_msg( NULL, "Error converting input string to UTF-16");
|
|
if (uinput) {
|
|
efree( uinput );
|
|
}
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
|
|
/* Allocate memory for the destination buffer for normalization */
|
|
uret_len = uinput_len * expansion_factor;
|
|
uret_buf = (UChar*)safe_femalloc(uret_len + 1, sizeof(UChar), 0, /* fallible */ true);
|
|
if (!uret_buf) {
|
|
RETURN_OOM();
|
|
}
|
|
|
|
/* normalize */
|
|
size_needed = intl_normalize(form, uinput, uinput_len, uret_buf, uret_len, &status);
|
|
|
|
/* Bail out if an unexpected error occurred.
|
|
* (U_BUFFER_OVERFLOW_ERROR means that *target buffer is not large enough).
|
|
* (U_STRING_NOT_TERMINATED_WARNING usually means that the input string is empty).
|
|
*/
|
|
if (UNEXPECTED(U_FAILURE(status) && status != U_BUFFER_OVERFLOW_ERROR && status != U_STRING_NOT_TERMINATED_WARNING)) {
|
|
intl_error_set_custom_msg( NULL, "Error normalizing string");
|
|
efree( uret_buf );
|
|
efree( uinput );
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
if ( size_needed > uret_len ) {
|
|
/* realloc does not seem to work properly - memory is corrupted
|
|
* uret_buf = eurealloc(uret_buf, size_needed + 1);
|
|
*/
|
|
efree( uret_buf );
|
|
uret_buf = (UChar*)safe_femalloc(size_needed + 1, sizeof(UChar), 0, /* fallible */ true);
|
|
if (!uret_buf) {
|
|
efree(uinput);
|
|
RETURN_OOM();
|
|
}
|
|
uret_len = size_needed;
|
|
|
|
status = U_ZERO_ERROR;
|
|
|
|
/* try normalize again */
|
|
size_needed = intl_normalize(form, uinput, uinput_len, uret_buf, uret_len, &status);
|
|
|
|
/* Bail out if an unexpected error occurred. */
|
|
if (UNEXPECTED(U_FAILURE(status))) {
|
|
/* Set error messages. */
|
|
intl_error_set_custom_msg( NULL,"Error normalizing string");
|
|
efree( uret_buf );
|
|
efree( uinput );
|
|
RETURN_FALSE;
|
|
}
|
|
}
|
|
|
|
efree( uinput );
|
|
|
|
/* the buffer we actually used */
|
|
uret_len = size_needed;
|
|
|
|
/* Convert normalized string from UTF-16 to UTF-8. */
|
|
u8str = intl_convert_utf16_to_utf8(uret_buf, uret_len, &status );
|
|
efree( uret_buf );
|
|
if( !u8str )
|
|
{
|
|
intl_error_set( NULL, status,
|
|
"error converting normalized text UTF-8");
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
/* Return it. */
|
|
RETVAL_NEW_STR( u8str );
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ Test if a string is in a given normalization form. */
|
|
PHP_INTL_FUNCTION_WITH_ERROR_RESET(normalizer_is_normalized)
|
|
{
|
|
char* input = NULL;
|
|
/* form is optional, defaults to FORM_C */
|
|
zend_long form = NORMALIZER_DEFAULT;
|
|
size_t input_len = 0;
|
|
|
|
UChar* uinput = NULL;
|
|
int uinput_len = 0;
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
|
|
UBool uret = false;
|
|
|
|
|
|
/* Parse parameters. */
|
|
if( zend_parse_method_parameters( ZEND_NUM_ARGS(), getThis(), "s|l",
|
|
&input, &input_len, &form) == FAILURE )
|
|
{
|
|
RETURN_THROWS();
|
|
}
|
|
|
|
switch(form) {
|
|
case NORMALIZER_FORM_D:
|
|
case NORMALIZER_FORM_KD:
|
|
case NORMALIZER_FORM_C:
|
|
case NORMALIZER_FORM_KC:
|
|
case NORMALIZER_FORM_KC_CF:
|
|
break;
|
|
default:
|
|
zend_argument_value_error(2, "must be a valid normalization form");
|
|
RETURN_THROWS();
|
|
}
|
|
|
|
|
|
/*
|
|
* Test normalization of string (converting it to UTF-16 first).
|
|
*/
|
|
|
|
/* First convert the string to UTF-16. */
|
|
intl_convert_utf8_to_utf16(&uinput, &uinput_len, input, input_len, &status );
|
|
|
|
if( U_FAILURE( status ) )
|
|
{
|
|
/* Set global error code. */
|
|
intl_error_set_code( NULL, status );
|
|
|
|
/* Set error messages. */
|
|
intl_error_set_custom_msg( NULL, "Error converting string to UTF-16.");
|
|
if (uinput) {
|
|
efree( uinput );
|
|
}
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
|
|
/* test string */
|
|
uret = intl_is_normalized(form, uinput, uinput_len, &status);
|
|
|
|
efree( uinput );
|
|
|
|
/* Bail out if an unexpected error occurred. */
|
|
if (UNEXPECTED(U_FAILURE(status))) {
|
|
/* Set error messages. */
|
|
intl_error_set_custom_msg( NULL,"Error testing if string is the given normalization form.");
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
if ( uret )
|
|
RETURN_TRUE;
|
|
|
|
RETURN_FALSE;
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ Returns the Decomposition_Mapping property for the given UTF-8 encoded code point. */
|
|
PHP_INTL_FUNCTION_WITH_ERROR_RESET(normalizer_get_raw_decomposition)
|
|
{
|
|
char* input = NULL;
|
|
size_t input_length = 0;
|
|
|
|
UChar32 codepoint = -1;
|
|
int32_t offset = 0;
|
|
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
const UNormalizer2 *norm;
|
|
UChar decomposition[32];
|
|
int32_t decomposition_length;
|
|
|
|
zend_long form = NORMALIZER_DEFAULT;
|
|
|
|
|
|
ZEND_PARSE_PARAMETERS_START(1, 2)
|
|
Z_PARAM_STRING(input, input_length)
|
|
Z_PARAM_OPTIONAL
|
|
Z_PARAM_LONG(form)
|
|
ZEND_PARSE_PARAMETERS_END();
|
|
|
|
norm = intl_get_normalizer(form, &status);
|
|
|
|
U8_NEXT(input, offset, input_length, codepoint);
|
|
if (UNEXPECTED((size_t)offset != input_length)) {
|
|
intl_error_set_code(NULL, U_ILLEGAL_ARGUMENT_ERROR);
|
|
intl_error_set_custom_msg(NULL, "Input string must be exactly one UTF-8 encoded code point long.");
|
|
return;
|
|
}
|
|
|
|
if (UNEXPECTED((codepoint < UCHAR_MIN_VALUE) || (codepoint > UCHAR_MAX_VALUE))) {
|
|
intl_error_set_code(NULL, U_ILLEGAL_ARGUMENT_ERROR);
|
|
intl_error_set_custom_msg(NULL, "Code point out of range");
|
|
return;
|
|
}
|
|
|
|
decomposition_length = unorm2_getRawDecomposition(norm, codepoint, decomposition, 32, &status);
|
|
if (UNEXPECTED(decomposition_length == -1)) {
|
|
RETURN_NULL();
|
|
}
|
|
|
|
RETVAL_NEW_STR(intl_convert_utf16_to_utf8(decomposition, decomposition_length, &status));
|
|
}
|
|
/* }}} */
|