The Tor Browser / file comparison

comparison: intl/icu/source/common/ucnv_u16.c

intl/icu/source/common/ucnv_u16.c

branch
TOR_BUG_9701
changeset 15
b8a032363ba2
equal deleted inserted replaced
-1:000000000000 0:7cf82970fd74
1 /*
2 **********************************************************************
3 * Copyright (C) 2002-2010, International Business Machines
4 * Corporation and others. All Rights Reserved.
5 **********************************************************************
6 * file name: ucnv_u16.c
7 * encoding: US-ASCII
8 * tab size: 8 (not used)
9 * indentation:4
10 *
11 * created on: 2002jul01
12 * created by: Markus W. Scherer
13 *
14 * UTF-16 converter implementation. Used to be in ucnv_utf.c.
15 */
16
17 #include "unicode/utypes.h"
18
19 #if !UCONFIG_NO_CONVERSION
20
21 #include "unicode/ucnv.h"
22 #include "ucnv_bld.h"
23 #include "ucnv_cnv.h"
24 #include "cmemory.h"
25
26 enum {
27 UCNV_NEED_TO_WRITE_BOM=1
28 };
29
30 /*
31 * The UTF-16 toUnicode implementation is also used for the Java-specific
32 * "with BOM" variants of UTF-16BE and UTF-16LE.
33 */
34 static void
35 _UTF16ToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
36 UErrorCode *pErrorCode);
37
38 /* UTF-16BE ----------------------------------------------------------------- */
39
40 #if U_IS_BIG_ENDIAN
41 # define _UTF16PEFromUnicodeWithOffsets _UTF16BEFromUnicodeWithOffsets
42 #else
43 # define _UTF16PEFromUnicodeWithOffsets _UTF16LEFromUnicodeWithOffsets
44 #endif
45
46
47 static void
48 _UTF16BEFromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs,
49 UErrorCode *pErrorCode) {
50 UConverter *cnv;
51 const UChar *source;
52 char *target;
53 int32_t *offsets;
54
55 uint32_t targetCapacity, length, sourceIndex;
56 UChar c, trail;
57 char overflow[4];
58
59 source=pArgs->source;
60 length=(int32_t)(pArgs->sourceLimit-source);
61 if(length<=0) {
62 /* no input, nothing to do */
63 return;
64 }
65
66 cnv=pArgs->converter;
67
68 /* write the BOM if necessary */
69 if(cnv->fromUnicodeStatus==UCNV_NEED_TO_WRITE_BOM) {
70 static const char bom[]={ (char)0xfe, (char)0xff };
71 ucnv_fromUWriteBytes(cnv,
72 bom, 2,
73 &pArgs->target, pArgs->targetLimit,
74 &pArgs->offsets, -1,
75 pErrorCode);
76 cnv->fromUnicodeStatus=0;
77 }
78
79 target=pArgs->target;
80 if(target >= pArgs->targetLimit) {
81 *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
82 return;
83 }
84
85 targetCapacity=(uint32_t)(pArgs->targetLimit-target);
86 offsets=pArgs->offsets;
87 sourceIndex=0;
88
89 /* c!=0 indicates in several places outside the main loops that a surrogate was found */
90
91 if((c=(UChar)cnv->fromUChar32)!=0 && U16_IS_TRAIL(trail=*source) && targetCapacity>=4) {
92 /* the last buffer ended with a lead surrogate, output the surrogate pair */
93 ++source;
94 --length;
95 target[0]=(uint8_t)(c>>8);
96 target[1]=(uint8_t)c;
97 target[2]=(uint8_t)(trail>>8);
98 target[3]=(uint8_t)trail;
99 target+=4;
100 targetCapacity-=4;
101 if(offsets!=NULL) {
102 *offsets++=-1;
103 *offsets++=-1;
104 *offsets++=-1;
105 *offsets++=-1;
106 }
107 sourceIndex=1;
108 cnv->fromUChar32=c=0;
109 }
110
111 if(c==0) {
112 /* copy an even number of bytes for complete UChars */
113 uint32_t count=2*length;
114 if(count>targetCapacity) {
115 count=targetCapacity&~1;
116 }
117 /* count is even */
118 targetCapacity-=count;
119 count>>=1;
120 length-=count;
121
122 if(offsets==NULL) {
123 while(count>0) {
124 c=*source++;
125 if(U16_IS_SINGLE(c)) {
126 target[0]=(uint8_t)(c>>8);
127 target[1]=(uint8_t)c;
128 target+=2;
129 } else if(U16_IS_SURROGATE_LEAD(c) && count>=2 && U16_IS_TRAIL(trail=*source)) {
130 ++source;
131 --count;
132 target[0]=(uint8_t)(c>>8);
133 target[1]=(uint8_t)c;
134 target[2]=(uint8_t)(trail>>8);
135 target[3]=(uint8_t)trail;
136 target+=4;
137 } else {
138 break;
139 }
140 --count;
141 }
142 } else {
143 while(count>0) {
144 c=*source++;
145 if(U16_IS_SINGLE(c)) {
146 target[0]=(uint8_t)(c>>8);
147 target[1]=(uint8_t)c;
148 target+=2;
149 *offsets++=sourceIndex;
150 *offsets++=sourceIndex++;
151 } else if(U16_IS_SURROGATE_LEAD(c) && count>=2 && U16_IS_TRAIL(trail=*source)) {
152 ++source;
153 --count;
154 target[0]=(uint8_t)(c>>8);
155 target[1]=(uint8_t)c;
156 target[2]=(uint8_t)(trail>>8);
157 target[3]=(uint8_t)trail;
158 target+=4;
159 *offsets++=sourceIndex;
160 *offsets++=sourceIndex;
161 *offsets++=sourceIndex;
162 *offsets++=sourceIndex;
163 sourceIndex+=2;
164 } else {
165 break;
166 }
167 --count;
168 }
169 }
170
171 if(count==0) {
172 /* done with the loop for complete UChars */
173 if(length>0 && targetCapacity>0) {
174 /*
175 * there is more input and some target capacity -
176 * it must be targetCapacity==1 because otherwise
177 * the above would have copied more;
178 * prepare for overflow output
179 */
180 if(U16_IS_SINGLE(c=*source++)) {
181 overflow[0]=(char)(c>>8);
182 overflow[1]=(char)c;
183 length=2; /* 2 bytes to output */
184 c=0;
185 /* } else { keep c for surrogate handling, length will be set there */
186 }
187 } else {
188 length=0;
189 c=0;
190 }
191 } else {
192 /* keep c for surrogate handling, length will be set there */
193 targetCapacity+=2*count;
194 }
195 } else {
196 length=0; /* from here on, length counts the bytes in overflow[] */
197 }
198
199 if(c!=0) {
200 /*
201 * c is a surrogate, and
202 * - source or target too short
203 * - or the surrogate is unmatched
204 */
205 length=0;
206 if(U16_IS_SURROGATE_LEAD(c)) {
207 if(source<pArgs->sourceLimit) {
208 if(U16_IS_TRAIL(trail=*source)) {
209 /* output the surrogate pair, will overflow (see conditions comment above) */
210 ++source;
211 overflow[0]=(char)(c>>8);
212 overflow[1]=(char)c;
213 overflow[2]=(char)(trail>>8);
214 overflow[3]=(char)trail;
215 length=4; /* 4 bytes to output */
216 c=0;
217 } else {
218 /* unmatched lead surrogate */
219 *pErrorCode=U_ILLEGAL_CHAR_FOUND;
220 }
221 } else {
222 /* see if the trail surrogate is in the next buffer */
223 }
224 } else {
225 /* unmatched trail surrogate */
226 *pErrorCode=U_ILLEGAL_CHAR_FOUND;
227 }
228 cnv->fromUChar32=c;
229 }
230
231 if(length>0) {
232 /* output length bytes with overflow (length>targetCapacity>0) */
233 ucnv_fromUWriteBytes(cnv,
234 overflow, length,
235 (char **)&target, pArgs->targetLimit,
236 &offsets, sourceIndex,
237 pErrorCode);
238 targetCapacity=(uint32_t)(pArgs->targetLimit-(char *)target);
239 }
240
241 if(U_SUCCESS(*pErrorCode) && source<pArgs->sourceLimit && targetCapacity==0) {
242 *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
243 }
244
245 /* write back the updated pointers */
246 pArgs->source=source;
247 pArgs->target=(char *)target;
248 pArgs->offsets=offsets;
249 }
250
251 static void
252 _UTF16BEToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
253 UErrorCode *pErrorCode) {
254 UConverter *cnv;
255 const uint8_t *source;
256 UChar *target;
257 int32_t *offsets;
258
259 uint32_t targetCapacity, length, count, sourceIndex;
260 UChar c, trail;
261
262 if(pArgs->converter->mode<8) {
263 _UTF16ToUnicodeWithOffsets(pArgs, pErrorCode);
264 return;
265 }
266
267 cnv=pArgs->converter;
268 source=(const uint8_t *)pArgs->source;
269 length=(int32_t)((const uint8_t *)pArgs->sourceLimit-source);
270 if(length<=0 && cnv->toUnicodeStatus==0) {
271 /* no input, nothing to do */
272 return;
273 }
274
275 target=pArgs->target;
276 if(target >= pArgs->targetLimit) {
277 *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
278 return;
279 }
280
281 targetCapacity=(uint32_t)(pArgs->targetLimit-target);
282 offsets=pArgs->offsets;
283 sourceIndex=0;
284 c=0;
285
286 /* complete a partial UChar or pair from the last call */
287 if(cnv->toUnicodeStatus!=0) {
288 /*
289 * special case: single byte from a previous buffer,
290 * where the byte turned out not to belong to a trail surrogate
291 * and the preceding, unmatched lead surrogate was put into toUBytes[]
292 * for error handling
293 */
294 cnv->toUBytes[0]=(uint8_t)cnv->toUnicodeStatus;
295 cnv->toULength=1;
296 cnv->toUnicodeStatus=0;
297 }
298 if((count=cnv->toULength)!=0) {
299 uint8_t *p=cnv->toUBytes;
300 do {
301 p[count++]=*source++;
302 ++sourceIndex;
303 --length;
304 if(count==2) {
305 c=((UChar)p[0]<<8)|p[1];
306 if(U16_IS_SINGLE(c)) {
307 /* output the BMP code point */
308 *target++=c;
309 if(offsets!=NULL) {
310 *offsets++=-1;
311 }
312 --targetCapacity;
313 count=0;
314 c=0;
315 break;
316 } else if(U16_IS_SURROGATE_LEAD(c)) {
317 /* continue collecting bytes for the trail surrogate */
318 c=0; /* avoid unnecessary surrogate handling below */
319 } else {
320 /* fall through to error handling for an unmatched trail surrogate */
321 break;
322 }
323 } else if(count==4) {
324 c=((UChar)p[0]<<8)|p[1];
325 trail=((UChar)p[2]<<8)|p[3];
326 if(U16_IS_TRAIL(trail)) {
327 /* output the surrogate pair */
328 *target++=c;
329 if(targetCapacity>=2) {
330 *target++=trail;
331 if(offsets!=NULL) {
332 *offsets++=-1;
333 *offsets++=-1;
334 }
335 targetCapacity-=2;
336 } else /* targetCapacity==1 */ {
337 targetCapacity=0;
338 cnv->UCharErrorBuffer[0]=trail;
339 cnv->UCharErrorBufferLength=1;
340 *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
341 }
342 count=0;
343 c=0;
344 break;
345 } else {
346 /* unmatched lead surrogate, handle here for consistent toUBytes[] */
347 *pErrorCode=U_ILLEGAL_CHAR_FOUND;
348
349 /* back out reading the code unit after it */
350 if(((const uint8_t *)pArgs->source-source)>=2) {
351 source-=2;
352 } else {
353 /*
354 * if the trail unit's first byte was in a previous buffer, then
355 * we need to put it into a special place because toUBytes[] will be
356 * used for the lead unit's bytes
357 */
358 cnv->toUnicodeStatus=0x100|p[2];
359 --source;
360 }
361 cnv->toULength=2;
362
363 /* write back the updated pointers */
364 pArgs->source=(const char *)source;
365 pArgs->target=target;
366 pArgs->offsets=offsets;
367 return;
368 }
369 }
370 } while(length>0);
371 cnv->toULength=(int8_t)count;
372 }
373
374 /* copy an even number of bytes for complete UChars */
375 count=2*targetCapacity;
376 if(count>length) {
377 count=length&~1;
378 }
379 if(c==0 && count>0) {
380 length-=count;
381 count>>=1;
382 targetCapacity-=count;
383 if(offsets==NULL) {
384 do {
385 c=((UChar)source[0]<<8)|source[1];
386 source+=2;
387 if(U16_IS_SINGLE(c)) {
388 *target++=c;
389 } else if(U16_IS_SURROGATE_LEAD(c) && count>=2 &&
390 U16_IS_TRAIL(trail=((UChar)source[0]<<8)|source[1])
391 ) {
392 source+=2;
393 --count;
394 *target++=c;
395 *target++=trail;
396 } else {
397 break;
398 }
399 } while(--count>0);
400 } else {
401 do {
402 c=((UChar)source[0]<<8)|source[1];
403 source+=2;
404 if(U16_IS_SINGLE(c)) {
405 *target++=c;
406 *offsets++=sourceIndex;
407 sourceIndex+=2;
408 } else if(U16_IS_SURROGATE_LEAD(c) && count>=2 &&
409 U16_IS_TRAIL(trail=((UChar)source[0]<<8)|source[1])
410 ) {
411 source+=2;
412 --count;
413 *target++=c;
414 *target++=trail;
415 *offsets++=sourceIndex;
416 *offsets++=sourceIndex;
417 sourceIndex+=4;
418 } else {
419 break;
420 }
421 } while(--count>0);
422 }
423
424 if(count==0) {
425 /* done with the loop for complete UChars */
426 c=0;
427 } else {
428 /* keep c for surrogate handling, trail will be set there */
429 length+=2*(count-1); /* one more byte pair was consumed than count decremented */
430 targetCapacity+=count;
431 }
432 }
433
434 if(c!=0) {
435 /*
436 * c is a surrogate, and
437 * - source or target too short
438 * - or the surrogate is unmatched
439 */
440 cnv->toUBytes[0]=(uint8_t)(c>>8);
441 cnv->toUBytes[1]=(uint8_t)c;
442 cnv->toULength=2;
443
444 if(U16_IS_SURROGATE_LEAD(c)) {
445 if(length>=2) {
446 if(U16_IS_TRAIL(trail=((UChar)source[0]<<8)|source[1])) {
447 /* output the surrogate pair, will overflow (see conditions comment above) */
448 source+=2;
449 length-=2;
450 *target++=c;
451 if(offsets!=NULL) {
452 *offsets++=sourceIndex;
453 }
454 cnv->UCharErrorBuffer[0]=trail;
455 cnv->UCharErrorBufferLength=1;
456 cnv->toULength=0;
457 *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
458 } else {
459 /* unmatched lead surrogate */
460 *pErrorCode=U_ILLEGAL_CHAR_FOUND;
461 }
462 } else {
463 /* see if the trail surrogate is in the next buffer */
464 }
465 } else {
466 /* unmatched trail surrogate */
467 *pErrorCode=U_ILLEGAL_CHAR_FOUND;
468 }
469 }
470
471 if(U_SUCCESS(*pErrorCode)) {
472 /* check for a remaining source byte */
473 if(length>0) {
474 if(targetCapacity==0) {
475 *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
476 } else {
477 /* it must be length==1 because otherwise the above would have copied more */
478 cnv->toUBytes[cnv->toULength++]=*source++;
479 }
480 }
481 }
482
483 /* write back the updated pointers */
484 pArgs->source=(const char *)source;
485 pArgs->target=target;
486 pArgs->offsets=offsets;
487 }
488
489 static UChar32
490 _UTF16BEGetNextUChar(UConverterToUnicodeArgs *pArgs, UErrorCode *err) {
491 const uint8_t *s, *sourceLimit;
492 UChar32 c;
493
494 if(pArgs->converter->mode<8) {
495 return UCNV_GET_NEXT_UCHAR_USE_TO_U;
496 }
497
498 s=(const uint8_t *)pArgs->source;
499 sourceLimit=(const uint8_t *)pArgs->sourceLimit;
500
501 if(s>=sourceLimit) {
502 /* no input */
503 *err=U_INDEX_OUTOFBOUNDS_ERROR;
504 return 0xffff;
505 }
506
507 if(s+2>sourceLimit) {
508 /* only one byte: truncated UChar */
509 pArgs->converter->toUBytes[0]=*s++;
510 pArgs->converter->toULength=1;
511 pArgs->source=(const char *)s;
512 *err = U_TRUNCATED_CHAR_FOUND;
513 return 0xffff;
514 }
515
516 /* get one UChar */
517 c=((UChar32)*s<<8)|s[1];
518 s+=2;
519
520 /* check for a surrogate pair */
521 if(U_IS_SURROGATE(c)) {
522 if(U16_IS_SURROGATE_LEAD(c)) {
523 if(s+2<=sourceLimit) {
524 UChar trail;
525
526 /* get a second UChar and see if it is a trail surrogate */
527 trail=((UChar)*s<<8)|s[1];
528 if(U16_IS_TRAIL(trail)) {
529 c=U16_GET_SUPPLEMENTARY(c, trail);
530 s+=2;
531 } else {
532 /* unmatched lead surrogate */
533 c=-2;
534 }
535 } else {
536 /* too few (2 or 3) bytes for a surrogate pair: truncated code point */
537 uint8_t *bytes=pArgs->converter->toUBytes;
538 s-=2;
539 pArgs->converter->toULength=(int8_t)(sourceLimit-s);
540 do {
541 *bytes++=*s++;
542 } while(s<sourceLimit);
543
544 c=0xffff;
545 *err=U_TRUNCATED_CHAR_FOUND;
546 }
547 } else {
548 /* unmatched trail surrogate */
549 c=-2;
550 }
551
552 if(c<0) {
553 /* write the unmatched surrogate */
554 uint8_t *bytes=pArgs->converter->toUBytes;
555 pArgs->converter->toULength=2;
556 *bytes=*(s-2);
557 bytes[1]=*(s-1);
558
559 c=0xffff;
560 *err=U_ILLEGAL_CHAR_FOUND;
561 }
562 }
563
564 pArgs->source=(const char *)s;
565 return c;
566 }
567
568 static void
569 _UTF16BEReset(UConverter *cnv, UConverterResetChoice choice) {
570 if(choice<=UCNV_RESET_TO_UNICODE) {
571 /* reset toUnicode state */
572 if(UCNV_GET_VERSION(cnv)==0) {
573 cnv->mode=8; /* no BOM handling */
574 } else {
575 cnv->mode=0; /* Java-specific "UnicodeBig" requires BE BOM or no BOM */
576 }
577 }
578 if(choice!=UCNV_RESET_TO_UNICODE && UCNV_GET_VERSION(cnv)==1) {
579 /* reset fromUnicode for "UnicodeBig": prepare to output the UTF-16BE BOM */
580 cnv->fromUnicodeStatus=UCNV_NEED_TO_WRITE_BOM;
581 }
582 }
583
584 static void
585 _UTF16BEOpen(UConverter *cnv,
586 UConverterLoadArgs *pArgs,
587 UErrorCode *pErrorCode) {
588 if(UCNV_GET_VERSION(cnv)<=1) {
589 _UTF16BEReset(cnv, UCNV_RESET_BOTH);
590 } else {
591 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
592 }
593 }
594
595 static const char *
596 _UTF16BEGetName(const UConverter *cnv) {
597 if(UCNV_GET_VERSION(cnv)==0) {
598 return "UTF-16BE";
599 } else {
600 return "UTF-16BE,version=1";
601 }
602 }
603
604 static const UConverterImpl _UTF16BEImpl={
605 UCNV_UTF16_BigEndian,
606
607 NULL,
608 NULL,
609
610 _UTF16BEOpen,
611 NULL,
612 _UTF16BEReset,
613
614 _UTF16BEToUnicodeWithOffsets,
615 _UTF16BEToUnicodeWithOffsets,
616 _UTF16BEFromUnicodeWithOffsets,
617 _UTF16BEFromUnicodeWithOffsets,
618 _UTF16BEGetNextUChar,
619
620 NULL,
621 _UTF16BEGetName,
622 NULL,
623 NULL,
624 ucnv_getNonSurrogateUnicodeSet
625 };
626
627 static const UConverterStaticData _UTF16BEStaticData={
628 sizeof(UConverterStaticData),
629 "UTF-16BE",
630 1200, UCNV_IBM, UCNV_UTF16_BigEndian, 2, 2,
631 { 0xff, 0xfd, 0, 0 },2,FALSE,FALSE,
632 0,
633 0,
634 { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } /* reserved */
635 };
636
637
638 const UConverterSharedData _UTF16BEData={
639 sizeof(UConverterSharedData), ~((uint32_t) 0),
640 NULL, NULL, &_UTF16BEStaticData, FALSE, &_UTF16BEImpl,
641 0
642 };
643
644 /* UTF-16LE ----------------------------------------------------------------- */
645
646 static void
647 _UTF16LEFromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs,
648 UErrorCode *pErrorCode) {
649 UConverter *cnv;
650 const UChar *source;
651 char *target;
652 int32_t *offsets;
653
654 uint32_t targetCapacity, length, sourceIndex;
655 UChar c, trail;
656 char overflow[4];
657
658 source=pArgs->source;
659 length=(int32_t)(pArgs->sourceLimit-source);
660 if(length<=0) {
661 /* no input, nothing to do */
662 return;
663 }
664
665 cnv=pArgs->converter;
666
667 /* write the BOM if necessary */
668 if(cnv->fromUnicodeStatus==UCNV_NEED_TO_WRITE_BOM) {
669 static const char bom[]={ (char)0xff, (char)0xfe };
670 ucnv_fromUWriteBytes(cnv,
671 bom, 2,
672 &pArgs->target, pArgs->targetLimit,
673 &pArgs->offsets, -1,
674 pErrorCode);
675 cnv->fromUnicodeStatus=0;
676 }
677
678 target=pArgs->target;
679 if(target >= pArgs->targetLimit) {
680 *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
681 return;
682 }
683
684 targetCapacity=(uint32_t)(pArgs->targetLimit-pArgs->target);
685 offsets=pArgs->offsets;
686 sourceIndex=0;
687
688 /* c!=0 indicates in several places outside the main loops that a surrogate was found */
689
690 if((c=(UChar)cnv->fromUChar32)!=0 && U16_IS_TRAIL(trail=*source) && targetCapacity>=4) {
691 /* the last buffer ended with a lead surrogate, output the surrogate pair */
692 ++source;
693 --length;
694 target[0]=(uint8_t)c;
695 target[1]=(uint8_t)(c>>8);
696 target[2]=(uint8_t)trail;
697 target[3]=(uint8_t)(trail>>8);
698 target+=4;
699 targetCapacity-=4;
700 if(offsets!=NULL) {
701 *offsets++=-1;
702 *offsets++=-1;
703 *offsets++=-1;
704 *offsets++=-1;
705 }
706 sourceIndex=1;
707 cnv->fromUChar32=c=0;
708 }
709
710 if(c==0) {
711 /* copy an even number of bytes for complete UChars */
712 uint32_t count=2*length;
713 if(count>targetCapacity) {
714 count=targetCapacity&~1;
715 }
716 /* count is even */
717 targetCapacity-=count;
718 count>>=1;
719 length-=count;
720
721 if(offsets==NULL) {
722 while(count>0) {
723 c=*source++;
724 if(U16_IS_SINGLE(c)) {
725 target[0]=(uint8_t)c;
726 target[1]=(uint8_t)(c>>8);
727 target+=2;
728 } else if(U16_IS_SURROGATE_LEAD(c) && count>=2 && U16_IS_TRAIL(trail=*source)) {
729 ++source;
730 --count;
731 target[0]=(uint8_t)c;
732 target[1]=(uint8_t)(c>>8);
733 target[2]=(uint8_t)trail;
734 target[3]=(uint8_t)(trail>>8);
735 target+=4;
736 } else {
737 break;
738 }
739 --count;
740 }
741 } else {
742 while(count>0) {
743 c=*source++;
744 if(U16_IS_SINGLE(c)) {
745 target[0]=(uint8_t)c;
746 target[1]=(uint8_t)(c>>8);
747 target+=2;
748 *offsets++=sourceIndex;
749 *offsets++=sourceIndex++;
750 } else if(U16_IS_SURROGATE_LEAD(c) && count>=2 && U16_IS_TRAIL(trail=*source)) {
751 ++source;
752 --count;
753 target[0]=(uint8_t)c;
754 target[1]=(uint8_t)(c>>8);
755 target[2]=(uint8_t)trail;
756 target[3]=(uint8_t)(trail>>8);
757 target+=4;
758 *offsets++=sourceIndex;
759 *offsets++=sourceIndex;
760 *offsets++=sourceIndex;
761 *offsets++=sourceIndex;
762 sourceIndex+=2;
763 } else {
764 break;
765 }
766 --count;
767 }
768 }
769
770 if(count==0) {
771 /* done with the loop for complete UChars */
772 if(length>0 && targetCapacity>0) {
773 /*
774 * there is more input and some target capacity -
775 * it must be targetCapacity==1 because otherwise
776 * the above would have copied more;
777 * prepare for overflow output
778 */
779 if(U16_IS_SINGLE(c=*source++)) {
780 overflow[0]=(char)c;
781 overflow[1]=(char)(c>>8);
782 length=2; /* 2 bytes to output */
783 c=0;
784 /* } else { keep c for surrogate handling, length will be set there */
785 }
786 } else {
787 length=0;
788 c=0;
789 }
790 } else {
791 /* keep c for surrogate handling, length will be set there */
792 targetCapacity+=2*count;
793 }
794 } else {
795 length=0; /* from here on, length counts the bytes in overflow[] */
796 }
797
798 if(c!=0) {
799 /*
800 * c is a surrogate, and
801 * - source or target too short
802 * - or the surrogate is unmatched
803 */
804 length=0;
805 if(U16_IS_SURROGATE_LEAD(c)) {
806 if(source<pArgs->sourceLimit) {
807 if(U16_IS_TRAIL(trail=*source)) {
808 /* output the surrogate pair, will overflow (see conditions comment above) */
809 ++source;
810 overflow[0]=(char)c;
811 overflow[1]=(char)(c>>8);
812 overflow[2]=(char)trail;
813 overflow[3]=(char)(trail>>8);
814 length=4; /* 4 bytes to output */
815 c=0;
816 } else {
817 /* unmatched lead surrogate */
818 *pErrorCode=U_ILLEGAL_CHAR_FOUND;
819 }
820 } else {
821 /* see if the trail surrogate is in the next buffer */
822 }
823 } else {
824 /* unmatched trail surrogate */
825 *pErrorCode=U_ILLEGAL_CHAR_FOUND;
826 }
827 cnv->fromUChar32=c;
828 }
829
830 if(length>0) {
831 /* output length bytes with overflow (length>targetCapacity>0) */
832 ucnv_fromUWriteBytes(cnv,
833 overflow, length,
834 &target, pArgs->targetLimit,
835 &offsets, sourceIndex,
836 pErrorCode);
837 targetCapacity=(uint32_t)(pArgs->targetLimit-(char *)target);
838 }
839
840 if(U_SUCCESS(*pErrorCode) && source<pArgs->sourceLimit && targetCapacity==0) {
841 *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
842 }
843
844 /* write back the updated pointers */
845 pArgs->source=source;
846 pArgs->target=target;
847 pArgs->offsets=offsets;
848 }
849
850 static void
851 _UTF16LEToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
852 UErrorCode *pErrorCode) {
853 UConverter *cnv;
854 const uint8_t *source;
855 UChar *target;
856 int32_t *offsets;
857
858 uint32_t targetCapacity, length, count, sourceIndex;
859 UChar c, trail;
860
861 if(pArgs->converter->mode<8) {
862 _UTF16ToUnicodeWithOffsets(pArgs, pErrorCode);
863 return;
864 }
865
866 cnv=pArgs->converter;
867 source=(const uint8_t *)pArgs->source;
868 length=(int32_t)((const uint8_t *)pArgs->sourceLimit-source);
869 if(length<=0 && cnv->toUnicodeStatus==0) {
870 /* no input, nothing to do */
871 return;
872 }
873
874 target=pArgs->target;
875 if(target >= pArgs->targetLimit) {
876 *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
877 return;
878 }
879
880 targetCapacity=(uint32_t)(pArgs->targetLimit-pArgs->target);
881 offsets=pArgs->offsets;
882 sourceIndex=0;
883 c=0;
884
885 /* complete a partial UChar or pair from the last call */
886 if(cnv->toUnicodeStatus!=0) {
887 /*
888 * special case: single byte from a previous buffer,
889 * where the byte turned out not to belong to a trail surrogate
890 * and the preceding, unmatched lead surrogate was put into toUBytes[]
891 * for error handling
892 */
893 cnv->toUBytes[0]=(uint8_t)cnv->toUnicodeStatus;
894 cnv->toULength=1;
895 cnv->toUnicodeStatus=0;
896 }
897 if((count=cnv->toULength)!=0) {
898 uint8_t *p=cnv->toUBytes;
899 do {
900 p[count++]=*source++;
901 ++sourceIndex;
902 --length;
903 if(count==2) {
904 c=((UChar)p[1]<<8)|p[0];
905 if(U16_IS_SINGLE(c)) {
906 /* output the BMP code point */
907 *target++=c;
908 if(offsets!=NULL) {
909 *offsets++=-1;
910 }
911 --targetCapacity;
912 count=0;
913 c=0;
914 break;
915 } else if(U16_IS_SURROGATE_LEAD(c)) {
916 /* continue collecting bytes for the trail surrogate */
917 c=0; /* avoid unnecessary surrogate handling below */
918 } else {
919 /* fall through to error handling for an unmatched trail surrogate */
920 break;
921 }
922 } else if(count==4) {
923 c=((UChar)p[1]<<8)|p[0];
924 trail=((UChar)p[3]<<8)|p[2];
925 if(U16_IS_TRAIL(trail)) {
926 /* output the surrogate pair */
927 *target++=c;
928 if(targetCapacity>=2) {
929 *target++=trail;
930 if(offsets!=NULL) {
931 *offsets++=-1;
932 *offsets++=-1;
933 }
934 targetCapacity-=2;
935 } else /* targetCapacity==1 */ {
936 targetCapacity=0;
937 cnv->UCharErrorBuffer[0]=trail;
938 cnv->UCharErrorBufferLength=1;
939 *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
940 }
941 count=0;
942 c=0;
943 break;
944 } else {
945 /* unmatched lead surrogate, handle here for consistent toUBytes[] */
946 *pErrorCode=U_ILLEGAL_CHAR_FOUND;
947
948 /* back out reading the code unit after it */
949 if(((const uint8_t *)pArgs->source-source)>=2) {
950 source-=2;
951 } else {
952 /*
953 * if the trail unit's first byte was in a previous buffer, then
954 * we need to put it into a special place because toUBytes[] will be
955 * used for the lead unit's bytes
956 */
957 cnv->toUnicodeStatus=0x100|p[2];
958 --source;
959 }
960 cnv->toULength=2;
961
962 /* write back the updated pointers */
963 pArgs->source=(const char *)source;
964 pArgs->target=target;
965 pArgs->offsets=offsets;
966 return;
967 }
968 }
969 } while(length>0);
970 cnv->toULength=(int8_t)count;
971 }
972
973 /* copy an even number of bytes for complete UChars */
974 count=2*targetCapacity;
975 if(count>length) {
976 count=length&~1;
977 }
978 if(c==0 && count>0) {
979 length-=count;
980 count>>=1;
981 targetCapacity-=count;
982 if(offsets==NULL) {
983 do {
984 c=((UChar)source[1]<<8)|source[0];
985 source+=2;
986 if(U16_IS_SINGLE(c)) {
987 *target++=c;
988 } else if(U16_IS_SURROGATE_LEAD(c) && count>=2 &&
989 U16_IS_TRAIL(trail=((UChar)source[1]<<8)|source[0])
990 ) {
991 source+=2;
992 --count;
993 *target++=c;
994 *target++=trail;
995 } else {
996 break;
997 }
998 } while(--count>0);
999 } else {
1000 do {
1001 c=((UChar)source[1]<<8)|source[0];
1002 source+=2;
1003 if(U16_IS_SINGLE(c)) {
1004 *target++=c;
1005 *offsets++=sourceIndex;
1006 sourceIndex+=2;
1007 } else if(U16_IS_SURROGATE_LEAD(c) && count>=2 &&
1008 U16_IS_TRAIL(trail=((UChar)source[1]<<8)|source[0])
1009 ) {
1010 source+=2;
1011 --count;
1012 *target++=c;
1013 *target++=trail;
1014 *offsets++=sourceIndex;
1015 *offsets++=sourceIndex;
1016 sourceIndex+=4;
1017 } else {
1018 break;
1019 }
1020 } while(--count>0);
1021 }
1022
1023 if(count==0) {
1024 /* done with the loop for complete UChars */
1025 c=0;
1026 } else {
1027 /* keep c for surrogate handling, trail will be set there */
1028 length+=2*(count-1); /* one more byte pair was consumed than count decremented */
1029 targetCapacity+=count;
1030 }
1031 }
1032
1033 if(c!=0) {
1034 /*
1035 * c is a surrogate, and
1036 * - source or target too short
1037 * - or the surrogate is unmatched
1038 */
1039 cnv->toUBytes[0]=(uint8_t)c;
1040 cnv->toUBytes[1]=(uint8_t)(c>>8);
1041 cnv->toULength=2;
1042
1043 if(U16_IS_SURROGATE_LEAD(c)) {
1044 if(length>=2) {
1045 if(U16_IS_TRAIL(trail=((UChar)source[1]<<8)|source[0])) {
1046 /* output the surrogate pair, will overflow (see conditions comment above) */
1047 source+=2;
1048 length-=2;
1049 *target++=c;
1050 if(offsets!=NULL) {
1051 *offsets++=sourceIndex;
1052 }
1053 cnv->UCharErrorBuffer[0]=trail;
1054 cnv->UCharErrorBufferLength=1;
1055 cnv->toULength=0;
1056 *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
1057 } else {
1058 /* unmatched lead surrogate */
1059 *pErrorCode=U_ILLEGAL_CHAR_FOUND;
1060 }
1061 } else {
1062 /* see if the trail surrogate is in the next buffer */
1063 }
1064 } else {
1065 /* unmatched trail surrogate */
1066 *pErrorCode=U_ILLEGAL_CHAR_FOUND;
1067 }
1068 }
1069
1070 if(U_SUCCESS(*pErrorCode)) {
1071 /* check for a remaining source byte */
1072 if(length>0) {
1073 if(targetCapacity==0) {
1074 *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
1075 } else {
1076 /* it must be length==1 because otherwise the above would have copied more */
1077 cnv->toUBytes[cnv->toULength++]=*source++;
1078 }
1079 }
1080 }
1081
1082 /* write back the updated pointers */
1083 pArgs->source=(const char *)source;
1084 pArgs->target=target;
1085 pArgs->offsets=offsets;
1086 }
1087
1088 static UChar32
1089 _UTF16LEGetNextUChar(UConverterToUnicodeArgs *pArgs, UErrorCode *err) {
1090 const uint8_t *s, *sourceLimit;
1091 UChar32 c;
1092
1093 if(pArgs->converter->mode<8) {
1094 return UCNV_GET_NEXT_UCHAR_USE_TO_U;
1095 }
1096
1097 s=(const uint8_t *)pArgs->source;
1098 sourceLimit=(const uint8_t *)pArgs->sourceLimit;
1099
1100 if(s>=sourceLimit) {
1101 /* no input */
1102 *err=U_INDEX_OUTOFBOUNDS_ERROR;
1103 return 0xffff;
1104 }
1105
1106 if(s+2>sourceLimit) {
1107 /* only one byte: truncated UChar */
1108 pArgs->converter->toUBytes[0]=*s++;
1109 pArgs->converter->toULength=1;
1110 pArgs->source=(const char *)s;
1111 *err = U_TRUNCATED_CHAR_FOUND;
1112 return 0xffff;
1113 }
1114
1115 /* get one UChar */
1116 c=((UChar32)s[1]<<8)|*s;
1117 s+=2;
1118
1119 /* check for a surrogate pair */
1120 if(U_IS_SURROGATE(c)) {
1121 if(U16_IS_SURROGATE_LEAD(c)) {
1122 if(s+2<=sourceLimit) {
1123 UChar trail;
1124
1125 /* get a second UChar and see if it is a trail surrogate */
1126 trail=((UChar)s[1]<<8)|*s;
1127 if(U16_IS_TRAIL(trail)) {
1128 c=U16_GET_SUPPLEMENTARY(c, trail);
1129 s+=2;
1130 } else {
1131 /* unmatched lead surrogate */
1132 c=-2;
1133 }
1134 } else {
1135 /* too few (2 or 3) bytes for a surrogate pair: truncated code point */
1136 uint8_t *bytes=pArgs->converter->toUBytes;
1137 s-=2;
1138 pArgs->converter->toULength=(int8_t)(sourceLimit-s);
1139 do {
1140 *bytes++=*s++;
1141 } while(s<sourceLimit);
1142
1143 c=0xffff;
1144 *err=U_TRUNCATED_CHAR_FOUND;
1145 }
1146 } else {
1147 /* unmatched trail surrogate */
1148 c=-2;
1149 }
1150
1151 if(c<0) {
1152 /* write the unmatched surrogate */
1153 uint8_t *bytes=pArgs->converter->toUBytes;
1154 pArgs->converter->toULength=2;
1155 *bytes=*(s-2);
1156 bytes[1]=*(s-1);
1157
1158 c=0xffff;
1159 *err=U_ILLEGAL_CHAR_FOUND;
1160 }
1161 }
1162
1163 pArgs->source=(const char *)s;
1164 return c;
1165 }
1166
1167 static void
1168 _UTF16LEReset(UConverter *cnv, UConverterResetChoice choice) {
1169 if(choice<=UCNV_RESET_TO_UNICODE) {
1170 /* reset toUnicode state */
1171 if(UCNV_GET_VERSION(cnv)==0) {
1172 cnv->mode=8; /* no BOM handling */
1173 } else {
1174 cnv->mode=0; /* Java-specific "UnicodeLittle" requires LE BOM or no BOM */
1175 }
1176 }
1177 if(choice!=UCNV_RESET_TO_UNICODE && UCNV_GET_VERSION(cnv)==1) {
1178 /* reset fromUnicode for "UnicodeLittle": prepare to output the UTF-16LE BOM */
1179 cnv->fromUnicodeStatus=UCNV_NEED_TO_WRITE_BOM;
1180 }
1181 }
1182
1183 static void
1184 _UTF16LEOpen(UConverter *cnv,
1185 UConverterLoadArgs *pArgs,
1186 UErrorCode *pErrorCode) {
1187 if(UCNV_GET_VERSION(cnv)<=1) {
1188 _UTF16LEReset(cnv, UCNV_RESET_BOTH);
1189 } else {
1190 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
1191 }
1192 }
1193
1194 static const char *
1195 _UTF16LEGetName(const UConverter *cnv) {
1196 if(UCNV_GET_VERSION(cnv)==0) {
1197 return "UTF-16LE";
1198 } else {
1199 return "UTF-16LE,version=1";
1200 }
1201 }
1202
1203 static const UConverterImpl _UTF16LEImpl={
1204 UCNV_UTF16_LittleEndian,
1205
1206 NULL,
1207 NULL,
1208
1209 _UTF16LEOpen,
1210 NULL,
1211 _UTF16LEReset,
1212
1213 _UTF16LEToUnicodeWithOffsets,
1214 _UTF16LEToUnicodeWithOffsets,
1215 _UTF16LEFromUnicodeWithOffsets,
1216 _UTF16LEFromUnicodeWithOffsets,
1217 _UTF16LEGetNextUChar,
1218
1219 NULL,
1220 _UTF16LEGetName,
1221 NULL,
1222 NULL,
1223 ucnv_getNonSurrogateUnicodeSet
1224 };
1225
1226
1227 static const UConverterStaticData _UTF16LEStaticData={
1228 sizeof(UConverterStaticData),
1229 "UTF-16LE",
1230 1202, UCNV_IBM, UCNV_UTF16_LittleEndian, 2, 2,
1231 { 0xfd, 0xff, 0, 0 },2,FALSE,FALSE,
1232 0,
1233 0,
1234 { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } /* reserved */
1235 };
1236
1237
1238 const UConverterSharedData _UTF16LEData={
1239 sizeof(UConverterSharedData), ~((uint32_t) 0),
1240 NULL, NULL, &_UTF16LEStaticData, FALSE, &_UTF16LEImpl,
1241 0
1242 };
1243
1244 /* UTF-16 (Detect BOM) ------------------------------------------------------ */
1245
1246 /*
1247 * Detect a BOM at the beginning of the stream and select UTF-16BE or UTF-16LE
1248 * accordingly.
1249 * This is a simpler version of the UTF-32 converter, with
1250 * fewer states for shorter BOMs.
1251 *
1252 * State values:
1253 * 0 initial state
1254 * 1 saw first byte
1255 * 2..5 -
1256 * 6..7 see _UTF16ToUnicodeWithOffsets() comments in state 1
1257 * 8 UTF-16BE mode
1258 * 9 UTF-16LE mode
1259 *
1260 * During detection: state==number of initial bytes seen so far.
1261 *
1262 * On output, emit U+FEFF as the first code point.
1263 *
1264 * Variants:
1265 * - UTF-16,version=1 (Java "Unicode" encoding) treats a missing BOM as an error.
1266 * - UTF-16BE,version=1 (Java "UnicodeBig" encoding) and
1267 * UTF-16LE,version=1 (Java "UnicodeLittle" encoding) treat a reverse BOM as an error.
1268 */
1269
1270 static void
1271 _UTF16Reset(UConverter *cnv, UConverterResetChoice choice) {
1272 if(choice<=UCNV_RESET_TO_UNICODE) {
1273 /* reset toUnicode: state=0 */
1274 cnv->mode=0;
1275 }
1276 if(choice!=UCNV_RESET_TO_UNICODE) {
1277 /* reset fromUnicode: prepare to output the UTF-16PE BOM */
1278 cnv->fromUnicodeStatus=UCNV_NEED_TO_WRITE_BOM;
1279 }
1280 }
1281
1282 static const UConverterSharedData _UTF16v2Data;
1283
1284 static void
1285 _UTF16Open(UConverter *cnv,
1286 UConverterLoadArgs *pArgs,
1287 UErrorCode *pErrorCode) {
1288 if(UCNV_GET_VERSION(cnv)<=2) {
1289 if(UCNV_GET_VERSION(cnv)==2 && !pArgs->onlyTestIsLoadable) {
1290 /*
1291 * Switch implementation, and switch the staticData that's different
1292 * and was copied into the UConverter.
1293 * (See ucnv_createConverterFromSharedData() in ucnv_bld.c.)
1294 * UTF-16,version=2 fromUnicode() always writes a big-endian byte stream.
1295 */
1296 cnv->sharedData=(UConverterSharedData*)&_UTF16v2Data;
1297 uprv_memcpy(cnv->subChars, _UTF16v2Data.staticData->subChar, UCNV_MAX_SUBCHAR_LEN);
1298 }
1299 _UTF16Reset(cnv, UCNV_RESET_BOTH);
1300 } else {
1301 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
1302 }
1303 }
1304
1305 static const char *
1306 _UTF16GetName(const UConverter *cnv) {
1307 if(UCNV_GET_VERSION(cnv)==0) {
1308 return "UTF-16";
1309 } else if(UCNV_GET_VERSION(cnv)==1) {
1310 return "UTF-16,version=1";
1311 } else {
1312 return "UTF-16,version=2";
1313 }
1314 }
1315
1316 const UConverterSharedData _UTF16Data;
1317
1318 #define IS_UTF16BE(cnv) ((cnv)->sharedData==&_UTF16BEData)
1319 #define IS_UTF16LE(cnv) ((cnv)->sharedData==&_UTF16LEData)
1320 #define IS_UTF16(cnv) ((cnv)->sharedData==&_UTF16Data || (cnv)->sharedData==&_UTF16v2Data)
1321
1322 static void
1323 _UTF16ToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
1324 UErrorCode *pErrorCode) {
1325 UConverter *cnv=pArgs->converter;
1326 const char *source=pArgs->source;
1327 const char *sourceLimit=pArgs->sourceLimit;
1328 int32_t *offsets=pArgs->offsets;
1329
1330 int32_t state, offsetDelta;
1331 uint8_t b;
1332
1333 state=cnv->mode;
1334
1335 /*
1336 * If we detect a BOM in this buffer, then we must add the BOM size to the
1337 * offsets because the actual converter function will not see and count the BOM.
1338 * offsetDelta will have the number of the BOM bytes that are in the current buffer.
1339 */
1340 offsetDelta=0;
1341
1342 while(source<sourceLimit && U_SUCCESS(*pErrorCode)) {
1343 switch(state) {
1344 case 0:
1345 cnv->toUBytes[0]=(uint8_t)*source++;
1346 cnv->toULength=1;
1347 state=1;
1348 break;
1349 case 1:
1350 /*
1351 * Only inside this switch case can the state variable
1352 * temporarily take two additional values:
1353 * 6: BOM error, continue with BE
1354 * 7: BOM error, continue with LE
1355 */
1356 b=*source;
1357 if(cnv->toUBytes[0]==0xfe && b==0xff) {
1358 if(IS_UTF16LE(cnv)) {
1359 state=7; /* illegal reverse BOM for Java "UnicodeLittle" */
1360 } else {
1361 state=8; /* detect UTF-16BE */
1362 }
1363 } else if(cnv->toUBytes[0]==0xff && b==0xfe) {
1364 if(IS_UTF16BE(cnv)) {
1365 state=6; /* illegal reverse BOM for Java "UnicodeBig" */
1366 } else {
1367 state=9; /* detect UTF-16LE */
1368 }
1369 } else if((IS_UTF16(cnv) && UCNV_GET_VERSION(cnv)==1)) {
1370 state=6; /* illegal missing BOM for Java "Unicode" */
1371 }
1372 if(state>=8) {
1373 /* BOM detected, consume it */
1374 ++source;
1375 cnv->toULength=0;
1376 offsetDelta=(int32_t)(source-pArgs->source);
1377 } else if(state<6) {
1378 /* ok: no BOM, and not a reverse BOM */
1379 if(source!=pArgs->source) {
1380 /* reset the source for a correct first offset */
1381 source=pArgs->source;
1382 cnv->toULength=0;
1383 }
1384 if(IS_UTF16LE(cnv)) {
1385 /* Make Java "UnicodeLittle" default to LE. */
1386 state=9;
1387 } else {
1388 /* Make standard UTF-16 and Java "UnicodeBig" default to BE. */
1389 state=8;
1390 }
1391 } else {
1392 /*
1393 * error: missing BOM, or reverse BOM
1394 * UTF-16,version=1: Java-specific "Unicode" requires a BOM.
1395 * UTF-16BE,version=1: Java-specific "UnicodeBig" requires a BE BOM or no BOM.
1396 * UTF-16LE,version=1: Java-specific "UnicodeLittle" requires an LE BOM or no BOM.
1397 */
1398 /* report the non-BOM or reverse BOM as an illegal sequence */
1399 cnv->toUBytes[1]=b;
1400 cnv->toULength=2;
1401 pArgs->source=source+1;
1402 /* continue with conversion if the callback resets the error */
1403 /*
1404 * Make Java "Unicode" default to BE like standard UTF-16.
1405 * Make Java "UnicodeBig" and "UnicodeLittle" default
1406 * to their normal endiannesses.
1407 */
1408 cnv->mode=state+2;
1409 *pErrorCode=U_ILLEGAL_ESCAPE_SEQUENCE;
1410 return;
1411 }
1412 /* convert the rest of the stream */
1413 cnv->mode=state;
1414 continue;
1415 case 8:
1416 /* call UTF-16BE */
1417 pArgs->source=source;
1418 _UTF16BEToUnicodeWithOffsets(pArgs, pErrorCode);
1419 source=pArgs->source;
1420 break;
1421 case 9:
1422 /* call UTF-16LE */
1423 pArgs->source=source;
1424 _UTF16LEToUnicodeWithOffsets(pArgs, pErrorCode);
1425 source=pArgs->source;
1426 break;
1427 default:
1428 break; /* does not occur */
1429 }
1430 }
1431
1432 /* add BOM size to offsets - see comment at offsetDelta declaration */
1433 if(offsets!=NULL && offsetDelta!=0) {
1434 int32_t *offsetsLimit=pArgs->offsets;
1435 while(offsets<offsetsLimit) {
1436 *offsets++ += offsetDelta;
1437 }
1438 }
1439
1440 pArgs->source=source;
1441
1442 if(source==sourceLimit && pArgs->flush) {
1443 /* handle truncated input */
1444 switch(state) {
1445 case 0:
1446 break; /* no input at all, nothing to do */
1447 case 8:
1448 _UTF16BEToUnicodeWithOffsets(pArgs, pErrorCode);
1449 break;
1450 case 9:
1451 _UTF16LEToUnicodeWithOffsets(pArgs, pErrorCode);
1452 break;
1453 default:
1454 /* 0<state<8: framework will report truncation, nothing to do here */
1455 break;
1456 }
1457 }
1458
1459 cnv->mode=state;
1460 }
1461
1462 static UChar32
1463 _UTF16GetNextUChar(UConverterToUnicodeArgs *pArgs,
1464 UErrorCode *pErrorCode) {
1465 switch(pArgs->converter->mode) {
1466 case 8:
1467 return _UTF16BEGetNextUChar(pArgs, pErrorCode);
1468 case 9:
1469 return _UTF16LEGetNextUChar(pArgs, pErrorCode);
1470 default:
1471 return UCNV_GET_NEXT_UCHAR_USE_TO_U;
1472 }
1473 }
1474
1475 static const UConverterImpl _UTF16Impl = {
1476 UCNV_UTF16,
1477
1478 NULL,
1479 NULL,
1480
1481 _UTF16Open,
1482 NULL,
1483 _UTF16Reset,
1484
1485 _UTF16ToUnicodeWithOffsets,
1486 _UTF16ToUnicodeWithOffsets,
1487 _UTF16PEFromUnicodeWithOffsets,
1488 _UTF16PEFromUnicodeWithOffsets,
1489 _UTF16GetNextUChar,
1490
1491 NULL, /* ### TODO implement getStarters for all Unicode encodings?! */
1492 _UTF16GetName,
1493 NULL,
1494 NULL,
1495 ucnv_getNonSurrogateUnicodeSet
1496 };
1497
1498 static const UConverterStaticData _UTF16StaticData = {
1499 sizeof(UConverterStaticData),
1500 "UTF-16",
1501 1204, /* CCSID for BOM sensitive UTF-16 */
1502 UCNV_IBM, UCNV_UTF16, 2, 2,
1503 #if U_IS_BIG_ENDIAN
1504 { 0xff, 0xfd, 0, 0 }, 2,
1505 #else
1506 { 0xfd, 0xff, 0, 0 }, 2,
1507 #endif
1508 FALSE, FALSE,
1509 0,
1510 0,
1511 { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } /* reserved */
1512 };
1513
1514 const UConverterSharedData _UTF16Data = {
1515 sizeof(UConverterSharedData), ~((uint32_t) 0),
1516 NULL, NULL, &_UTF16StaticData, FALSE, &_UTF16Impl,
1517 0
1518 };
1519
1520 static const UConverterImpl _UTF16v2Impl = {
1521 UCNV_UTF16,
1522
1523 NULL,
1524 NULL,
1525
1526 _UTF16Open,
1527 NULL,
1528 _UTF16Reset,
1529
1530 _UTF16ToUnicodeWithOffsets,
1531 _UTF16ToUnicodeWithOffsets,
1532 _UTF16BEFromUnicodeWithOffsets,
1533 _UTF16BEFromUnicodeWithOffsets,
1534 _UTF16GetNextUChar,
1535
1536 NULL, /* ### TODO implement getStarters for all Unicode encodings?! */
1537 _UTF16GetName,
1538 NULL,
1539 NULL,
1540 ucnv_getNonSurrogateUnicodeSet
1541 };
1542
1543 static const UConverterStaticData _UTF16v2StaticData = {
1544 sizeof(UConverterStaticData),
1545 "UTF-16,version=2",
1546 1204, /* CCSID for BOM sensitive UTF-16 */
1547 UCNV_IBM, UCNV_UTF16, 2, 2,
1548 { 0xff, 0xfd, 0, 0 }, 2,
1549 FALSE, FALSE,
1550 0,
1551 0,
1552 { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } /* reserved */
1553 };
1554
1555 static const UConverterSharedData _UTF16v2Data = {
1556 sizeof(UConverterSharedData), ~((uint32_t) 0),
1557 NULL, NULL, &_UTF16v2StaticData, FALSE, &_UTF16v2Impl,
1558 0
1559 };
1560
1561 #endif

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial