1 /*
2 +----------------------------------------------------------------------+
3 | This source file is subject to version 3.01 of the PHP license, |
4 | that is bundled with this package in the file LICENSE, and is |
5 | available through the world-wide-web at the following url: |
6 | https://www.php.net/license/3_01.txt |
7 | If you did not receive a copy of the PHP license and are unable to |
8 | obtain it through the world-wide-web, please send a note to |
9 | license@php.net so we can mail you a copy immediately. |
10 +----------------------------------------------------------------------+
11 | Author: Ed Batutis <ed@batutis.com> |
12 +----------------------------------------------------------------------+
13 */
14
15 /* {{{ includes */
16 #ifdef HAVE_CONFIG_H
17 #include "config.h"
18 #endif
19
20 #include <php.h>
21 #include "grapheme.h"
22 #include "grapheme_util.h"
23
24 #include <unicode/utypes.h>
25 #include <unicode/utf8.h>
26 #include <unicode/ucol.h>
27 #include <unicode/ustring.h>
28 #include <unicode/ubrk.h>
29
30 /* }}} */
31
32 /* {{{ Get number of graphemes in a string */
PHP_FUNCTION(grapheme_strlen)33 PHP_FUNCTION(grapheme_strlen)
34 {
35 char* string;
36 size_t string_len;
37 UChar* ustring = NULL;
38 int ustring_len = 0;
39 zend_long ret_len;
40 UErrorCode status;
41
42 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &string, &string_len) == FAILURE) {
43 RETURN_THROWS();
44 }
45
46 ret_len = grapheme_ascii_check((unsigned char *)string, string_len);
47
48 if ( ret_len >= 0 )
49 RETURN_LONG(string_len);
50
51 /* convert the string to UTF-16. */
52 status = U_ZERO_ERROR;
53 intl_convert_utf8_to_utf16(&ustring, &ustring_len, string, string_len, &status );
54
55 if ( U_FAILURE( status ) ) {
56 /* Set global error code. */
57 intl_error_set_code( NULL, status );
58
59 /* Set error messages. */
60 intl_error_set_custom_msg( NULL, "Error converting input string to UTF-16", 0 );
61 if (ustring) {
62 efree( ustring );
63 }
64 RETURN_NULL();
65 }
66
67 ret_len = grapheme_split_string(ustring, ustring_len, NULL, 0 );
68
69 if (ustring) {
70 efree( ustring );
71 }
72
73 if (ret_len >= 0) {
74 RETVAL_LONG(ret_len);
75 } else {
76 RETVAL_FALSE;
77 }
78 }
79 /* }}} */
80
81 /* {{{ Find position of first occurrence of a string within another */
PHP_FUNCTION(grapheme_strpos)82 PHP_FUNCTION(grapheme_strpos)
83 {
84 char *haystack, *needle;
85 size_t haystack_len, needle_len;
86 const char *found;
87 zend_long loffset = 0;
88 int32_t offset = 0;
89 size_t noffset = 0;
90 zend_long ret_pos;
91
92 if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|l", &haystack, &haystack_len, &needle, &needle_len, &loffset) == FAILURE) {
93 RETURN_THROWS();
94 }
95
96 if ( OUTSIDE_STRING(loffset, haystack_len) ) {
97 zend_argument_value_error(3, "must be contained in argument #1 ($haystack)");
98 RETURN_THROWS();
99 }
100
101 /* we checked that it will fit: */
102 offset = (int32_t) loffset;
103 noffset = offset >= 0 ? offset : (int32_t)haystack_len + offset;
104
105 /* the offset is 'grapheme count offset' so it still might be invalid - we'll check it later */
106
107 if (offset >= 0 && grapheme_ascii_check((unsigned char *)haystack, haystack_len) >= 0) {
108 /* quick check to see if the string might be there
109 * I realize that 'offset' is 'grapheme count offset' but will work in spite of that
110 */
111 found = php_memnstr(haystack + noffset, needle, needle_len, haystack + haystack_len);
112
113 /* if it isn't there the we are done */
114 if (found) {
115 RETURN_LONG(found - haystack);
116 }
117 RETURN_FALSE;
118 }
119
120 /* do utf16 part of the strpos */
121 ret_pos = grapheme_strpos_utf16(haystack, haystack_len, needle, needle_len, offset, NULL, 0 /* fIgnoreCase */, 0 /* last */ );
122
123 if ( ret_pos >= 0 ) {
124 RETURN_LONG(ret_pos);
125 } else {
126 RETURN_FALSE;
127 }
128 }
129 /* }}} */
130
131 /* {{{ Find position of first occurrence of a string within another, ignoring case differences */
PHP_FUNCTION(grapheme_stripos)132 PHP_FUNCTION(grapheme_stripos)
133 {
134 char *haystack, *needle;
135 size_t haystack_len, needle_len;
136 const char *found;
137 zend_long loffset = 0;
138 int32_t offset = 0;
139 zend_long ret_pos;
140 int is_ascii;
141
142 if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|l", &haystack, &haystack_len, &needle, &needle_len, &loffset) == FAILURE) {
143 RETURN_THROWS();
144 }
145
146 if ( OUTSIDE_STRING(loffset, haystack_len) ) {
147 zend_argument_value_error(3, "must be contained in argument #1 ($haystack)");
148 RETURN_THROWS();
149 }
150
151 /* we checked that it will fit: */
152 offset = (int32_t) loffset;
153
154 /* the offset is 'grapheme count offset' so it still might be invalid - we'll check it later */
155
156 is_ascii = ( grapheme_ascii_check((unsigned char*)haystack, haystack_len) >= 0 );
157
158 if ( is_ascii ) {
159 char *haystack_dup, *needle_dup;
160 int32_t noffset = offset >= 0 ? offset : (int32_t)haystack_len + offset;
161 needle_dup = estrndup(needle, needle_len);
162 zend_str_tolower(needle_dup, needle_len);
163 haystack_dup = estrndup(haystack, haystack_len);
164 zend_str_tolower(haystack_dup, haystack_len);
165
166 found = php_memnstr(haystack_dup + noffset, needle_dup, needle_len, haystack_dup + haystack_len);
167
168 efree(haystack_dup);
169 efree(needle_dup);
170
171 if (found) {
172 RETURN_LONG(found - haystack_dup);
173 }
174
175 /* if needle was ascii too, we are all done, otherwise we need to try using Unicode to see what we get */
176 if ( grapheme_ascii_check((unsigned char *)needle, needle_len) >= 0 ) {
177 RETURN_FALSE;
178 }
179 }
180
181 /* do utf16 part of the strpos */
182 ret_pos = grapheme_strpos_utf16(haystack, haystack_len, needle, needle_len, offset, NULL, 1 /* fIgnoreCase */, 0 /*last */ );
183
184 if ( ret_pos >= 0 ) {
185 RETURN_LONG(ret_pos);
186 } else {
187 RETURN_FALSE;
188 }
189
190 }
191 /* }}} */
192
193 /* {{{ Find position of last occurrence of a string within another */
PHP_FUNCTION(grapheme_strrpos)194 PHP_FUNCTION(grapheme_strrpos)
195 {
196 char *haystack, *needle;
197 size_t haystack_len, needle_len;
198 zend_long loffset = 0;
199 int32_t offset = 0;
200 zend_long ret_pos;
201 int is_ascii;
202
203 if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|l", &haystack, &haystack_len, &needle, &needle_len, &loffset) == FAILURE) {
204 RETURN_THROWS();
205 }
206
207 if ( OUTSIDE_STRING(loffset, haystack_len) ) {
208 zend_argument_value_error(3, "must be contained in argument #1 ($haystack)");
209 RETURN_THROWS();
210 }
211
212 /* we checked that it will fit: */
213 offset = (int32_t) loffset;
214
215 /* the offset is 'grapheme count offset' so it still might be invalid - we'll check it later */
216
217 is_ascii = grapheme_ascii_check((unsigned char *)haystack, haystack_len) >= 0;
218
219 if ( is_ascii ) {
220
221 ret_pos = grapheme_strrpos_ascii(haystack, haystack_len, needle, needle_len, offset);
222
223 if ( ret_pos >= 0 ) {
224 RETURN_LONG(ret_pos);
225 }
226
227 /* if the needle was ascii too, we are done */
228
229 if ( grapheme_ascii_check((unsigned char *)needle, needle_len) >= 0 ) {
230 RETURN_FALSE;
231 }
232
233 /* else we need to continue via utf16 */
234 }
235
236 ret_pos = grapheme_strpos_utf16(haystack, haystack_len, needle, needle_len, offset, NULL, 0 /* f_ignore_case */, 1/* last */);
237
238 if ( ret_pos >= 0 ) {
239 RETURN_LONG(ret_pos);
240 } else {
241 RETURN_FALSE;
242 }
243
244
245 }
246 /* }}} */
247
248 /* {{{ Find position of last occurrence of a string within another, ignoring case */
PHP_FUNCTION(grapheme_strripos)249 PHP_FUNCTION(grapheme_strripos)
250 {
251 char *haystack, *needle;
252 size_t haystack_len, needle_len;
253 zend_long loffset = 0;
254 int32_t offset = 0;
255 zend_long ret_pos;
256 int is_ascii;
257
258 if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|l", &haystack, &haystack_len, &needle, &needle_len, &loffset) == FAILURE) {
259 RETURN_THROWS();
260 }
261
262 if ( OUTSIDE_STRING(loffset, haystack_len) ) {
263 zend_argument_value_error(3, "must be contained in argument #1 ($haystack)");
264 RETURN_THROWS();
265 }
266
267 /* we checked that it will fit: */
268 offset = (int32_t) loffset;
269
270 /* the offset is 'grapheme count offset' so it still might be invalid - we'll check it later */
271
272 is_ascii = grapheme_ascii_check((unsigned char *)haystack, haystack_len) >= 0;
273
274 if ( is_ascii ) {
275 char *needle_dup, *haystack_dup;
276
277 needle_dup = estrndup(needle, needle_len);
278 zend_str_tolower(needle_dup, needle_len);
279 haystack_dup = estrndup(haystack, haystack_len);
280 zend_str_tolower(haystack_dup, haystack_len);
281
282 ret_pos = grapheme_strrpos_ascii(haystack_dup, haystack_len, needle_dup, needle_len, offset);
283
284 efree(haystack_dup);
285 efree(needle_dup);
286
287 if ( ret_pos >= 0 ) {
288 RETURN_LONG(ret_pos);
289 }
290
291 /* if the needle was ascii too, we are done */
292
293 if ( grapheme_ascii_check((unsigned char *)needle, needle_len) >= 0 ) {
294 RETURN_FALSE;
295 }
296
297 /* else we need to continue via utf16 */
298 }
299
300 ret_pos = grapheme_strpos_utf16(haystack, haystack_len, needle, needle_len, offset, NULL, 1 /* f_ignore_case */, 1 /*last */);
301
302 if ( ret_pos >= 0 ) {
303 RETURN_LONG(ret_pos);
304 } else {
305 RETURN_FALSE;
306 }
307
308
309 }
310 /* }}} */
311
312 /* {{{ Returns part of a string */
PHP_FUNCTION(grapheme_substr)313 PHP_FUNCTION(grapheme_substr)
314 {
315 char *str;
316 zend_string *u8_sub_str;
317 UChar *ustr;
318 size_t str_len;
319 int32_t ustr_len;
320 zend_long lstart = 0, length = 0;
321 int32_t start = 0;
322 int iter_val;
323 UErrorCode status;
324 unsigned char u_break_iterator_buffer[U_BRK_SAFECLONE_BUFFERSIZE];
325 UBreakIterator* bi = NULL;
326 int sub_str_start_pos, sub_str_end_pos;
327 int32_t (*iter_func)(UBreakIterator *);
328 bool no_length = 1;
329
330 if (zend_parse_parameters(ZEND_NUM_ARGS(), "sl|l!", &str, &str_len, &lstart, &length, &no_length) == FAILURE) {
331 RETURN_THROWS();
332 }
333
334 if (lstart < INT32_MIN || lstart > INT32_MAX) {
335 zend_argument_value_error(2, "is too large");
336 RETURN_THROWS();
337 }
338
339 start = (int32_t) lstart;
340
341 if (no_length) {
342 length = str_len;
343 }
344
345 if (length < INT32_MIN || length > INT32_MAX) {
346 zend_argument_value_error(3, "is too large");
347 RETURN_THROWS();
348 }
349
350 /* the offset is 'grapheme count offset' so it still might be invalid - we'll check it later */
351
352 if ( grapheme_ascii_check((unsigned char *)str, str_len) >= 0 ) {
353 int32_t asub_str_len;
354 char *sub_str;
355 grapheme_substr_ascii(str, str_len, start, (int32_t)length, &sub_str, &asub_str_len);
356
357 if ( NULL == sub_str ) {
358 intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "grapheme_substr: invalid parameters", 1 );
359 RETURN_FALSE;
360 }
361
362 RETURN_STRINGL(sub_str, asub_str_len);
363 }
364
365 ustr = NULL;
366 ustr_len = 0;
367 status = U_ZERO_ERROR;
368 intl_convert_utf8_to_utf16(&ustr, &ustr_len, str, str_len, &status);
369
370 if ( U_FAILURE( status ) ) {
371 /* Set global error code. */
372 intl_error_set_code( NULL, status );
373
374 /* Set error messages. */
375 intl_error_set_custom_msg( NULL, "Error converting input string to UTF-16", 0 );
376 if (ustr) {
377 efree( ustr );
378 }
379 RETURN_FALSE;
380 }
381
382 bi = grapheme_get_break_iterator((void*)u_break_iterator_buffer, &status );
383
384 if( U_FAILURE(status) ) {
385 RETURN_FALSE;
386 }
387
388 ubrk_setText(bi, ustr, ustr_len, &status);
389
390 if ( start < 0 ) {
391 iter_func = ubrk_previous;
392 ubrk_last(bi);
393 iter_val = 1;
394 }
395 else {
396 iter_func = ubrk_next;
397 iter_val = -1;
398 }
399
400 sub_str_start_pos = 0;
401
402 while ( start ) {
403 sub_str_start_pos = iter_func(bi);
404
405 if ( UBRK_DONE == sub_str_start_pos ) {
406 break;
407 }
408
409 start += iter_val;
410 }
411
412 if (0 != start) {
413 if (start > 0) {
414 if (ustr) {
415 efree(ustr);
416 }
417 ubrk_close(bi);
418 RETURN_EMPTY_STRING();
419 }
420
421 sub_str_start_pos = 0;
422 ubrk_first(bi);
423 }
424
425 /* OK to convert here since if str_len were big, convert above would fail */
426 if (length >= (int32_t)str_len) {
427
428 /* no length supplied or length is too big, return the rest of the string */
429
430 status = U_ZERO_ERROR;
431 u8_sub_str = intl_convert_utf16_to_utf8(ustr + sub_str_start_pos, ustr_len - sub_str_start_pos, &status);
432
433 if (ustr) {
434 efree( ustr );
435 }
436 ubrk_close( bi );
437
438 if ( !u8_sub_str ) {
439 /* Set global error code. */
440 intl_error_set_code( NULL, status );
441
442 /* Set error messages. */
443 intl_error_set_custom_msg( NULL, "Error converting output string to UTF-8", 0 );
444
445 RETURN_FALSE;
446 }
447
448 /* return the allocated string, not a duplicate */
449 RETVAL_NEW_STR(u8_sub_str);
450 return;
451 }
452
453 if(length == 0) {
454 /* empty length - we've validated start, we can return "" now */
455 if (ustr) {
456 efree(ustr);
457 }
458 ubrk_close(bi);
459 RETURN_EMPTY_STRING();
460 }
461
462 /* find the end point of the string to return */
463
464 if ( length < 0 ) {
465 iter_func = ubrk_previous;
466 ubrk_last(bi);
467 iter_val = 1;
468 }
469 else {
470 iter_func = ubrk_next;
471 iter_val = -1;
472 }
473
474 sub_str_end_pos = 0;
475
476 while ( length ) {
477 sub_str_end_pos = iter_func(bi);
478
479 if ( UBRK_DONE == sub_str_end_pos ) {
480 break;
481 }
482
483 length += iter_val;
484 }
485
486 ubrk_close(bi);
487
488 if ( UBRK_DONE == sub_str_end_pos) {
489 if (length < 0) {
490 efree(ustr);
491 RETURN_EMPTY_STRING();
492 } else {
493 sub_str_end_pos = ustr_len;
494 }
495 }
496
497 if (sub_str_start_pos > sub_str_end_pos) {
498 efree(ustr);
499 RETURN_EMPTY_STRING();
500 }
501
502 status = U_ZERO_ERROR;
503 u8_sub_str = intl_convert_utf16_to_utf8(ustr + sub_str_start_pos, ( sub_str_end_pos - sub_str_start_pos ), &status);
504
505 efree( ustr );
506
507 if ( !u8_sub_str ) {
508 /* Set global error code. */
509 intl_error_set_code( NULL, status );
510
511 /* Set error messages. */
512 intl_error_set_custom_msg( NULL, "Error converting output string to UTF-8", 0 );
513
514 RETURN_FALSE;
515 }
516
517 /* return the allocated string, not a duplicate */
518 RETVAL_NEW_STR(u8_sub_str);
519 }
520 /* }}} */
521
522 /* {{{ strstr_common_handler */
strstr_common_handler(INTERNAL_FUNCTION_PARAMETERS,int f_ignore_case)523 static void strstr_common_handler(INTERNAL_FUNCTION_PARAMETERS, int f_ignore_case)
524 {
525 char *haystack, *needle;
526 const char *found;
527 size_t haystack_len, needle_len;
528 int32_t ret_pos, uchar_pos;
529 bool part = 0;
530
531 if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|b", &haystack, &haystack_len, &needle, &needle_len, &part) == FAILURE) {
532 RETURN_THROWS();
533 }
534
535 if ( !f_ignore_case ) {
536
537 /* ASCII optimization: quick check to see if the string might be there */
538 found = php_memnstr(haystack, needle, needle_len, haystack + haystack_len);
539
540 /* if it isn't there the we are done */
541 if ( !found ) {
542 RETURN_FALSE;
543 }
544
545 /* if it is there, and if the haystack is ascii, we are all done */
546 if ( grapheme_ascii_check((unsigned char *)haystack, haystack_len) >= 0 ) {
547 size_t found_offset = found - haystack;
548
549 if (part) {
550 RETURN_STRINGL(haystack, found_offset);
551 } else {
552 RETURN_STRINGL(found, haystack_len - found_offset);
553 }
554 }
555
556 }
557
558 /* need to work in utf16 */
559 ret_pos = grapheme_strpos_utf16(haystack, haystack_len, needle, needle_len, 0, &uchar_pos, f_ignore_case, 0 /*last */ );
560
561 if ( ret_pos < 0 ) {
562 RETURN_FALSE;
563 }
564
565 /* uchar_pos is the 'nth' Unicode character position of the needle */
566
567 ret_pos = 0;
568 U8_FWD_N(haystack, ret_pos, haystack_len, uchar_pos);
569
570 if (part) {
571 RETURN_STRINGL(haystack, ret_pos);
572 } else {
573 RETURN_STRINGL(haystack + ret_pos, haystack_len - ret_pos);
574 }
575
576 }
577 /* }}} */
578
579 /* {{{ Finds first occurrence of a string within another */
PHP_FUNCTION(grapheme_strstr)580 PHP_FUNCTION(grapheme_strstr)
581 {
582 strstr_common_handler(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0 /* f_ignore_case */);
583 }
584 /* }}} */
585
586 /* {{{ Finds first occurrence of a string within another */
PHP_FUNCTION(grapheme_stristr)587 PHP_FUNCTION(grapheme_stristr)
588 {
589 strstr_common_handler(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1 /* f_ignore_case */);
590 }
591 /* }}} */
592
593 /* {{{ grapheme_extract_charcount_iter - grapheme iterator for grapheme_extract MAXCHARS */
594 static inline int32_t
grapheme_extract_charcount_iter(UBreakIterator * bi,int32_t csize,unsigned char * pstr,int32_t str_len)595 grapheme_extract_charcount_iter(UBreakIterator *bi, int32_t csize, unsigned char *pstr, int32_t str_len)
596 {
597 int pos = 0;
598 int ret_pos = 0;
599 int break_pos, prev_break_pos;
600 int count = 0;
601
602 while ( 1 ) {
603 pos = ubrk_next(bi);
604
605 if ( UBRK_DONE == pos ) {
606 break;
607 }
608
609 for ( break_pos = ret_pos; break_pos < pos; ) {
610 count++;
611 prev_break_pos = break_pos;
612 U8_FWD_1(pstr, break_pos, str_len);
613
614 if ( prev_break_pos == break_pos ) {
615 /* something wrong - malformed utf8? */
616 csize = 0;
617 break;
618 }
619 }
620
621 /* if we are beyond our limit, then the loop is done */
622 if ( count > csize ) {
623 break;
624 }
625
626 ret_pos = break_pos;
627 }
628
629 return ret_pos;
630 }
631 /* }}} */
632
633 /* {{{ grapheme_extract_bytecount_iter - grapheme iterator for grapheme_extract MAXBYTES */
634 static inline int32_t
grapheme_extract_bytecount_iter(UBreakIterator * bi,int32_t bsize,unsigned char * pstr,int32_t str_len)635 grapheme_extract_bytecount_iter(UBreakIterator *bi, int32_t bsize, unsigned char *pstr, int32_t str_len)
636 {
637 int pos = 0;
638 int ret_pos = 0;
639
640 while ( 1 ) {
641 pos = ubrk_next(bi);
642
643 if ( UBRK_DONE == pos ) {
644 break;
645 }
646
647 if ( pos > bsize ) {
648 break;
649 }
650
651 ret_pos = pos;
652 }
653
654 return ret_pos;
655 }
656 /* }}} */
657
658 /* {{{ grapheme_extract_count_iter - grapheme iterator for grapheme_extract COUNT */
659 static inline int32_t
grapheme_extract_count_iter(UBreakIterator * bi,int32_t size,unsigned char * pstr,int32_t str_len)660 grapheme_extract_count_iter(UBreakIterator *bi, int32_t size, unsigned char *pstr, int32_t str_len)
661 {
662 int next_pos = 0;
663 int ret_pos = 0;
664
665 while ( size ) {
666 next_pos = ubrk_next(bi);
667
668 if ( UBRK_DONE == next_pos ) {
669 break;
670 }
671 ret_pos = next_pos;
672 size--;
673 }
674
675 return ret_pos;
676 }
677 /* }}} */
678
679 /* {{{ grapheme extract iter function pointer array */
680 typedef int32_t (*grapheme_extract_iter)(UBreakIterator * /*bi*/, int32_t /*size*/, unsigned char * /*pstr*/, int32_t /*str_len*/);
681
682 static const grapheme_extract_iter grapheme_extract_iters[] = {
683 &grapheme_extract_count_iter,
684 &grapheme_extract_bytecount_iter,
685 &grapheme_extract_charcount_iter,
686 };
687 /* }}} */
688
689 /* {{{ Function to extract a sequence of default grapheme clusters */
PHP_FUNCTION(grapheme_extract)690 PHP_FUNCTION(grapheme_extract)
691 {
692 char *str, *pstr;
693 UText ut = UTEXT_INITIALIZER;
694 size_t str_len;
695 zend_long size; /* maximum number of grapheme clusters, bytes, or characters (based on extract_type) to return */
696 zend_long lstart = 0; /* starting position in str in bytes */
697 int32_t start = 0;
698 zend_long extract_type = GRAPHEME_EXTRACT_TYPE_COUNT;
699 UErrorCode status;
700 unsigned char u_break_iterator_buffer[U_BRK_SAFECLONE_BUFFERSIZE];
701 UBreakIterator* bi = NULL;
702 int ret_pos;
703 zval *next = NULL; /* return offset of next part of the string */
704
705 if (zend_parse_parameters(ZEND_NUM_ARGS(), "sl|llz", &str, &str_len, &size, &extract_type, &lstart, &next) == FAILURE) {
706 RETURN_THROWS();
707 }
708
709 if (lstart < 0) {
710 lstart += str_len;
711 }
712
713 if ( NULL != next ) {
714 if ( !Z_ISREF_P(next) ) {
715 intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
716 "grapheme_extract: 'next' was not passed by reference", 0 );
717 RETURN_FALSE;
718 } else {
719 ZVAL_DEREF(next);
720 /* initialize next */
721 zval_ptr_dtor(next);
722 ZVAL_LONG(next, lstart);
723 }
724 }
725
726 if ( extract_type < GRAPHEME_EXTRACT_TYPE_MIN || extract_type > GRAPHEME_EXTRACT_TYPE_MAX ) {
727 zend_argument_value_error(3, "must be one of GRAPHEME_EXTR_COUNT, GRAPHEME_EXTR_MAXBYTES, or GRAPHEME_EXTR_MAXCHARS");
728 RETURN_THROWS();
729 }
730
731 if ( lstart > INT32_MAX || lstart < 0 || (size_t)lstart >= str_len ) {
732 intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "grapheme_extract: start not contained in string", 0 );
733 RETURN_FALSE;
734 }
735
736 if (size < 0) {
737 zend_argument_value_error(2, "must be greater than or equal to 0");
738 RETURN_THROWS();
739 }
740
741 if (size > INT32_MAX) {
742 zend_argument_value_error(2, "is too large");
743 RETURN_THROWS();
744 }
745
746 if (size == 0) {
747 RETURN_EMPTY_STRING();
748 }
749
750 /* we checked that it will fit: */
751 start = (int32_t) lstart;
752
753 pstr = str + start;
754
755 /* just in case pstr points in the middle of a character, move forward to the start of the next char */
756 if ( !U8_IS_SINGLE(*pstr) && !U8_IS_LEAD(*pstr) ) {
757 char *str_end = str + str_len;
758
759 while ( !U8_IS_SINGLE(*pstr) && !U8_IS_LEAD(*pstr) ) {
760 pstr++;
761 if ( pstr >= str_end ) {
762 intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
763 "grapheme_extract: invalid input string", 0 );
764
765 RETURN_FALSE;
766 }
767 }
768 }
769
770 str_len -= (pstr - str);
771
772 /* if the string is all ASCII up to size+1 - or str_len whichever is first - then we are done.
773 (size + 1 because the size-th character might be the beginning of a grapheme cluster)
774 */
775
776 if ( -1 != grapheme_ascii_check((unsigned char *)pstr, MIN(size + 1, str_len)) ) {
777 size_t nsize = MIN(size, str_len);
778 if ( NULL != next ) {
779 ZVAL_LONG(next, start+nsize);
780 }
781 RETURN_STRINGL(pstr, nsize);
782 }
783
784 status = U_ZERO_ERROR;
785 utext_openUTF8(&ut, pstr, str_len, &status);
786
787 if ( U_FAILURE( status ) ) {
788 /* Set global error code. */
789 intl_error_set_code( NULL, status );
790
791 /* Set error messages. */
792 intl_error_set_custom_msg( NULL, "Error opening UTF-8 text", 0 );
793
794 RETURN_FALSE;
795 }
796
797 bi = NULL;
798 status = U_ZERO_ERROR;
799 bi = grapheme_get_break_iterator(u_break_iterator_buffer, &status );
800
801 ubrk_setUText(bi, &ut, &status);
802 /* if the caller put us in the middle of a grapheme, we can't detect it in all cases since we
803 can't back up. So, we will not do anything. */
804
805 /* now we need to find the end of the chunk the user wants us to return */
806 /* it's ok to convert str_len to in32_t since if it were too big intl_convert_utf8_to_utf16 above would fail */
807 ret_pos = (*grapheme_extract_iters[extract_type])(bi, size, (unsigned char *)pstr, (int32_t)str_len);
808
809 utext_close(&ut);
810 ubrk_close(bi);
811
812 if ( NULL != next ) {
813 ZVAL_LONG(next, start+ret_pos);
814 }
815
816 RETURN_STRINGL(((char *)pstr), ret_pos);
817 }
818
819 /* }}} */
820
