Back to index

php5  5.3.10
Defines | Typedefs | Functions | Variables
grapheme_string.c File Reference
#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"

Go to the source code of this file.

Defines

#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

Typedefs

typedef int32_t(* grapheme_extract_iter )(UBreakIterator *, int32_t, unsigned char *, int32_t)

Functions

void grapheme_register_constants (INIT_FUNC_ARGS)
 PHP_FUNCTION (grapheme_strlen)
 PHP_FUNCTION (grapheme_strpos)
 PHP_FUNCTION (grapheme_stripos)
 PHP_FUNCTION (grapheme_strrpos)
 PHP_FUNCTION (grapheme_strripos)
 PHP_FUNCTION (grapheme_substr)
static void strstr_common_handler (INTERNAL_FUNCTION_PARAMETERS, int f_ignore_case)
 PHP_FUNCTION (grapheme_strstr)
 PHP_FUNCTION (grapheme_stristr)
static int32_t grapheme_extract_charcount_iter (UBreakIterator *bi, int32_t csize, unsigned char *pstr, int32_t str_len)
static int32_t grapheme_extract_bytecount_iter (UBreakIterator *bi, int32_t bsize, unsigned char *pstr, int32_t str_len)
static int32_t grapheme_extract_count_iter (UBreakIterator *bi, int32_t size, unsigned char *pstr, int32_t str_len)
 PHP_FUNCTION (grapheme_extract)

Variables

static grapheme_extract_iter grapheme_extract_iters []

Define Documentation

Definition at line 35 of file grapheme_string.c.

Definition at line 39 of file grapheme_string.c.

Definition at line 36 of file grapheme_string.c.

Definition at line 37 of file grapheme_string.c.

Definition at line 38 of file grapheme_string.c.


Typedef Documentation

typedef int32_t(* grapheme_extract_iter)(UBreakIterator *, int32_t, unsigned char *, int32_t)

Definition at line 778 of file grapheme_string.c.


Function Documentation

static int32_t grapheme_extract_bytecount_iter ( UBreakIterator *  bi,
int32_t  bsize,
unsigned char *  pstr,
int32_t  str_len 
) [inline, static]

Definition at line 718 of file grapheme_string.c.

{
       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;
}
static int32_t grapheme_extract_charcount_iter ( UBreakIterator *  bi,
int32_t  csize,
unsigned char *  pstr,
int32_t  str_len 
) [inline, static]

Definition at line 681 of file grapheme_string.c.

{
       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;
}
static int32_t grapheme_extract_count_iter ( UBreakIterator *  bi,
int32_t  size,
unsigned char *  pstr,
int32_t  str_len 
) [inline, static]

Definition at line 752 of file grapheme_string.c.

{
       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;
}

Definition at line 45 of file grapheme_string.c.

Here is the caller graph for this function:

Definition at line 55 of file grapheme_string.c.

{
       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;
       }
}

Here is the call graph for this function:

Definition at line 109 of file grapheme_string.c.

{
       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;
       }

}

Here is the call graph for this function:

Definition at line 176 of file grapheme_string.c.

{
       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;
       }

}

Here is the call graph for this function:

Definition at line 251 of file grapheme_string.c.

{
       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;
       }


}

Here is the call graph for this function:

Definition at line 321 of file grapheme_string.c.

{
       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;
       }


}

Here is the call graph for this function:

Definition at line 399 of file grapheme_string.c.

{
       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 && 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", 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);

}

Here is the call graph for this function:

Definition at line 665 of file grapheme_string.c.

Here is the call graph for this function:

Definition at line 673 of file grapheme_string.c.

Here is the call graph for this function:

Definition at line 789 of file grapheme_string.c.

{
       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, 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);
}

Here is the call graph for this function:

static void strstr_common_handler ( INTERNAL_FUNCTION_PARAMETERS  ,
int  f_ignore_case 
) [static]

Definition at line 593 of file grapheme_string.c.

{
       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);
       }

}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation