diff options
Diffstat (limited to 'ext/intl/grapheme/grapheme_string.c')
| -rw-r--r-- | ext/intl/grapheme/grapheme_string.c | 939 |
1 files changed, 939 insertions, 0 deletions
diff --git a/ext/intl/grapheme/grapheme_string.c b/ext/intl/grapheme/grapheme_string.c new file mode 100644 index 0000000..475bbe4 --- /dev/null +++ b/ext/intl/grapheme/grapheme_string.c @@ -0,0 +1,939 @@ +/* + +----------------------------------------------------------------------+ + | 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", 0 TSRMLS_CC ); + if (ustring) { + efree( ustring ); + } + RETURN_NULL(); + } + + ret_len = grapheme_split_string(ustring, ustring_len, NULL, 0 TSRMLS_CC ); + + if (ustring) { + 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", 0 TSRMLS_CC ); + if (ustr) { + 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 ); + + if (ustr) { + 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); + + if (ustr) { + 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", 0 TSRMLS_CC ); + + if (sub_str) { + 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) { + if(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; + } else { + sub_str_end_pos = ustr_len; + } + } + + 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", 0 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 */ +static 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 */ +static 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 */ +static 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_dtor(next); + ZVAL_LONG(next, lstart); + } + } + + 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", 0 TSRMLS_CC ); + RETURN_FALSE; + } + + if ( size > INT32_MAX || size < 0) { + intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "grapheme_extract: size is invalid", 0 TSRMLS_CC ); + RETURN_FALSE; + } + if (size == 0) { + RETURN_EMPTY_STRING(); + } + + /* 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", 0 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); + + if (ustr) { + 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 + */ + |