Commit | Line | Data |
---|---|---|
b75a7d8f A |
1 | /* |
2 | ******************************************************************************* | |
3 | * | |
51004dcb | 4 | * Copyright (C) 2002-2012, International Business Machines |
b75a7d8f A |
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" | |
4388f060 A |
22 | #include "unicode/utf.h" |
23 | #include "unicode/utf8.h" | |
24 | #include "unicode/utf16.h" | |
b75a7d8f A |
25 | #include "cstring.h" |
26 | ||
46f4442e A |
27 | U_NAMESPACE_USE |
28 | ||
b75a7d8f A |
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*/) { | |
73c04bcf | 58 | return UITER_NO_STATE; |
b75a7d8f A |
59 | } |
60 | ||
61 | static void U_CALLCONV | |
73c04bcf A |
62 | noopSetState(UCharIterator * /*iter*/, uint32_t /*state*/, UErrorCode *pErrorCode) { |
63 | *pErrorCode=U_UNSUPPORTED_ERROR; | |
b75a7d8f A |
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 | ||
374ca955 A |
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 | ||
b75a7d8f A |
248 | static UChar32 U_CALLCONV |
249 | utf16BEIteratorCurrent(UCharIterator *iter) { | |
250 | int32_t index; | |
251 | ||
252 | if((index=iter->index)<iter->limit) { | |
374ca955 | 253 | return utf16BEIteratorGet(iter, index); |
b75a7d8f A |
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) { | |
b75a7d8f | 264 | iter->index=index+1; |
374ca955 | 265 | return utf16BEIteratorGet(iter, index); |
b75a7d8f A |
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) { | |
b75a7d8f | 276 | iter->index=--index; |
374ca955 | 277 | return utf16BEIteratorGet(iter, index); |
b75a7d8f A |
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) { | |
51004dcb A |
603 | U8_NEXT_OR_FFFD(s, i, limit, c); |
604 | index+=U16_LENGTH(c); | |
b75a7d8f A |
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) { | |
51004dcb A |
635 | U8_NEXT_OR_FFFD(s, i, limit, c); |
636 | length+=U16_LENGTH(c); | |
b75a7d8f A |
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) { | |
51004dcb A |
653 | U8_NEXT_OR_FFFD(s, i, limit, c); |
654 | length+=U16_LENGTH(c); | |
b75a7d8f A |
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; | |
374ca955 | 759 | return iter->index>=0 ? iter->index : (int32_t)UITER_UNKNOWN_INDEX; |
b75a7d8f A |
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) { | |
51004dcb A |
778 | U8_NEXT_OR_FFFD(s, i, limit, c); |
779 | if(c<=0xffff) { | |
b75a7d8f A |
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) { | |
51004dcb A |
808 | U8_PREV_OR_FFFD(s, 0, i, c); |
809 | if(c<=0xffff) { | |
b75a7d8f A |
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) { | |
374ca955 | 841 | return iter->start<iter->limit || iter->reservedField!=0; |
b75a7d8f A |
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 | ||
51004dcb A |
858 | U8_NEXT_OR_FFFD(s, i, iter->limit, c); |
859 | if(c<=0xffff) { | |
b75a7d8f A |
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 | ||
51004dcb | 884 | U8_NEXT_OR_FFFD(s, iter->start, iter->limit, c); |
b75a7d8f A |
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 | } | |
51004dcb | 893 | if(c<=0xffff) { |
b75a7d8f A |
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 | ||
51004dcb | 920 | U8_PREV_OR_FFFD(s, 0, iter->start, c); |
b75a7d8f A |
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 | } | |
51004dcb | 926 | if(c<=0xffff) { |
b75a7d8f A |
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; | |
51004dcb | 976 | U8_PREV_OR_FFFD((const uint8_t *)iter->context, 0, index, c); |
b75a7d8f A |
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 { | |
374ca955 | 1010 | iter->limit=(int32_t)uprv_strlen(s); |
b75a7d8f A |
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); | |
4388f060 A |
1026 | if(U16_IS_SURROGATE(c)) { |
1027 | if(U16_IS_SURROGATE_LEAD(c)) { | |
b75a7d8f A |
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); | |
4388f060 A |
1033 | if(U16_IS_TRAIL(c2=iter->current(iter))) { |
1034 | c=U16_GET_SUPPLEMENTARY(c, c2); | |
b75a7d8f A |
1035 | } |
1036 | ||
1037 | /* undo index movement */ | |
1038 | iter->move(iter, -1, UITER_CURRENT); | |
1039 | } else { | |
4388f060 A |
1040 | if(U16_IS_LEAD(c2=iter->previous(iter))) { |
1041 | c=U16_GET_SUPPLEMENTARY(c2, c); | |
b75a7d8f A |
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); | |
4388f060 A |
1057 | if(U16_IS_LEAD(c)) { |
1058 | if(U16_IS_TRAIL(c2=iter->next(iter))) { | |
1059 | c=U16_GET_SUPPLEMENTARY(c, c2); | |
b75a7d8f A |
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); | |
4388f060 A |
1073 | if(U16_IS_TRAIL(c)) { |
1074 | if(U16_IS_LEAD(c2=iter->previous(iter))) { | |
1075 | c=U16_GET_SUPPLEMENTARY(c2, c); | |
b75a7d8f A |
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 |