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