mirror of
https://github.com/php/php-src.git
synced 2024-09-23 02:47:26 +00:00
915 lines
24 KiB
C
Executable File
915 lines
24 KiB
C
Executable File
/*
|
|
+----------------------------------------------------------------------+
|
|
| PHP Version 5 |
|
|
+----------------------------------------------------------------------+
|
|
| 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: |
|
|
| http://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. |
|
|
+----------------------------------------------------------------------+
|
|
| Author: Ed Batutis <ed@batutis.com> |
|
|
+----------------------------------------------------------------------+
|
|
*/
|
|
|
|
/* {{{ includes */
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include <php.h>
|
|
#include "grapheme.h"
|
|
#include "grapheme_util.h"
|
|
|
|
#include <unicode/utypes.h>
|
|
#include <unicode/ucol.h>
|
|
#include <unicode/ustring.h>
|
|
#include <unicode/ubrk.h>
|
|
|
|
#include "ext/standard/php_string.h"
|
|
|
|
/* }}} */
|
|
|
|
#define GRAPHEME_EXTRACT_TYPE_COUNT 0
|
|
#define GRAPHEME_EXTRACT_TYPE_MAXBYTES 1
|
|
#define GRAPHEME_EXTRACT_TYPE_MAXCHARS 2
|
|
#define GRAPHEME_EXTRACT_TYPE_MIN GRAPHEME_EXTRACT_TYPE_COUNT
|
|
#define GRAPHEME_EXTRACT_TYPE_MAX GRAPHEME_EXTRACT_TYPE_MAXCHARS
|
|
|
|
|
|
/* {{{ grapheme_register_constants
|
|
* Register API constants
|
|
*/
|
|
void grapheme_register_constants( INIT_FUNC_ARGS )
|
|
{
|
|
REGISTER_LONG_CONSTANT("GRAPHEME_EXTR_COUNT", GRAPHEME_EXTRACT_TYPE_COUNT, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("GRAPHEME_EXTR_MAXBYTES", GRAPHEME_EXTRACT_TYPE_MAXBYTES, CONST_CS | CONST_PERSISTENT);
|
|
REGISTER_LONG_CONSTANT("GRAPHEME_EXTR_MAXCHARS", GRAPHEME_EXTRACT_TYPE_MAXCHARS, CONST_CS | CONST_PERSISTENT);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto int grapheme_strlen(string str)
|
|
Get number of graphemes in a string */
|
|
PHP_FUNCTION(grapheme_strlen)
|
|
{
|
|
unsigned char* string;
|
|
int string_len;
|
|
UChar* ustring = NULL;
|
|
int ustring_len = 0;
|
|
int ret_len;
|
|
UErrorCode status;
|
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", (char **)&string, &string_len) == FAILURE) {
|
|
|
|
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
|
|
"grapheme_strlen: unable to parse input param", 0 TSRMLS_CC );
|
|
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
ret_len = grapheme_ascii_check(string, string_len);
|
|
|
|
if ( ret_len >= 0 )
|
|
RETURN_LONG(ret_len);
|
|
|
|
/* convert the string to UTF-16. */
|
|
status = U_ZERO_ERROR;
|
|
intl_convert_utf8_to_utf16(&ustring, &ustring_len, (char*) string, string_len, &status );
|
|
|
|
if ( U_FAILURE( status ) ) {
|
|
/* Set global error code. */
|
|
intl_error_set_code( NULL, status TSRMLS_CC );
|
|
|
|
/* Set error messages. */
|
|
intl_error_set_custom_msg( NULL, "Error converting input string to UTF-16", 1 TSRMLS_CC );
|
|
efree( ustring );
|
|
RETURN_NULL();
|
|
}
|
|
|
|
ret_len = grapheme_split_string(ustring, ustring_len, NULL, 0 TSRMLS_CC );
|
|
|
|
efree( ustring );
|
|
|
|
if (ret_len >= 0) {
|
|
RETVAL_LONG(ret_len);
|
|
} else {
|
|
RETVAL_FALSE;
|
|
}
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto int grapheme_strpos(string haystack, string needle [, int offset ])
|
|
Find position of first occurrence of a string within another */
|
|
PHP_FUNCTION(grapheme_strpos)
|
|
{
|
|
unsigned char *haystack, *needle;
|
|
int haystack_len, needle_len;
|
|
unsigned char *found;
|
|
long loffset = 0;
|
|
int32_t offset = 0;
|
|
int ret_pos, uchar_pos;
|
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|l", (char **)&haystack, &haystack_len, (char **)&needle, &needle_len, &loffset) == FAILURE) {
|
|
|
|
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
|
|
"grapheme_strpos: unable to parse input param", 0 TSRMLS_CC );
|
|
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
if ( OUTSIDE_STRING(loffset, haystack_len) ) {
|
|
|
|
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "grapheme_strpos: Offset not contained in string", 1 TSRMLS_CC );
|
|
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
/* we checked that it will fit: */
|
|
offset = (int32_t) loffset;
|
|
|
|
/* the offset is 'grapheme count offset' so it still might be invalid - we'll check it later */
|
|
|
|
if (needle_len == 0) {
|
|
|
|
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "grapheme_strpos: Empty delimiter", 1 TSRMLS_CC );
|
|
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
|
|
/* quick check to see if the string might be there
|
|
* I realize that 'offset' is 'grapheme count offset' but will work in spite of that
|
|
*/
|
|
found = (unsigned char *)php_memnstr((char *)haystack + offset, (char *)needle, needle_len, (char *)haystack + haystack_len);
|
|
|
|
/* if it isn't there the we are done */
|
|
if (!found) {
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
/* if it is there, and if the haystack is ascii, we are all done */
|
|
if ( grapheme_ascii_check(haystack, haystack_len) >= 0 ) {
|
|
|
|
RETURN_LONG(found - haystack);
|
|
}
|
|
|
|
/* do utf16 part of the strpos */
|
|
ret_pos = grapheme_strpos_utf16(haystack, haystack_len, needle, needle_len, offset, &uchar_pos, 0 /* fIgnoreCase */ TSRMLS_CC );
|
|
|
|
if ( ret_pos >= 0 ) {
|
|
RETURN_LONG(ret_pos + offset);
|
|
} else {
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto int grapheme_stripos(string haystack, string needle [, int offset ])
|
|
Find position of first occurrence of a string within another, ignoring case differences */
|
|
PHP_FUNCTION(grapheme_stripos)
|
|
{
|
|
unsigned char *haystack, *needle, *haystack_dup, *needle_dup;
|
|
int haystack_len, needle_len;
|
|
unsigned char *found;
|
|
long loffset = 0;
|
|
int32_t offset = 0;
|
|
int ret_pos, uchar_pos;
|
|
int is_ascii;
|
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|l", (char **)&haystack, &haystack_len, (char **)&needle, &needle_len, &loffset) == FAILURE) {
|
|
|
|
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
|
|
"grapheme_stripos: unable to parse input param", 0 TSRMLS_CC );
|
|
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
if ( OUTSIDE_STRING(loffset, haystack_len) ) {
|
|
|
|
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "grapheme_stripos: Offset not contained in string", 1 TSRMLS_CC );
|
|
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
/* we checked that it will fit: */
|
|
offset = (int32_t) loffset;
|
|
|
|
/* the offset is 'grapheme count offset' so it still might be invalid - we'll check it later */
|
|
|
|
if (needle_len == 0) {
|
|
|
|
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "grapheme_stripos: Empty delimiter", 1 TSRMLS_CC );
|
|
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
|
|
is_ascii = ( grapheme_ascii_check(haystack, haystack_len) >= 0 );
|
|
|
|
if ( is_ascii ) {
|
|
needle_dup = (unsigned char *)estrndup((char *)needle, needle_len);
|
|
php_strtolower((char *)needle_dup, needle_len);
|
|
haystack_dup = (unsigned char *)estrndup((char *)haystack, haystack_len);
|
|
php_strtolower((char *)haystack_dup, haystack_len);
|
|
|
|
found = (unsigned char*) php_memnstr((char *)haystack_dup + offset, (char *)needle_dup, needle_len, (char *)haystack_dup + haystack_len);
|
|
|
|
efree(haystack_dup);
|
|
efree(needle_dup);
|
|
|
|
if (found) {
|
|
RETURN_LONG(found - haystack_dup);
|
|
}
|
|
|
|
/* if needle was ascii too, we are all done, otherwise we need to try using Unicode to see what we get */
|
|
if ( grapheme_ascii_check(needle, needle_len) >= 0 ) {
|
|
RETURN_FALSE;
|
|
}
|
|
}
|
|
|
|
/* do utf16 part of the strpos */
|
|
ret_pos = grapheme_strpos_utf16(haystack, haystack_len, needle, needle_len, offset, &uchar_pos, 1 /* fIgnoreCase */ TSRMLS_CC );
|
|
|
|
if ( ret_pos >= 0 ) {
|
|
RETURN_LONG(ret_pos + offset);
|
|
} else {
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto int grapheme_strrpos(string haystack, string needle [, int offset])
|
|
Find position of last occurrence of a string within another */
|
|
PHP_FUNCTION(grapheme_strrpos)
|
|
{
|
|
unsigned char *haystack, *needle;
|
|
int haystack_len, needle_len;
|
|
long loffset = 0;
|
|
int32_t offset = 0;
|
|
int32_t ret_pos;
|
|
int is_ascii;
|
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|l", (char **)&haystack, &haystack_len, (char **)&needle, &needle_len, &loffset) == FAILURE) {
|
|
|
|
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
|
|
"grapheme_strrpos: unable to parse input param", 0 TSRMLS_CC );
|
|
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
if ( OUTSIDE_STRING(loffset, haystack_len) ) {
|
|
|
|
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "grapheme_strpos: Offset not contained in string", 1 TSRMLS_CC );
|
|
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
/* we checked that it will fit: */
|
|
offset = (int32_t) loffset;
|
|
|
|
/* the offset is 'grapheme count offset' so it still might be invalid - we'll check it later */
|
|
|
|
if (needle_len == 0) {
|
|
|
|
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "grapheme_strpos: Empty delimiter", 1 TSRMLS_CC );
|
|
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
is_ascii = grapheme_ascii_check(haystack, haystack_len) >= 0;
|
|
|
|
if ( is_ascii ) {
|
|
|
|
ret_pos = grapheme_strrpos_ascii(haystack, haystack_len, needle, needle_len, offset);
|
|
|
|
|
|
if ( ret_pos >= 0 ) {
|
|
RETURN_LONG(ret_pos);
|
|
}
|
|
|
|
/* if the needle was ascii too, we are done */
|
|
|
|
if ( grapheme_ascii_check(needle, needle_len) >= 0 ) {
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
/* else we need to continue via utf16 */
|
|
}
|
|
|
|
ret_pos = grapheme_strrpos_utf16(haystack, haystack_len, needle, needle_len, offset, 0 /* f_ignore_case */ TSRMLS_CC);
|
|
|
|
if ( ret_pos >= 0 ) {
|
|
RETURN_LONG(ret_pos);
|
|
} else {
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto int grapheme_strripos(string haystack, string needle [, int offset])
|
|
Find position of last occurrence of a string within another, ignoring case */
|
|
PHP_FUNCTION(grapheme_strripos)
|
|
{
|
|
unsigned char *haystack, *needle;
|
|
int haystack_len, needle_len;
|
|
long loffset = 0;
|
|
int32_t offset = 0;
|
|
int32_t ret_pos;
|
|
int is_ascii;
|
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|l", (char **)&haystack, &haystack_len, (char **)&needle, &needle_len, &loffset) == FAILURE) {
|
|
|
|
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
|
|
"grapheme_strrpos: unable to parse input param", 0 TSRMLS_CC );
|
|
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
if ( OUTSIDE_STRING(loffset, haystack_len) ) {
|
|
|
|
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "grapheme_strpos: Offset not contained in string", 1 TSRMLS_CC );
|
|
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
/* we checked that it will fit: */
|
|
offset = (int32_t) loffset;
|
|
|
|
/* the offset is 'grapheme count offset' so it still might be invalid - we'll check it later */
|
|
|
|
if (needle_len == 0) {
|
|
|
|
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "grapheme_strpos: Empty delimiter", 1 TSRMLS_CC );
|
|
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
is_ascii = grapheme_ascii_check(haystack, haystack_len) >= 0;
|
|
|
|
if ( is_ascii ) {
|
|
unsigned char *needle_dup, *haystack_dup;
|
|
|
|
needle_dup = (unsigned char *)estrndup((char *)needle, needle_len);
|
|
php_strtolower((char *)needle_dup, needle_len);
|
|
haystack_dup = (unsigned char *)estrndup((char *)haystack, haystack_len);
|
|
php_strtolower((char *)haystack_dup, haystack_len);
|
|
|
|
ret_pos = grapheme_strrpos_ascii(haystack_dup, haystack_len, needle_dup, needle_len, offset);
|
|
|
|
efree(haystack_dup);
|
|
efree(needle_dup);
|
|
|
|
if ( ret_pos >= 0 ) {
|
|
RETURN_LONG(ret_pos);
|
|
}
|
|
|
|
/* if the needle was ascii too, we are done */
|
|
|
|
if ( grapheme_ascii_check(needle, needle_len) >= 0 ) {
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
/* else we need to continue via utf16 */
|
|
}
|
|
|
|
ret_pos = grapheme_strrpos_utf16(haystack, haystack_len, needle, needle_len, offset, 1 /* f_ignore_case */ TSRMLS_CC);
|
|
|
|
if ( ret_pos >= 0 ) {
|
|
RETURN_LONG(ret_pos);
|
|
} else {
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto string grapheme_substr(string str, int start [, int length])
|
|
Returns part of a string */
|
|
PHP_FUNCTION(grapheme_substr)
|
|
{
|
|
unsigned char *str, *sub_str;
|
|
UChar *ustr;
|
|
int str_len, sub_str_len, ustr_len;
|
|
long lstart = 0, length = 0;
|
|
int32_t start = 0;
|
|
int iter_val;
|
|
UErrorCode status;
|
|
unsigned char u_break_iterator_buffer[U_BRK_SAFECLONE_BUFFERSIZE];
|
|
UBreakIterator* bi = NULL;
|
|
int sub_str_start_pos, sub_str_end_pos;
|
|
int32_t (*iter_func)(UBreakIterator *);
|
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl|l", (char **)&str, &str_len, &lstart, &length) == FAILURE) {
|
|
|
|
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
|
|
"grapheme_substr: unable to parse input param", 0 TSRMLS_CC );
|
|
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
if ( OUTSIDE_STRING(lstart, str_len) ) {
|
|
|
|
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "grapheme_substr: start not contained in string", 1 TSRMLS_CC );
|
|
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
/* we checked that it will fit: */
|
|
start = (int32_t) lstart;
|
|
|
|
/* the offset is 'grapheme count offset' so it still might be invalid - we'll check it later */
|
|
|
|
if ( grapheme_ascii_check(str, str_len) >= 0 ) {
|
|
grapheme_substr_ascii((char *)str, str_len, start, length, ZEND_NUM_ARGS(), (char **) &sub_str, &sub_str_len);
|
|
|
|
if ( NULL == sub_str ) {
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
RETURN_STRINGL(((char *)sub_str), sub_str_len, 1);
|
|
}
|
|
|
|
ustr = NULL;
|
|
ustr_len = 0;
|
|
status = U_ZERO_ERROR;
|
|
intl_convert_utf8_to_utf16(&ustr, &ustr_len, (char *)str, str_len, &status);
|
|
|
|
if ( U_FAILURE( status ) ) {
|
|
/* Set global error code. */
|
|
intl_error_set_code( NULL, status TSRMLS_CC );
|
|
|
|
/* Set error messages. */
|
|
intl_error_set_custom_msg( NULL, "Error converting input string to UTF-16", 1 TSRMLS_CC );
|
|
efree( ustr );
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
bi = grapheme_get_break_iterator((void*)u_break_iterator_buffer, &status TSRMLS_CC );
|
|
|
|
if( U_FAILURE(status) ) {
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
ubrk_setText(bi, ustr, ustr_len, &status);
|
|
|
|
if ( start < 0 ) {
|
|
iter_func = ubrk_previous;
|
|
ubrk_last(bi);
|
|
iter_val = 1;
|
|
}
|
|
else {
|
|
iter_func = ubrk_next;
|
|
iter_val = -1;
|
|
}
|
|
|
|
sub_str_start_pos = 0;
|
|
|
|
while ( start ) {
|
|
sub_str_start_pos = iter_func(bi);
|
|
|
|
if ( UBRK_DONE == sub_str_start_pos ) {
|
|
break;
|
|
}
|
|
|
|
start += iter_val;
|
|
}
|
|
|
|
if ( 0 != start || sub_str_start_pos >= ustr_len ) {
|
|
|
|
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "grapheme_substr: start not contained in string", 1 TSRMLS_CC );
|
|
|
|
efree(ustr);
|
|
ubrk_close(bi);
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
if (ZEND_NUM_ARGS() <= 2) {
|
|
|
|
/* no length supplied, return the rest of the string */
|
|
|
|
sub_str = NULL;
|
|
sub_str_len = 0;
|
|
status = U_ZERO_ERROR;
|
|
intl_convert_utf16_to_utf8((char **)&sub_str, &sub_str_len, ustr + sub_str_start_pos, ustr_len - sub_str_start_pos, &status);
|
|
|
|
efree( ustr );
|
|
ubrk_close( bi );
|
|
|
|
if ( U_FAILURE( status ) ) {
|
|
/* Set global error code. */
|
|
intl_error_set_code( NULL, status TSRMLS_CC );
|
|
|
|
/* Set error messages. */
|
|
intl_error_set_custom_msg( NULL, "Error converting output string to UTF-8", 1 TSRMLS_CC );
|
|
|
|
efree( sub_str );
|
|
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
/* return the allocated string, not a duplicate */
|
|
RETURN_STRINGL(((char *)sub_str), sub_str_len, 0);
|
|
}
|
|
|
|
/* find the end point of the string to return */
|
|
|
|
if ( length < 0 ) {
|
|
iter_func = ubrk_previous;
|
|
ubrk_last(bi);
|
|
iter_val = 1;
|
|
}
|
|
else {
|
|
iter_func = ubrk_next;
|
|
iter_val = -1;
|
|
}
|
|
|
|
sub_str_end_pos = 0;
|
|
|
|
while ( length ) {
|
|
sub_str_end_pos = iter_func(bi);
|
|
|
|
if ( UBRK_DONE == sub_str_end_pos ) {
|
|
break;
|
|
}
|
|
|
|
length += iter_val;
|
|
}
|
|
|
|
if ( UBRK_DONE == sub_str_end_pos && length < 0) {
|
|
|
|
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "grapheme_substr: length not contained in string", 1 TSRMLS_CC );
|
|
|
|
efree(ustr);
|
|
ubrk_close(bi);
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
sub_str = NULL;
|
|
status = U_ZERO_ERROR;
|
|
intl_convert_utf16_to_utf8((char **)&sub_str, &sub_str_len, ustr + sub_str_start_pos, ( sub_str_end_pos - sub_str_start_pos ), &status);
|
|
|
|
efree( ustr );
|
|
ubrk_close( bi );
|
|
|
|
if ( U_FAILURE( status ) ) {
|
|
/* Set global error code. */
|
|
intl_error_set_code( NULL, status TSRMLS_CC );
|
|
|
|
/* Set error messages. */
|
|
intl_error_set_custom_msg( NULL, "Error converting output string to UTF-8", 1 TSRMLS_CC );
|
|
|
|
if ( NULL != sub_str )
|
|
efree( sub_str );
|
|
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
/* return the allocated string, not a duplicate */
|
|
RETURN_STRINGL(((char *)sub_str), sub_str_len, 0);
|
|
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ strstr_common_handler */
|
|
static void strstr_common_handler(INTERNAL_FUNCTION_PARAMETERS, int f_ignore_case)
|
|
{
|
|
unsigned char *haystack, *needle, *found;
|
|
int haystack_len, needle_len;
|
|
int ret_pos, uchar_pos;
|
|
zend_bool part = 0;
|
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|b", (char **)&haystack, &haystack_len, (char **)&needle, &needle_len, &part) == FAILURE) {
|
|
|
|
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
|
|
"grapheme_strstr: unable to parse input param", 0 TSRMLS_CC );
|
|
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
if (needle_len == 0) {
|
|
|
|
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "grapheme_strpos: Empty delimiter", 1 TSRMLS_CC );
|
|
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
|
|
if ( !f_ignore_case ) {
|
|
|
|
/* ASCII optimization: quick check to see if the string might be there
|
|
* I realize that 'offset' is 'grapheme count offset' but will work in spite of that
|
|
*/
|
|
found = (unsigned char *)php_memnstr((char *)haystack, (char *)needle, needle_len, (char *)haystack + haystack_len);
|
|
|
|
/* if it isn't there the we are done */
|
|
if ( !found ) {
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
/* if it is there, and if the haystack is ascii, we are all done */
|
|
if ( grapheme_ascii_check(haystack, haystack_len) >= 0 ) {
|
|
size_t found_offset = found - haystack;
|
|
|
|
if (part) {
|
|
RETURN_STRINGL(((char *)haystack) , found_offset, 1);
|
|
} else {
|
|
RETURN_STRINGL(((char *)found), haystack_len - found_offset, 1);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/* need to work in utf16 */
|
|
ret_pos = grapheme_strpos_utf16(haystack, haystack_len, needle, needle_len, 0, &uchar_pos, f_ignore_case TSRMLS_CC );
|
|
|
|
if ( ret_pos < 0 ) {
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
/* uchar_pos is the 'nth' Unicode character position of the needle */
|
|
|
|
ret_pos = 0;
|
|
U8_FWD_N(haystack, ret_pos, haystack_len, uchar_pos);
|
|
|
|
if (part) {
|
|
RETURN_STRINGL(((char *)haystack), ret_pos, 1);
|
|
}
|
|
else {
|
|
RETURN_STRINGL(((char *)haystack) + ret_pos, haystack_len - ret_pos, 1);
|
|
}
|
|
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto string grapheme_strstr(string haystack, string needle[, bool part])
|
|
Finds first occurrence of a string within another */
|
|
PHP_FUNCTION(grapheme_strstr)
|
|
{
|
|
strstr_common_handler(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0 /* f_ignore_case */);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ proto string grapheme_stristr(string haystack, string needle[, bool part])
|
|
Finds first occurrence of a string within another */
|
|
PHP_FUNCTION(grapheme_stristr)
|
|
{
|
|
strstr_common_handler(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1 /* f_ignore_case */);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ grapheme_extract_charcount_iter - grapheme iterator for grapheme_extract MAXCHARS */
|
|
inline int32_t
|
|
grapheme_extract_charcount_iter(UBreakIterator *bi, int32_t csize, unsigned char *pstr, int32_t str_len)
|
|
{
|
|
int pos = 0, prev_pos = 0;
|
|
int ret_pos = 0, prev_ret_pos = 0;
|
|
|
|
while ( 1 ) {
|
|
pos = ubrk_next(bi);
|
|
|
|
if ( UBRK_DONE == pos ) {
|
|
break;
|
|
}
|
|
|
|
/* if we are beyond our limit, then the loop is done */
|
|
if ( pos > csize ) {
|
|
break;
|
|
}
|
|
|
|
/* update our pointer in the original UTF-8 buffer by as many characters
|
|
as ubrk_next iterated over */
|
|
|
|
prev_ret_pos = ret_pos;
|
|
U8_FWD_N(pstr, ret_pos, str_len, pos - prev_pos);
|
|
|
|
if ( prev_ret_pos == ret_pos ) {
|
|
/* something wrong - malformed utf8? */
|
|
break;
|
|
}
|
|
|
|
prev_pos = pos;
|
|
}
|
|
|
|
return ret_pos;
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ grapheme_extract_bytecount_iter - grapheme iterator for grapheme_extract MAXBYTES */
|
|
inline int32_t
|
|
grapheme_extract_bytecount_iter(UBreakIterator *bi, int32_t bsize, unsigned char *pstr, int32_t str_len)
|
|
{
|
|
int pos = 0, prev_pos = 0;
|
|
int ret_pos = 0, prev_ret_pos = 0;
|
|
|
|
while ( 1 ) {
|
|
pos = ubrk_next(bi);
|
|
|
|
if ( UBRK_DONE == pos ) {
|
|
break;
|
|
}
|
|
|
|
prev_ret_pos = ret_pos;
|
|
U8_FWD_N(pstr, ret_pos, str_len, pos - prev_pos);
|
|
|
|
if ( ret_pos > bsize ) {
|
|
ret_pos = prev_ret_pos;
|
|
break;
|
|
}
|
|
|
|
if ( prev_ret_pos == ret_pos ) {
|
|
/* something wrong - malformed utf8? */
|
|
break;
|
|
}
|
|
|
|
prev_pos = pos;
|
|
}
|
|
|
|
return ret_pos;
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ grapheme_extract_count_iter - grapheme iterator for grapheme_extract COUNT */
|
|
inline int32_t
|
|
grapheme_extract_count_iter(UBreakIterator *bi, int32_t size, unsigned char *pstr, int32_t str_len)
|
|
{
|
|
int pos = 0, next_pos = 0;
|
|
int ret_pos = 0;
|
|
|
|
while ( size ) {
|
|
next_pos = ubrk_next(bi);
|
|
|
|
if ( UBRK_DONE == next_pos ) {
|
|
break;
|
|
}
|
|
pos = next_pos;
|
|
size--;
|
|
}
|
|
|
|
/* pos is one past the last UChar - and represent the number of code units to
|
|
advance in the utf-8 buffer
|
|
*/
|
|
|
|
U8_FWD_N(pstr, ret_pos, str_len, pos);
|
|
|
|
return ret_pos;
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ grapheme extract iter function pointer array */
|
|
typedef int32_t (*grapheme_extract_iter)(UBreakIterator * /*bi*/, int32_t /*size*/, unsigned char * /*pstr*/, int32_t /*str_len*/);
|
|
|
|
static grapheme_extract_iter grapheme_extract_iters[] = {
|
|
&grapheme_extract_count_iter,
|
|
&grapheme_extract_bytecount_iter,
|
|
&grapheme_extract_charcount_iter,
|
|
};
|
|
/* }}} */
|
|
|
|
/* {{{ proto string grapheme_extract(string str, int size[, int extract_type[, int start[, int next]]])
|
|
Function to extract a sequence of default grapheme clusters */
|
|
PHP_FUNCTION(grapheme_extract)
|
|
{
|
|
unsigned char *str, *pstr;
|
|
UChar *ustr;
|
|
int str_len, ustr_len;
|
|
long size; /* maximum number of grapheme clusters, bytes, or characters (based on extract_type) to return */
|
|
long lstart = 0; /* starting position in str in bytes */
|
|
int32_t start = 0;
|
|
long extract_type = GRAPHEME_EXTRACT_TYPE_COUNT;
|
|
UErrorCode status;
|
|
unsigned char u_break_iterator_buffer[U_BRK_SAFECLONE_BUFFERSIZE];
|
|
UBreakIterator* bi = NULL;
|
|
int ret_pos;
|
|
zval *next = NULL; /* return offset of next part of the string */
|
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl|llz", (char **)&str, &str_len, &size, &extract_type, &lstart, &next) == FAILURE) {
|
|
|
|
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
|
|
"grapheme_extract: unable to parse input param", 0 TSRMLS_CC );
|
|
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
if ( NULL != next ) {
|
|
if ( !PZVAL_IS_REF(next) ) {
|
|
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
|
|
"grapheme_extract: 'next' was not passed by reference", 0 TSRMLS_CC );
|
|
|
|
RETURN_FALSE;
|
|
}
|
|
else {
|
|
/* initialize next */
|
|
ZVAL_LONG(next, start);
|
|
}
|
|
}
|
|
|
|
if ( extract_type < GRAPHEME_EXTRACT_TYPE_MIN || extract_type > GRAPHEME_EXTRACT_TYPE_MAX ) {
|
|
|
|
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
|
|
"grapheme_extract: unknown extract type param", 0 TSRMLS_CC );
|
|
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
if ( lstart > INT32_MAX || lstart < 0 || lstart >= str_len ) {
|
|
|
|
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "grapheme_extract: start not contained in string", 1 TSRMLS_CC );
|
|
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
/* we checked that it will fit: */
|
|
start = (int32_t) lstart;
|
|
|
|
pstr = str + start;
|
|
|
|
/* just in case pstr points in the middle of a character, move forward to the start of the next char */
|
|
if ( !UTF8_IS_SINGLE(*pstr) && !U8_IS_LEAD(*pstr) ) {
|
|
unsigned char *str_end = str + str_len;
|
|
|
|
while ( !UTF8_IS_SINGLE(*pstr) && !U8_IS_LEAD(*pstr) ) {
|
|
pstr++;
|
|
if ( pstr >= str_end ) {
|
|
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
|
|
"grapheme_extract: invalid input string", 0 TSRMLS_CC );
|
|
|
|
RETURN_FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
str_len -= (pstr - str);
|
|
|
|
/* if the string is all ASCII up to size+1 - or str_len whichever is first - then we are done.
|
|
(size + 1 because the size-th character might be the beginning of a grapheme cluster)
|
|
*/
|
|
|
|
if ( -1 != grapheme_ascii_check(pstr, size + 1 < str_len ? size + 1 : str_len ) ) {
|
|
long nsize = ( size < str_len ? size : str_len );
|
|
if ( NULL != next ) {
|
|
ZVAL_LONG(next, start+nsize);
|
|
}
|
|
RETURN_STRINGL(((char *)pstr), nsize, 1);
|
|
}
|
|
|
|
/* convert the strings to UTF-16. */
|
|
ustr = NULL;
|
|
ustr_len = 0;
|
|
status = U_ZERO_ERROR;
|
|
intl_convert_utf8_to_utf16(&ustr, &ustr_len, (char *)pstr, str_len, &status );
|
|
|
|
if ( U_FAILURE( status ) ) {
|
|
/* Set global error code. */
|
|
intl_error_set_code( NULL, status TSRMLS_CC );
|
|
|
|
/* Set error messages. */
|
|
intl_error_set_custom_msg( NULL, "Error converting input string to UTF-16", 1 TSRMLS_CC );
|
|
|
|
if ( NULL != ustr )
|
|
efree( ustr );
|
|
|
|
RETURN_FALSE;
|
|
}
|
|
|
|
bi = NULL;
|
|
status = U_ZERO_ERROR;
|
|
bi = grapheme_get_break_iterator(u_break_iterator_buffer, &status TSRMLS_CC );
|
|
|
|
ubrk_setText(bi, ustr, ustr_len, &status);
|
|
|
|
/* if the caller put us in the middle of a grapheme, we can't detect it in all cases since we
|
|
can't back up. So, we will not do anything. */
|
|
|
|
/* now we need to find the end of the chunk the user wants us to return */
|
|
|
|
ret_pos = (*grapheme_extract_iters[extract_type])(bi, size, pstr, str_len);
|
|
|
|
efree(ustr);
|
|
ubrk_close(bi);
|
|
|
|
if ( NULL != next ) {
|
|
ZVAL_LONG(next, start+ret_pos);
|
|
}
|
|
|
|
RETURN_STRINGL(((char *)pstr), ret_pos, 1);
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
/*
|
|
* Local variables:
|
|
* tab-width: 4
|
|
* c-basic-offset: 4
|
|
* End:
|
|
* vim600: fdm=marker
|
|
* vim: noet sw=4 ts=4
|
|
*/
|
|
|