The Tor Browser / file comparison

comparison: intl/icu/source/common/uiter.cpp

intl/icu/source/common/uiter.cpp

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:94c948f18c6b
1 /*
2 *******************************************************************************
3 *
4 * Copyright (C) 2002-2012, International Business Machines
5 * Corporation and others. All Rights Reserved.
6 *
7 *******************************************************************************
8 * file name: uiter.cpp
9 * encoding: US-ASCII
10 * tab size: 8 (not used)
11 * indentation:4
12 *
13 * created on: 2002jan18
14 * created by: Markus W. Scherer
15 */
16
17 #include "unicode/utypes.h"
18 #include "unicode/ustring.h"
19 #include "unicode/chariter.h"
20 #include "unicode/rep.h"
21 #include "unicode/uiter.h"
22 #include "unicode/utf.h"
23 #include "unicode/utf8.h"
24 #include "unicode/utf16.h"
25 #include "cstring.h"
26
27 U_NAMESPACE_USE
28
29 #define IS_EVEN(n) (((n)&1)==0)
30 #define IS_POINTER_EVEN(p) IS_EVEN((size_t)p)
31
32 U_CDECL_BEGIN
33
34 /* No-Op UCharIterator implementation for illegal input --------------------- */
35
36 static int32_t U_CALLCONV
37 noopGetIndex(UCharIterator * /*iter*/, UCharIteratorOrigin /*origin*/) {
38 return 0;
39 }
40
41 static int32_t U_CALLCONV
42 noopMove(UCharIterator * /*iter*/, int32_t /*delta*/, UCharIteratorOrigin /*origin*/) {
43 return 0;
44 }
45
46 static UBool U_CALLCONV
47 noopHasNext(UCharIterator * /*iter*/) {
48 return FALSE;
49 }
50
51 static UChar32 U_CALLCONV
52 noopCurrent(UCharIterator * /*iter*/) {
53 return U_SENTINEL;
54 }
55
56 static uint32_t U_CALLCONV
57 noopGetState(const UCharIterator * /*iter*/) {
58 return UITER_NO_STATE;
59 }
60
61 static void U_CALLCONV
62 noopSetState(UCharIterator * /*iter*/, uint32_t /*state*/, UErrorCode *pErrorCode) {
63 *pErrorCode=U_UNSUPPORTED_ERROR;
64 }
65
66 static const UCharIterator noopIterator={
67 0, 0, 0, 0, 0, 0,
68 noopGetIndex,
69 noopMove,
70 noopHasNext,
71 noopHasNext,
72 noopCurrent,
73 noopCurrent,
74 noopCurrent,
75 NULL,
76 noopGetState,
77 noopSetState
78 };
79
80 /* UCharIterator implementation for simple strings -------------------------- */
81
82 /*
83 * This is an implementation of a code unit (UChar) iterator
84 * for UChar * strings.
85 *
86 * The UCharIterator.context field holds a pointer to the string.
87 */
88
89 static int32_t U_CALLCONV
90 stringIteratorGetIndex(UCharIterator *iter, UCharIteratorOrigin origin) {
91 switch(origin) {
92 case UITER_ZERO:
93 return 0;
94 case UITER_START:
95 return iter->start;
96 case UITER_CURRENT:
97 return iter->index;
98 case UITER_LIMIT:
99 return iter->limit;
100 case UITER_LENGTH:
101 return iter->length;
102 default:
103 /* not a valid origin */
104 /* Should never get here! */
105 return -1;
106 }
107 }
108
109 static int32_t U_CALLCONV
110 stringIteratorMove(UCharIterator *iter, int32_t delta, UCharIteratorOrigin origin) {
111 int32_t pos;
112
113 switch(origin) {
114 case UITER_ZERO:
115 pos=delta;
116 break;
117 case UITER_START:
118 pos=iter->start+delta;
119 break;
120 case UITER_CURRENT:
121 pos=iter->index+delta;
122 break;
123 case UITER_LIMIT:
124 pos=iter->limit+delta;
125 break;
126 case UITER_LENGTH:
127 pos=iter->length+delta;
128 break;
129 default:
130 return -1; /* Error */
131 }
132
133 if(pos<iter->start) {
134 pos=iter->start;
135 } else if(pos>iter->limit) {
136 pos=iter->limit;
137 }
138
139 return iter->index=pos;
140 }
141
142 static UBool U_CALLCONV
143 stringIteratorHasNext(UCharIterator *iter) {
144 return iter->index<iter->limit;
145 }
146
147 static UBool U_CALLCONV
148 stringIteratorHasPrevious(UCharIterator *iter) {
149 return iter->index>iter->start;
150 }
151
152 static UChar32 U_CALLCONV
153 stringIteratorCurrent(UCharIterator *iter) {
154 if(iter->index<iter->limit) {
155 return ((const UChar *)(iter->context))[iter->index];
156 } else {
157 return U_SENTINEL;
158 }
159 }
160
161 static UChar32 U_CALLCONV
162 stringIteratorNext(UCharIterator *iter) {
163 if(iter->index<iter->limit) {
164 return ((const UChar *)(iter->context))[iter->index++];
165 } else {
166 return U_SENTINEL;
167 }
168 }
169
170 static UChar32 U_CALLCONV
171 stringIteratorPrevious(UCharIterator *iter) {
172 if(iter->index>iter->start) {
173 return ((const UChar *)(iter->context))[--iter->index];
174 } else {
175 return U_SENTINEL;
176 }
177 }
178
179 static uint32_t U_CALLCONV
180 stringIteratorGetState(const UCharIterator *iter) {
181 return (uint32_t)iter->index;
182 }
183
184 static void U_CALLCONV
185 stringIteratorSetState(UCharIterator *iter, uint32_t state, UErrorCode *pErrorCode) {
186 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
187 /* do nothing */
188 } else if(iter==NULL) {
189 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
190 } else if((int32_t)state<iter->start || iter->limit<(int32_t)state) {
191 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
192 } else {
193 iter->index=(int32_t)state;
194 }
195 }
196
197 static const UCharIterator stringIterator={
198 0, 0, 0, 0, 0, 0,
199 stringIteratorGetIndex,
200 stringIteratorMove,
201 stringIteratorHasNext,
202 stringIteratorHasPrevious,
203 stringIteratorCurrent,
204 stringIteratorNext,
205 stringIteratorPrevious,
206 NULL,
207 stringIteratorGetState,
208 stringIteratorSetState
209 };
210
211 U_CAPI void U_EXPORT2
212 uiter_setString(UCharIterator *iter, const UChar *s, int32_t length) {
213 if(iter!=0) {
214 if(s!=0 && length>=-1) {
215 *iter=stringIterator;
216 iter->context=s;
217 if(length>=0) {
218 iter->length=length;
219 } else {
220 iter->length=u_strlen(s);
221 }
222 iter->limit=iter->length;
223 } else {
224 *iter=noopIterator;
225 }
226 }
227 }
228
229 /* UCharIterator implementation for UTF-16BE strings ------------------------ */
230
231 /*
232 * This is an implementation of a code unit (UChar) iterator
233 * for UTF-16BE strings, i.e., strings in byte-vectors where
234 * each UChar is stored as a big-endian pair of bytes.
235 *
236 * The UCharIterator.context field holds a pointer to the string.
237 * Everything works just like with a normal UChar iterator (uiter_setString),
238 * except that UChars are assembled from byte pairs.
239 */
240
241 /* internal helper function */
242 static inline UChar32
243 utf16BEIteratorGet(UCharIterator *iter, int32_t index) {
244 const uint8_t *p=(const uint8_t *)iter->context;
245 return ((UChar)p[2*index]<<8)|(UChar)p[2*index+1];
246 }
247
248 static UChar32 U_CALLCONV
249 utf16BEIteratorCurrent(UCharIterator *iter) {
250 int32_t index;
251
252 if((index=iter->index)<iter->limit) {
253 return utf16BEIteratorGet(iter, index);
254 } else {
255 return U_SENTINEL;
256 }
257 }
258
259 static UChar32 U_CALLCONV
260 utf16BEIteratorNext(UCharIterator *iter) {
261 int32_t index;
262
263 if((index=iter->index)<iter->limit) {
264 iter->index=index+1;
265 return utf16BEIteratorGet(iter, index);
266 } else {
267 return U_SENTINEL;
268 }
269 }
270
271 static UChar32 U_CALLCONV
272 utf16BEIteratorPrevious(UCharIterator *iter) {
273 int32_t index;
274
275 if((index=iter->index)>iter->start) {
276 iter->index=--index;
277 return utf16BEIteratorGet(iter, index);
278 } else {
279 return U_SENTINEL;
280 }
281 }
282
283 static const UCharIterator utf16BEIterator={
284 0, 0, 0, 0, 0, 0,
285 stringIteratorGetIndex,
286 stringIteratorMove,
287 stringIteratorHasNext,
288 stringIteratorHasPrevious,
289 utf16BEIteratorCurrent,
290 utf16BEIteratorNext,
291 utf16BEIteratorPrevious,
292 NULL,
293 stringIteratorGetState,
294 stringIteratorSetState
295 };
296
297 /*
298 * Count the number of UChars in a UTF-16BE string before a terminating UChar NUL,
299 * i.e., before a pair of 0 bytes where the first 0 byte is at an even
300 * offset from s.
301 */
302 static int32_t
303 utf16BE_strlen(const char *s) {
304 if(IS_POINTER_EVEN(s)) {
305 /*
306 * even-aligned, call u_strlen(s)
307 * we are probably on a little-endian machine, but searching for UChar NUL
308 * does not care about endianness
309 */
310 return u_strlen((const UChar *)s);
311 } else {
312 /* odd-aligned, search for pair of 0 bytes */
313 const char *p=s;
314
315 while(!(*p==0 && p[1]==0)) {
316 p+=2;
317 }
318 return (int32_t)((p-s)/2);
319 }
320 }
321
322 U_CAPI void U_EXPORT2
323 uiter_setUTF16BE(UCharIterator *iter, const char *s, int32_t length) {
324 if(iter!=NULL) {
325 /* allow only even-length strings (the input length counts bytes) */
326 if(s!=NULL && (length==-1 || (length>=0 && IS_EVEN(length)))) {
327 /* length/=2, except that >>=1 also works for -1 (-1/2==0, -1>>1==-1) */
328 length>>=1;
329
330 if(U_IS_BIG_ENDIAN && IS_POINTER_EVEN(s)) {
331 /* big-endian machine and 2-aligned UTF-16BE string: use normal UChar iterator */
332 uiter_setString(iter, (const UChar *)s, length);
333 return;
334 }
335
336 *iter=utf16BEIterator;
337 iter->context=s;
338 if(length>=0) {
339 iter->length=length;
340 } else {
341 iter->length=utf16BE_strlen(s);
342 }
343 iter->limit=iter->length;
344 } else {
345 *iter=noopIterator;
346 }
347 }
348 }
349
350 /* UCharIterator wrapper around CharacterIterator --------------------------- */
351
352 /*
353 * This is wrapper code around a C++ CharacterIterator to
354 * look like a C UCharIterator.
355 *
356 * The UCharIterator.context field holds a pointer to the CharacterIterator.
357 */
358
359 static int32_t U_CALLCONV
360 characterIteratorGetIndex(UCharIterator *iter, UCharIteratorOrigin origin) {
361 switch(origin) {
362 case UITER_ZERO:
363 return 0;
364 case UITER_START:
365 return ((CharacterIterator *)(iter->context))->startIndex();
366 case UITER_CURRENT:
367 return ((CharacterIterator *)(iter->context))->getIndex();
368 case UITER_LIMIT:
369 return ((CharacterIterator *)(iter->context))->endIndex();
370 case UITER_LENGTH:
371 return ((CharacterIterator *)(iter->context))->getLength();
372 default:
373 /* not a valid origin */
374 /* Should never get here! */
375 return -1;
376 }
377 }
378
379 static int32_t U_CALLCONV
380 characterIteratorMove(UCharIterator *iter, int32_t delta, UCharIteratorOrigin origin) {
381 switch(origin) {
382 case UITER_ZERO:
383 ((CharacterIterator *)(iter->context))->setIndex(delta);
384 return ((CharacterIterator *)(iter->context))->getIndex();
385 case UITER_START:
386 case UITER_CURRENT:
387 case UITER_LIMIT:
388 return ((CharacterIterator *)(iter->context))->move(delta, (CharacterIterator::EOrigin)origin);
389 case UITER_LENGTH:
390 ((CharacterIterator *)(iter->context))->setIndex(((CharacterIterator *)(iter->context))->getLength()+delta);
391 return ((CharacterIterator *)(iter->context))->getIndex();
392 default:
393 /* not a valid origin */
394 /* Should never get here! */
395 return -1;
396 }
397 }
398
399 static UBool U_CALLCONV
400 characterIteratorHasNext(UCharIterator *iter) {
401 return ((CharacterIterator *)(iter->context))->hasNext();
402 }
403
404 static UBool U_CALLCONV
405 characterIteratorHasPrevious(UCharIterator *iter) {
406 return ((CharacterIterator *)(iter->context))->hasPrevious();
407 }
408
409 static UChar32 U_CALLCONV
410 characterIteratorCurrent(UCharIterator *iter) {
411 UChar32 c;
412
413 c=((CharacterIterator *)(iter->context))->current();
414 if(c!=0xffff || ((CharacterIterator *)(iter->context))->hasNext()) {
415 return c;
416 } else {
417 return U_SENTINEL;
418 }
419 }
420
421 static UChar32 U_CALLCONV
422 characterIteratorNext(UCharIterator *iter) {
423 if(((CharacterIterator *)(iter->context))->hasNext()) {
424 return ((CharacterIterator *)(iter->context))->nextPostInc();
425 } else {
426 return U_SENTINEL;
427 }
428 }
429
430 static UChar32 U_CALLCONV
431 characterIteratorPrevious(UCharIterator *iter) {
432 if(((CharacterIterator *)(iter->context))->hasPrevious()) {
433 return ((CharacterIterator *)(iter->context))->previous();
434 } else {
435 return U_SENTINEL;
436 }
437 }
438
439 static uint32_t U_CALLCONV
440 characterIteratorGetState(const UCharIterator *iter) {
441 return ((CharacterIterator *)(iter->context))->getIndex();
442 }
443
444 static void U_CALLCONV
445 characterIteratorSetState(UCharIterator *iter, uint32_t state, UErrorCode *pErrorCode) {
446 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
447 /* do nothing */
448 } else if(iter==NULL || iter->context==NULL) {
449 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
450 } else if((int32_t)state<((CharacterIterator *)(iter->context))->startIndex() || ((CharacterIterator *)(iter->context))->endIndex()<(int32_t)state) {
451 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
452 } else {
453 ((CharacterIterator *)(iter->context))->setIndex((int32_t)state);
454 }
455 }
456
457 static const UCharIterator characterIteratorWrapper={
458 0, 0, 0, 0, 0, 0,
459 characterIteratorGetIndex,
460 characterIteratorMove,
461 characterIteratorHasNext,
462 characterIteratorHasPrevious,
463 characterIteratorCurrent,
464 characterIteratorNext,
465 characterIteratorPrevious,
466 NULL,
467 characterIteratorGetState,
468 characterIteratorSetState
469 };
470
471 U_CAPI void U_EXPORT2
472 uiter_setCharacterIterator(UCharIterator *iter, CharacterIterator *charIter) {
473 if(iter!=0) {
474 if(charIter!=0) {
475 *iter=characterIteratorWrapper;
476 iter->context=charIter;
477 } else {
478 *iter=noopIterator;
479 }
480 }
481 }
482
483 /* UCharIterator wrapper around Replaceable --------------------------------- */
484
485 /*
486 * This is an implementation of a code unit (UChar) iterator
487 * based on a Replaceable object.
488 *
489 * The UCharIterator.context field holds a pointer to the Replaceable.
490 * UCharIterator.length and UCharIterator.index hold Replaceable.length()
491 * and the iteration index.
492 */
493
494 static UChar32 U_CALLCONV
495 replaceableIteratorCurrent(UCharIterator *iter) {
496 if(iter->index<iter->limit) {
497 return ((Replaceable *)(iter->context))->charAt(iter->index);
498 } else {
499 return U_SENTINEL;
500 }
501 }
502
503 static UChar32 U_CALLCONV
504 replaceableIteratorNext(UCharIterator *iter) {
505 if(iter->index<iter->limit) {
506 return ((Replaceable *)(iter->context))->charAt(iter->index++);
507 } else {
508 return U_SENTINEL;
509 }
510 }
511
512 static UChar32 U_CALLCONV
513 replaceableIteratorPrevious(UCharIterator *iter) {
514 if(iter->index>iter->start) {
515 return ((Replaceable *)(iter->context))->charAt(--iter->index);
516 } else {
517 return U_SENTINEL;
518 }
519 }
520
521 static const UCharIterator replaceableIterator={
522 0, 0, 0, 0, 0, 0,
523 stringIteratorGetIndex,
524 stringIteratorMove,
525 stringIteratorHasNext,
526 stringIteratorHasPrevious,
527 replaceableIteratorCurrent,
528 replaceableIteratorNext,
529 replaceableIteratorPrevious,
530 NULL,
531 stringIteratorGetState,
532 stringIteratorSetState
533 };
534
535 U_CAPI void U_EXPORT2
536 uiter_setReplaceable(UCharIterator *iter, const Replaceable *rep) {
537 if(iter!=0) {
538 if(rep!=0) {
539 *iter=replaceableIterator;
540 iter->context=rep;
541 iter->limit=iter->length=rep->length();
542 } else {
543 *iter=noopIterator;
544 }
545 }
546 }
547
548 /* UCharIterator implementation for UTF-8 strings --------------------------- */
549
550 /*
551 * Possible, probably necessary only for an implementation for arbitrary
552 * converters:
553 * Maintain a buffer (ring buffer?) for a piece of converted 16-bit text.
554 * This would require to turn reservedFn into a close function and
555 * to introduce a uiter_close(iter).
556 */
557
558 #define UITER_CNV_CAPACITY 16
559
560 /*
561 * Minimal implementation:
562 * Maintain a single-UChar buffer for an additional surrogate.
563 * The caller must not modify start and limit because they are used internally.
564 *
565 * Use UCharIterator fields as follows:
566 * context pointer to UTF-8 string
567 * length UTF-16 length of the string; -1 until lazy evaluation
568 * start current UTF-8 index
569 * index current UTF-16 index; may be -1="unknown" after setState()
570 * limit UTF-8 length of the string
571 * reservedField supplementary code point
572 *
573 * Since UCharIterator delivers 16-bit code units, the iteration can be
574 * currently in the middle of the byte sequence for a supplementary code point.
575 * In this case, reservedField will contain that code point and start will
576 * point to after the corresponding byte sequence. The UTF-16 index will be
577 * one less than what it would otherwise be corresponding to the UTF-8 index.
578 * Otherwise, reservedField will be 0.
579 */
580
581 /*
582 * Possible optimization for NUL-terminated UTF-8 and UTF-16 strings:
583 * Add implementations that do not call strlen() for iteration but check for NUL.
584 */
585
586 static int32_t U_CALLCONV
587 utf8IteratorGetIndex(UCharIterator *iter, UCharIteratorOrigin origin) {
588 switch(origin) {
589 case UITER_ZERO:
590 case UITER_START:
591 return 0;
592 case UITER_CURRENT:
593 if(iter->index<0) {
594 /* the current UTF-16 index is unknown after setState(), count from the beginning */
595 const uint8_t *s;
596 UChar32 c;
597 int32_t i, limit, index;
598
599 s=(const uint8_t *)iter->context;
600 i=index=0;
601 limit=iter->start; /* count up to the UTF-8 index */
602 while(i<limit) {
603 U8_NEXT_OR_FFFD(s, i, limit, c);
604 index+=U16_LENGTH(c);
605 }
606
607 iter->start=i; /* just in case setState() did not get us to a code point boundary */
608 if(i==iter->limit) {
609 iter->length=index; /* in case it was <0 or wrong */
610 }
611 if(iter->reservedField!=0) {
612 --index; /* we are in the middle of a supplementary code point */
613 }
614 iter->index=index;
615 }
616 return iter->index;
617 case UITER_LIMIT:
618 case UITER_LENGTH:
619 if(iter->length<0) {
620 const uint8_t *s;
621 UChar32 c;
622 int32_t i, limit, length;
623
624 s=(const uint8_t *)iter->context;
625 if(iter->index<0) {
626 /*
627 * the current UTF-16 index is unknown after setState(),
628 * we must first count from the beginning to here
629 */
630 i=length=0;
631 limit=iter->start;
632
633 /* count from the beginning to the current index */
634 while(i<limit) {
635 U8_NEXT_OR_FFFD(s, i, limit, c);
636 length+=U16_LENGTH(c);
637 }
638
639 /* assume i==limit==iter->start, set the UTF-16 index */
640 iter->start=i; /* just in case setState() did not get us to a code point boundary */
641 iter->index= iter->reservedField!=0 ? length-1 : length;
642 } else {
643 i=iter->start;
644 length=iter->index;
645 if(iter->reservedField!=0) {
646 ++length;
647 }
648 }
649
650 /* count from the current index to the end */
651 limit=iter->limit;
652 while(i<limit) {
653 U8_NEXT_OR_FFFD(s, i, limit, c);
654 length+=U16_LENGTH(c);
655 }
656 iter->length=length;
657 }
658 return iter->length;
659 default:
660 /* not a valid origin */
661 /* Should never get here! */
662 return -1;
663 }
664 }
665
666 static int32_t U_CALLCONV
667 utf8IteratorMove(UCharIterator *iter, int32_t delta, UCharIteratorOrigin origin) {
668 const uint8_t *s;
669 UChar32 c;
670 int32_t pos; /* requested UTF-16 index */
671 int32_t i; /* UTF-8 index */
672 UBool havePos;
673
674 /* calculate the requested UTF-16 index */
675 switch(origin) {
676 case UITER_ZERO:
677 case UITER_START:
678 pos=delta;
679 havePos=TRUE;
680 /* iter->index<0 (unknown) is possible */
681 break;
682 case UITER_CURRENT:
683 if(iter->index>=0) {
684 pos=iter->index+delta;
685 havePos=TRUE;
686 } else {
687 /* the current UTF-16 index is unknown after setState(), use only delta */
688 pos=0;
689 havePos=FALSE;
690 }
691 break;
692 case UITER_LIMIT:
693 case UITER_LENGTH:
694 if(iter->length>=0) {
695 pos=iter->length+delta;
696 havePos=TRUE;
697 } else {
698 /* pin to the end, avoid counting the length */
699 iter->index=-1;
700 iter->start=iter->limit;
701 iter->reservedField=0;
702 if(delta>=0) {
703 return UITER_UNKNOWN_INDEX;
704 } else {
705 /* the current UTF-16 index is unknown, use only delta */
706 pos=0;
707 havePos=FALSE;
708 }
709 }
710 break;
711 default:
712 return -1; /* Error */
713 }
714
715 if(havePos) {
716 /* shortcuts: pinning to the edges of the string */
717 if(pos<=0) {
718 iter->index=iter->start=iter->reservedField=0;
719 return 0;
720 } else if(iter->length>=0 && pos>=iter->length) {
721 iter->index=iter->length;
722 iter->start=iter->limit;
723 iter->reservedField=0;
724 return iter->index;
725 }
726
727 /* minimize the number of U8_NEXT/PREV operations */
728 if(iter->index<0 || pos<iter->index/2) {
729 /* go forward from the start instead of backward from the current index */
730 iter->index=iter->start=iter->reservedField=0;
731 } else if(iter->length>=0 && (iter->length-pos)<(pos-iter->index)) {
732 /*
733 * if we have the UTF-16 index and length and the new position is
734 * closer to the end than the current index,
735 * then go backward from the end instead of forward from the current index
736 */
737 iter->index=iter->length;
738 iter->start=iter->limit;
739 iter->reservedField=0;
740 }
741
742 delta=pos-iter->index;
743 if(delta==0) {
744 return iter->index; /* nothing to do */
745 }
746 } else {
747 /* move relative to unknown UTF-16 index */
748 if(delta==0) {
749 return UITER_UNKNOWN_INDEX; /* nothing to do */
750 } else if(-delta>=iter->start) {
751 /* moving backwards by more UChars than there are UTF-8 bytes, pin to 0 */
752 iter->index=iter->start=iter->reservedField=0;
753 return 0;
754 } else if(delta>=(iter->limit-iter->start)) {
755 /* moving forward by more UChars than the remaining UTF-8 bytes, pin to the end */
756 iter->index=iter->length; /* may or may not be <0 (unknown) */
757 iter->start=iter->limit;
758 iter->reservedField=0;
759 return iter->index>=0 ? iter->index : (int32_t)UITER_UNKNOWN_INDEX;
760 }
761 }
762
763 /* delta!=0 */
764
765 /* move towards the requested position, pin to the edges of the string */
766 s=(const uint8_t *)iter->context;
767 pos=iter->index; /* could be <0 (unknown) */
768 i=iter->start;
769 if(delta>0) {
770 /* go forward */
771 int32_t limit=iter->limit;
772 if(iter->reservedField!=0) {
773 iter->reservedField=0;
774 ++pos;
775 --delta;
776 }
777 while(delta>0 && i<limit) {
778 U8_NEXT_OR_FFFD(s, i, limit, c);
779 if(c<=0xffff) {
780 ++pos;
781 --delta;
782 } else if(delta>=2) {
783 pos+=2;
784 delta-=2;
785 } else /* delta==1 */ {
786 /* stop in the middle of a supplementary code point */
787 iter->reservedField=c;
788 ++pos;
789 break; /* delta=0; */
790 }
791 }
792 if(i==limit) {
793 if(iter->length<0 && iter->index>=0) {
794 iter->length= iter->reservedField==0 ? pos : pos+1;
795 } else if(iter->index<0 && iter->length>=0) {
796 iter->index= iter->reservedField==0 ? iter->length : iter->length-1;
797 }
798 }
799 } else /* delta<0 */ {
800 /* go backward */
801 if(iter->reservedField!=0) {
802 iter->reservedField=0;
803 i-=4; /* we stayed behind the supplementary code point; go before it now */
804 --pos;
805 ++delta;
806 }
807 while(delta<0 && i>0) {
808 U8_PREV_OR_FFFD(s, 0, i, c);
809 if(c<=0xffff) {
810 --pos;
811 ++delta;
812 } else if(delta<=-2) {
813 pos-=2;
814 delta+=2;
815 } else /* delta==-1 */ {
816 /* stop in the middle of a supplementary code point */
817 i+=4; /* back to behind this supplementary code point for consistent state */
818 iter->reservedField=c;
819 --pos;
820 break; /* delta=0; */
821 }
822 }
823 }
824
825 iter->start=i;
826 if(iter->index>=0) {
827 return iter->index=pos;
828 } else {
829 /* we started with index<0 (unknown) so pos is bogus */
830 if(i<=1) {
831 return iter->index=i; /* reached the beginning */
832 } else {
833 /* we still don't know the UTF-16 index */
834 return UITER_UNKNOWN_INDEX;
835 }
836 }
837 }
838
839 static UBool U_CALLCONV
840 utf8IteratorHasNext(UCharIterator *iter) {
841 return iter->start<iter->limit || iter->reservedField!=0;
842 }
843
844 static UBool U_CALLCONV
845 utf8IteratorHasPrevious(UCharIterator *iter) {
846 return iter->start>0;
847 }
848
849 static UChar32 U_CALLCONV
850 utf8IteratorCurrent(UCharIterator *iter) {
851 if(iter->reservedField!=0) {
852 return U16_TRAIL(iter->reservedField);
853 } else if(iter->start<iter->limit) {
854 const uint8_t *s=(const uint8_t *)iter->context;
855 UChar32 c;
856 int32_t i=iter->start;
857
858 U8_NEXT_OR_FFFD(s, i, iter->limit, c);
859 if(c<=0xffff) {
860 return c;
861 } else {
862 return U16_LEAD(c);
863 }
864 } else {
865 return U_SENTINEL;
866 }
867 }
868
869 static UChar32 U_CALLCONV
870 utf8IteratorNext(UCharIterator *iter) {
871 int32_t index;
872
873 if(iter->reservedField!=0) {
874 UChar trail=U16_TRAIL(iter->reservedField);
875 iter->reservedField=0;
876 if((index=iter->index)>=0) {
877 iter->index=index+1;
878 }
879 return trail;
880 } else if(iter->start<iter->limit) {
881 const uint8_t *s=(const uint8_t *)iter->context;
882 UChar32 c;
883
884 U8_NEXT_OR_FFFD(s, iter->start, iter->limit, c);
885 if((index=iter->index)>=0) {
886 iter->index=++index;
887 if(iter->length<0 && iter->start==iter->limit) {
888 iter->length= c<=0xffff ? index : index+1;
889 }
890 } else if(iter->start==iter->limit && iter->length>=0) {
891 iter->index= c<=0xffff ? iter->length : iter->length-1;
892 }
893 if(c<=0xffff) {
894 return c;
895 } else {
896 iter->reservedField=c;
897 return U16_LEAD(c);
898 }
899 } else {
900 return U_SENTINEL;
901 }
902 }
903
904 static UChar32 U_CALLCONV
905 utf8IteratorPrevious(UCharIterator *iter) {
906 int32_t index;
907
908 if(iter->reservedField!=0) {
909 UChar lead=U16_LEAD(iter->reservedField);
910 iter->reservedField=0;
911 iter->start-=4; /* we stayed behind the supplementary code point; go before it now */
912 if((index=iter->index)>0) {
913 iter->index=index-1;
914 }
915 return lead;
916 } else if(iter->start>0) {
917 const uint8_t *s=(const uint8_t *)iter->context;
918 UChar32 c;
919
920 U8_PREV_OR_FFFD(s, 0, iter->start, c);
921 if((index=iter->index)>0) {
922 iter->index=index-1;
923 } else if(iter->start<=1) {
924 iter->index= c<=0xffff ? iter->start : iter->start+1;
925 }
926 if(c<=0xffff) {
927 return c;
928 } else {
929 iter->start+=4; /* back to behind this supplementary code point for consistent state */
930 iter->reservedField=c;
931 return U16_TRAIL(c);
932 }
933 } else {
934 return U_SENTINEL;
935 }
936 }
937
938 static uint32_t U_CALLCONV
939 utf8IteratorGetState(const UCharIterator *iter) {
940 uint32_t state=(uint32_t)(iter->start<<1);
941 if(iter->reservedField!=0) {
942 state|=1;
943 }
944 return state;
945 }
946
947 static void U_CALLCONV
948 utf8IteratorSetState(UCharIterator *iter,
949 uint32_t state,
950 UErrorCode *pErrorCode)
951 {
952 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
953 /* do nothing */
954 } else if(iter==NULL) {
955 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
956 } else if(state==utf8IteratorGetState(iter)) {
957 /* setting to the current state: no-op */
958 } else {
959 int32_t index=(int32_t)(state>>1); /* UTF-8 index */
960 state&=1; /* 1 if in surrogate pair, must be index>=4 */
961
962 if((state==0 ? index<0 : index<4) || iter->limit<index) {
963 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
964 } else {
965 iter->start=index; /* restore UTF-8 byte index */
966 if(index<=1) {
967 iter->index=index;
968 } else {
969 iter->index=-1; /* unknown UTF-16 index */
970 }
971 if(state==0) {
972 iter->reservedField=0;
973 } else {
974 /* verified index>=4 above */
975 UChar32 c;
976 U8_PREV_OR_FFFD((const uint8_t *)iter->context, 0, index, c);
977 if(c<=0xffff) {
978 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
979 } else {
980 iter->reservedField=c;
981 }
982 }
983 }
984 }
985 }
986
987 static const UCharIterator utf8Iterator={
988 0, 0, 0, 0, 0, 0,
989 utf8IteratorGetIndex,
990 utf8IteratorMove,
991 utf8IteratorHasNext,
992 utf8IteratorHasPrevious,
993 utf8IteratorCurrent,
994 utf8IteratorNext,
995 utf8IteratorPrevious,
996 NULL,
997 utf8IteratorGetState,
998 utf8IteratorSetState
999 };
1000
1001 U_CAPI void U_EXPORT2
1002 uiter_setUTF8(UCharIterator *iter, const char *s, int32_t length) {
1003 if(iter!=0) {
1004 if(s!=0 && length>=-1) {
1005 *iter=utf8Iterator;
1006 iter->context=s;
1007 if(length>=0) {
1008 iter->limit=length;
1009 } else {
1010 iter->limit=(int32_t)uprv_strlen(s);
1011 }
1012 iter->length= iter->limit<=1 ? iter->limit : -1;
1013 } else {
1014 *iter=noopIterator;
1015 }
1016 }
1017 }
1018
1019 /* Helper functions --------------------------------------------------------- */
1020
1021 U_CAPI UChar32 U_EXPORT2
1022 uiter_current32(UCharIterator *iter) {
1023 UChar32 c, c2;
1024
1025 c=iter->current(iter);
1026 if(U16_IS_SURROGATE(c)) {
1027 if(U16_IS_SURROGATE_LEAD(c)) {
1028 /*
1029 * go to the next code unit
1030 * we know that we are not at the limit because c!=U_SENTINEL
1031 */
1032 iter->move(iter, 1, UITER_CURRENT);
1033 if(U16_IS_TRAIL(c2=iter->current(iter))) {
1034 c=U16_GET_SUPPLEMENTARY(c, c2);
1035 }
1036
1037 /* undo index movement */
1038 iter->move(iter, -1, UITER_CURRENT);
1039 } else {
1040 if(U16_IS_LEAD(c2=iter->previous(iter))) {
1041 c=U16_GET_SUPPLEMENTARY(c2, c);
1042 }
1043 if(c2>=0) {
1044 /* undo index movement */
1045 iter->move(iter, 1, UITER_CURRENT);
1046 }
1047 }
1048 }
1049 return c;
1050 }
1051
1052 U_CAPI UChar32 U_EXPORT2
1053 uiter_next32(UCharIterator *iter) {
1054 UChar32 c, c2;
1055
1056 c=iter->next(iter);
1057 if(U16_IS_LEAD(c)) {
1058 if(U16_IS_TRAIL(c2=iter->next(iter))) {
1059 c=U16_GET_SUPPLEMENTARY(c, c2);
1060 } else if(c2>=0) {
1061 /* unmatched first surrogate, undo index movement */
1062 iter->move(iter, -1, UITER_CURRENT);
1063 }
1064 }
1065 return c;
1066 }
1067
1068 U_CAPI UChar32 U_EXPORT2
1069 uiter_previous32(UCharIterator *iter) {
1070 UChar32 c, c2;
1071
1072 c=iter->previous(iter);
1073 if(U16_IS_TRAIL(c)) {
1074 if(U16_IS_LEAD(c2=iter->previous(iter))) {
1075 c=U16_GET_SUPPLEMENTARY(c2, c);
1076 } else if(c2>=0) {
1077 /* unmatched second surrogate, undo index movement */
1078 iter->move(iter, 1, UITER_CURRENT);
1079 }
1080 }
1081 return c;
1082 }
1083
1084 U_CAPI uint32_t U_EXPORT2
1085 uiter_getState(const UCharIterator *iter) {
1086 if(iter==NULL || iter->getState==NULL) {
1087 return UITER_NO_STATE;
1088 } else {
1089 return iter->getState(iter);
1090 }
1091 }
1092
1093 U_CAPI void U_EXPORT2
1094 uiter_setState(UCharIterator *iter, uint32_t state, UErrorCode *pErrorCode) {
1095 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
1096 /* do nothing */
1097 } else if(iter==NULL) {
1098 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
1099 } else if(iter->setState==NULL) {
1100 *pErrorCode=U_UNSUPPORTED_ERROR;
1101 } else {
1102 iter->setState(iter, state, pErrorCode);
1103 }
1104 }
1105
1106 U_CDECL_END

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial