Annotation of embedaddon/php/ext/intl/grapheme/grapheme_string.c, revision 1.1.1.1
1.1 misho 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: */
45: void 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 */
55: PHP_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 */
109: PHP_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, uchar_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, &uchar_pos, 0 /* fIgnoreCase */ TSRMLS_CC );
164:
165: if ( ret_pos >= 0 ) {
166: RETURN_LONG(ret_pos + offset);
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 */
176: PHP_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, uchar_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, &uchar_pos, 1 /* fIgnoreCase */ TSRMLS_CC );
239:
240: if ( ret_pos >= 0 ) {
241: RETURN_LONG(ret_pos + offset);
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 */
251: PHP_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_strrpos_utf16(haystack, haystack_len, needle, needle_len, offset, 0 /* f_ignore_case */ 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 */
321: PHP_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_strrpos_utf16(haystack, haystack_len, needle, needle_len, offset, 1 /* f_ignore_case */ 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 */
399: PHP_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: RETURN_FALSE;
438: }
439:
440: RETURN_STRINGL(((char *)sub_str), sub_str_len, 1);
441: }
442:
443: ustr = NULL;
444: ustr_len = 0;
445: status = U_ZERO_ERROR;
446: intl_convert_utf8_to_utf16(&ustr, &ustr_len, (char *)str, str_len, &status);
447:
448: if ( U_FAILURE( status ) ) {
449: /* Set global error code. */
450: intl_error_set_code( NULL, status TSRMLS_CC );
451:
452: /* Set error messages. */
453: intl_error_set_custom_msg( NULL, "Error converting input string to UTF-16", 0 TSRMLS_CC );
454: if (ustr) {
455: efree( ustr );
456: }
457: RETURN_FALSE;
458: }
459:
460: bi = grapheme_get_break_iterator((void*)u_break_iterator_buffer, &status TSRMLS_CC );
461:
462: if( U_FAILURE(status) ) {
463: RETURN_FALSE;
464: }
465:
466: ubrk_setText(bi, ustr, ustr_len, &status);
467:
468: if ( start < 0 ) {
469: iter_func = ubrk_previous;
470: ubrk_last(bi);
471: iter_val = 1;
472: }
473: else {
474: iter_func = ubrk_next;
475: iter_val = -1;
476: }
477:
478: sub_str_start_pos = 0;
479:
480: while ( start ) {
481: sub_str_start_pos = iter_func(bi);
482:
483: if ( UBRK_DONE == sub_str_start_pos ) {
484: break;
485: }
486:
487: start += iter_val;
488: }
489:
490: if ( 0 != start || sub_str_start_pos >= ustr_len ) {
491:
492: intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "grapheme_substr: start not contained in string", 1 TSRMLS_CC );
493:
494: if (ustr) {
495: efree(ustr);
496: }
497: ubrk_close(bi);
498: RETURN_FALSE;
499: }
500:
501: if (ZEND_NUM_ARGS() <= 2) {
502:
503: /* no length supplied, return the rest of the string */
504:
505: sub_str = NULL;
506: sub_str_len = 0;
507: status = U_ZERO_ERROR;
508: intl_convert_utf16_to_utf8((char **)&sub_str, &sub_str_len, ustr + sub_str_start_pos, ustr_len - sub_str_start_pos, &status);
509:
510: if (ustr) {
511: efree( ustr );
512: }
513: ubrk_close( bi );
514:
515: if ( U_FAILURE( status ) ) {
516: /* Set global error code. */
517: intl_error_set_code( NULL, status TSRMLS_CC );
518:
519: /* Set error messages. */
520: intl_error_set_custom_msg( NULL, "Error converting output string to UTF-8", 0 TSRMLS_CC );
521:
522: if (sub_str) {
523: efree( sub_str );
524: }
525:
526: RETURN_FALSE;
527: }
528:
529: /* return the allocated string, not a duplicate */
530: RETURN_STRINGL(((char *)sub_str), sub_str_len, 0);
531: }
532:
533: /* find the end point of the string to return */
534:
535: if ( length < 0 ) {
536: iter_func = ubrk_previous;
537: ubrk_last(bi);
538: iter_val = 1;
539: }
540: else {
541: iter_func = ubrk_next;
542: iter_val = -1;
543: }
544:
545: sub_str_end_pos = 0;
546:
547: while ( length ) {
548: sub_str_end_pos = iter_func(bi);
549:
550: if ( UBRK_DONE == sub_str_end_pos ) {
551: break;
552: }
553:
554: length += iter_val;
555: }
556:
557: if ( UBRK_DONE == sub_str_end_pos && length < 0) {
558:
559: intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "grapheme_substr: length not contained in string", 1 TSRMLS_CC );
560:
561: efree(ustr);
562: ubrk_close(bi);
563: RETURN_FALSE;
564: }
565:
566: sub_str = NULL;
567: status = U_ZERO_ERROR;
568: 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);
569:
570: efree( ustr );
571: ubrk_close( bi );
572:
573: if ( U_FAILURE( status ) ) {
574: /* Set global error code. */
575: intl_error_set_code( NULL, status TSRMLS_CC );
576:
577: /* Set error messages. */
578: intl_error_set_custom_msg( NULL, "Error converting output string to UTF-8", 0 TSRMLS_CC );
579:
580: if ( NULL != sub_str )
581: efree( sub_str );
582:
583: RETURN_FALSE;
584: }
585:
586: /* return the allocated string, not a duplicate */
587: RETURN_STRINGL(((char *)sub_str), sub_str_len, 0);
588:
589: }
590: /* }}} */
591:
592: /* {{{ strstr_common_handler */
593: static void strstr_common_handler(INTERNAL_FUNCTION_PARAMETERS, int f_ignore_case)
594: {
595: unsigned char *haystack, *needle, *found;
596: int haystack_len, needle_len;
597: int ret_pos, uchar_pos;
598: zend_bool part = 0;
599:
600: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|b", (char **)&haystack, &haystack_len, (char **)&needle, &needle_len, &part) == FAILURE) {
601:
602: intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
603: "grapheme_strstr: unable to parse input param", 0 TSRMLS_CC );
604:
605: RETURN_FALSE;
606: }
607:
608: if (needle_len == 0) {
609:
610: intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "grapheme_strpos: Empty delimiter", 1 TSRMLS_CC );
611:
612: RETURN_FALSE;
613: }
614:
615:
616: if ( !f_ignore_case ) {
617:
618: /* ASCII optimization: quick check to see if the string might be there
619: * I realize that 'offset' is 'grapheme count offset' but will work in spite of that
620: */
621: found = (unsigned char *)php_memnstr((char *)haystack, (char *)needle, needle_len, (char *)haystack + haystack_len);
622:
623: /* if it isn't there the we are done */
624: if ( !found ) {
625: RETURN_FALSE;
626: }
627:
628: /* if it is there, and if the haystack is ascii, we are all done */
629: if ( grapheme_ascii_check(haystack, haystack_len) >= 0 ) {
630: size_t found_offset = found - haystack;
631:
632: if (part) {
633: RETURN_STRINGL(((char *)haystack) , found_offset, 1);
634: } else {
635: RETURN_STRINGL(((char *)found), haystack_len - found_offset, 1);
636: }
637: }
638:
639: }
640:
641: /* need to work in utf16 */
642: ret_pos = grapheme_strpos_utf16(haystack, haystack_len, needle, needle_len, 0, &uchar_pos, f_ignore_case TSRMLS_CC );
643:
644: if ( ret_pos < 0 ) {
645: RETURN_FALSE;
646: }
647:
648: /* uchar_pos is the 'nth' Unicode character position of the needle */
649:
650: ret_pos = 0;
651: U8_FWD_N(haystack, ret_pos, haystack_len, uchar_pos);
652:
653: if (part) {
654: RETURN_STRINGL(((char *)haystack), ret_pos, 1);
655: }
656: else {
657: RETURN_STRINGL(((char *)haystack) + ret_pos, haystack_len - ret_pos, 1);
658: }
659:
660: }
661: /* }}} */
662:
663: /* {{{ proto string grapheme_strstr(string haystack, string needle[, bool part])
664: Finds first occurrence of a string within another */
665: PHP_FUNCTION(grapheme_strstr)
666: {
667: strstr_common_handler(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0 /* f_ignore_case */);
668: }
669: /* }}} */
670:
671: /* {{{ proto string grapheme_stristr(string haystack, string needle[, bool part])
672: Finds first occurrence of a string within another */
673: PHP_FUNCTION(grapheme_stristr)
674: {
675: strstr_common_handler(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1 /* f_ignore_case */);
676: }
677: /* }}} */
678:
679: /* {{{ grapheme_extract_charcount_iter - grapheme iterator for grapheme_extract MAXCHARS */
680: static inline int32_t
681: grapheme_extract_charcount_iter(UBreakIterator *bi, int32_t csize, unsigned char *pstr, int32_t str_len)
682: {
683: int pos = 0, prev_pos = 0;
684: int ret_pos = 0, prev_ret_pos = 0;
685:
686: while ( 1 ) {
687: pos = ubrk_next(bi);
688:
689: if ( UBRK_DONE == pos ) {
690: break;
691: }
692:
693: /* if we are beyond our limit, then the loop is done */
694: if ( pos > csize ) {
695: break;
696: }
697:
698: /* update our pointer in the original UTF-8 buffer by as many characters
699: as ubrk_next iterated over */
700:
701: prev_ret_pos = ret_pos;
702: U8_FWD_N(pstr, ret_pos, str_len, pos - prev_pos);
703:
704: if ( prev_ret_pos == ret_pos ) {
705: /* something wrong - malformed utf8? */
706: break;
707: }
708:
709: prev_pos = pos;
710: }
711:
712: return ret_pos;
713: }
714: /* }}} */
715:
716: /* {{{ grapheme_extract_bytecount_iter - grapheme iterator for grapheme_extract MAXBYTES */
717: static inline int32_t
718: grapheme_extract_bytecount_iter(UBreakIterator *bi, int32_t bsize, unsigned char *pstr, int32_t str_len)
719: {
720: int pos = 0, prev_pos = 0;
721: int ret_pos = 0, prev_ret_pos = 0;
722:
723: while ( 1 ) {
724: pos = ubrk_next(bi);
725:
726: if ( UBRK_DONE == pos ) {
727: break;
728: }
729:
730: prev_ret_pos = ret_pos;
731: U8_FWD_N(pstr, ret_pos, str_len, pos - prev_pos);
732:
733: if ( ret_pos > bsize ) {
734: ret_pos = prev_ret_pos;
735: break;
736: }
737:
738: if ( prev_ret_pos == ret_pos ) {
739: /* something wrong - malformed utf8? */
740: break;
741: }
742:
743: prev_pos = pos;
744: }
745:
746: return ret_pos;
747: }
748: /* }}} */
749:
750: /* {{{ grapheme_extract_count_iter - grapheme iterator for grapheme_extract COUNT */
751: static inline int32_t
752: grapheme_extract_count_iter(UBreakIterator *bi, int32_t size, unsigned char *pstr, int32_t str_len)
753: {
754: int pos = 0, next_pos = 0;
755: int ret_pos = 0;
756:
757: while ( size ) {
758: next_pos = ubrk_next(bi);
759:
760: if ( UBRK_DONE == next_pos ) {
761: break;
762: }
763: pos = next_pos;
764: size--;
765: }
766:
767: /* pos is one past the last UChar - and represent the number of code units to
768: advance in the utf-8 buffer
769: */
770:
771: U8_FWD_N(pstr, ret_pos, str_len, pos);
772:
773: return ret_pos;
774: }
775: /* }}} */
776:
777: /* {{{ grapheme extract iter function pointer array */
778: typedef int32_t (*grapheme_extract_iter)(UBreakIterator * /*bi*/, int32_t /*size*/, unsigned char * /*pstr*/, int32_t /*str_len*/);
779:
780: static grapheme_extract_iter grapheme_extract_iters[] = {
781: &grapheme_extract_count_iter,
782: &grapheme_extract_bytecount_iter,
783: &grapheme_extract_charcount_iter,
784: };
785: /* }}} */
786:
787: /* {{{ proto string grapheme_extract(string str, int size[, int extract_type[, int start[, int next]]])
788: Function to extract a sequence of default grapheme clusters */
789: PHP_FUNCTION(grapheme_extract)
790: {
791: unsigned char *str, *pstr;
792: UChar *ustr;
793: int str_len, ustr_len;
794: long size; /* maximum number of grapheme clusters, bytes, or characters (based on extract_type) to return */
795: long lstart = 0; /* starting position in str in bytes */
796: int32_t start = 0;
797: long extract_type = GRAPHEME_EXTRACT_TYPE_COUNT;
798: UErrorCode status;
799: unsigned char u_break_iterator_buffer[U_BRK_SAFECLONE_BUFFERSIZE];
800: UBreakIterator* bi = NULL;
801: int ret_pos;
802: zval *next = NULL; /* return offset of next part of the string */
803:
804: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl|llz", (char **)&str, &str_len, &size, &extract_type, &lstart, &next) == FAILURE) {
805:
806: intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
807: "grapheme_extract: unable to parse input param", 0 TSRMLS_CC );
808:
809: RETURN_FALSE;
810: }
811:
812: if ( NULL != next ) {
813: if ( !PZVAL_IS_REF(next) ) {
814: intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
815: "grapheme_extract: 'next' was not passed by reference", 0 TSRMLS_CC );
816:
817: RETURN_FALSE;
818: }
819: else {
820: /* initialize next */
821: ZVAL_LONG(next, lstart);
822: }
823: }
824:
825: if ( extract_type < GRAPHEME_EXTRACT_TYPE_MIN || extract_type > GRAPHEME_EXTRACT_TYPE_MAX ) {
826:
827: intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
828: "grapheme_extract: unknown extract type param", 0 TSRMLS_CC );
829:
830: RETURN_FALSE;
831: }
832:
833: if ( lstart > INT32_MAX || lstart < 0 || lstart >= str_len ) {
834: intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "grapheme_extract: start not contained in string", 0 TSRMLS_CC );
835: RETURN_FALSE;
836: }
837:
838: if ( size > INT32_MAX || size < 0) {
839: intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "grapheme_extract: size is invalid", 0 TSRMLS_CC );
840: RETURN_FALSE;
841: }
842: if (size == 0) {
843: RETURN_EMPTY_STRING();
844: }
845:
846: /* we checked that it will fit: */
847: start = (int32_t) lstart;
848:
849: pstr = str + start;
850:
851: /* just in case pstr points in the middle of a character, move forward to the start of the next char */
852: if ( !UTF8_IS_SINGLE(*pstr) && !U8_IS_LEAD(*pstr) ) {
853: unsigned char *str_end = str + str_len;
854:
855: while ( !UTF8_IS_SINGLE(*pstr) && !U8_IS_LEAD(*pstr) ) {
856: pstr++;
857: if ( pstr >= str_end ) {
858: intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
859: "grapheme_extract: invalid input string", 0 TSRMLS_CC );
860:
861: RETURN_FALSE;
862: }
863: }
864: }
865:
866: str_len -= (pstr - str);
867:
868: /* if the string is all ASCII up to size+1 - or str_len whichever is first - then we are done.
869: (size + 1 because the size-th character might be the beginning of a grapheme cluster)
870: */
871:
872: if ( -1 != grapheme_ascii_check(pstr, size + 1 < str_len ? size + 1 : str_len ) ) {
873: long nsize = ( size < str_len ? size : str_len );
874: if ( NULL != next ) {
875: ZVAL_LONG(next, start+nsize);
876: }
877: RETURN_STRINGL(((char *)pstr), nsize, 1);
878: }
879:
880: /* convert the strings to UTF-16. */
881: ustr = NULL;
882: ustr_len = 0;
883: status = U_ZERO_ERROR;
884: intl_convert_utf8_to_utf16(&ustr, &ustr_len, (char *)pstr, str_len, &status );
885:
886: if ( U_FAILURE( status ) ) {
887: /* Set global error code. */
888: intl_error_set_code( NULL, status TSRMLS_CC );
889:
890: /* Set error messages. */
891: intl_error_set_custom_msg( NULL, "Error converting input string to UTF-16", 0 TSRMLS_CC );
892:
893: if ( NULL != ustr )
894: efree( ustr );
895:
896: RETURN_FALSE;
897: }
898:
899: bi = NULL;
900: status = U_ZERO_ERROR;
901: bi = grapheme_get_break_iterator(u_break_iterator_buffer, &status TSRMLS_CC );
902:
903: ubrk_setText(bi, ustr, ustr_len, &status);
904:
905: /* if the caller put us in the middle of a grapheme, we can't detect it in all cases since we
906: can't back up. So, we will not do anything. */
907:
908: /* now we need to find the end of the chunk the user wants us to return */
909:
910: ret_pos = (*grapheme_extract_iters[extract_type])(bi, size, pstr, str_len);
911:
912: if (ustr) {
913: efree(ustr);
914: }
915: ubrk_close(bi);
916:
917: if ( NULL != next ) {
918: ZVAL_LONG(next, start+ret_pos);
919: }
920:
921: RETURN_STRINGL(((char *)pstr), ret_pos, 1);
922: }
923:
924: /* }}} */
925:
926: /*
927: * Local variables:
928: * tab-width: 4
929: * c-basic-offset: 4
930: * End:
931: * vim600: fdm=marker
932: * vim: noet sw=4 ts=4
933: */
934:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to grapheme_string.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / intl / grapheme