The Tor Browser / file comparison

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

intl/icu/source/common/ucnvscsu.c

branch
TOR_BUG_3246
changeset 4
fc2d59ddac77
equal deleted inserted replaced
-1:000000000000 0:229ea68ea62d
1 /*
2 ******************************************************************************
3 *
4 * Copyright (C) 2000-2011, International Business Machines
5 * Corporation and others. All Rights Reserved.
6 *
7 ******************************************************************************
8 * file name: ucnvscsu.c
9 * encoding: US-ASCII
10 * tab size: 8 (not used)
11 * indentation:4
12 *
13 * created on: 2000nov18
14 * created by: Markus W. Scherer
15 *
16 * This is an implementation of the Standard Compression Scheme for Unicode
17 * as defined in http://www.unicode.org/unicode/reports/tr6/ .
18 * Reserved commands and window settings are treated as illegal sequences and
19 * will result in callback calls.
20 */
21
22 #include "unicode/utypes.h"
23
24 #if !UCONFIG_NO_CONVERSION
25
26 #include "unicode/ucnv.h"
27 #include "unicode/ucnv_cb.h"
28 #include "unicode/utf16.h"
29 #include "ucnv_bld.h"
30 #include "ucnv_cnv.h"
31 #include "cmemory.h"
32
33 /* SCSU definitions --------------------------------------------------------- */
34
35 /* SCSU command byte values */
36 enum {
37 SQ0=0x01, /* Quote from window pair 0 */
38 SQ7=0x08, /* Quote from window pair 7 */
39 SDX=0x0B, /* Define a window as extended */
40 Srs=0x0C, /* reserved */
41 SQU=0x0E, /* Quote a single Unicode character */
42 SCU=0x0F, /* Change to Unicode mode */
43 SC0=0x10, /* Select window 0 */
44 SC7=0x17, /* Select window 7 */
45 SD0=0x18, /* Define and select window 0 */
46 SD7=0x1F, /* Define and select window 7 */
47
48 UC0=0xE0, /* Select window 0 */
49 UC7=0xE7, /* Select window 7 */
50 UD0=0xE8, /* Define and select window 0 */
51 UD7=0xEF, /* Define and select window 7 */
52 UQU=0xF0, /* Quote a single Unicode character */
53 UDX=0xF1, /* Define a Window as extended */
54 Urs=0xF2 /* reserved */
55 };
56
57 enum {
58 /*
59 * Unicode code points from 3400 to E000 are not adressible by
60 * dynamic window, since in these areas no short run alphabets are
61 * found. Therefore add gapOffset to all values from gapThreshold.
62 */
63 gapThreshold=0x68,
64 gapOffset=0xAC00,
65
66 /* values between reservedStart and fixedThreshold are reserved */
67 reservedStart=0xA8,
68
69 /* use table of predefined fixed offsets for values from fixedThreshold */
70 fixedThreshold=0xF9
71 };
72
73 /* constant offsets for the 8 static windows */
74 static const uint32_t staticOffsets[8]={
75 0x0000, /* ASCII for quoted tags */
76 0x0080, /* Latin - 1 Supplement (for access to punctuation) */
77 0x0100, /* Latin Extended-A */
78 0x0300, /* Combining Diacritical Marks */
79 0x2000, /* General Punctuation */
80 0x2080, /* Currency Symbols */
81 0x2100, /* Letterlike Symbols and Number Forms */
82 0x3000 /* CJK Symbols and punctuation */
83 };
84
85 /* initial offsets for the 8 dynamic (sliding) windows */
86 static const uint32_t initialDynamicOffsets[8]={
87 0x0080, /* Latin-1 */
88 0x00C0, /* Latin Extended A */
89 0x0400, /* Cyrillic */
90 0x0600, /* Arabic */
91 0x0900, /* Devanagari */
92 0x3040, /* Hiragana */
93 0x30A0, /* Katakana */
94 0xFF00 /* Fullwidth ASCII */
95 };
96
97 /* Table of fixed predefined Offsets */
98 static const uint32_t fixedOffsets[]={
99 /* 0xF9 */ 0x00C0, /* Latin-1 Letters + half of Latin Extended A */
100 /* 0xFA */ 0x0250, /* IPA extensions */
101 /* 0xFB */ 0x0370, /* Greek */
102 /* 0xFC */ 0x0530, /* Armenian */
103 /* 0xFD */ 0x3040, /* Hiragana */
104 /* 0xFE */ 0x30A0, /* Katakana */
105 /* 0xFF */ 0xFF60 /* Halfwidth Katakana */
106 };
107
108 /* state values */
109 enum {
110 readCommand,
111 quotePairOne,
112 quotePairTwo,
113 quoteOne,
114 definePairOne,
115 definePairTwo,
116 defineOne
117 };
118
119 typedef struct SCSUData {
120 /* dynamic window offsets, intitialize to default values from initialDynamicOffsets */
121 uint32_t toUDynamicOffsets[8];
122 uint32_t fromUDynamicOffsets[8];
123
124 /* state machine state - toUnicode */
125 UBool toUIsSingleByteMode;
126 uint8_t toUState;
127 int8_t toUQuoteWindow, toUDynamicWindow;
128 uint8_t toUByteOne;
129 uint8_t toUPadding[3];
130
131 /* state machine state - fromUnicode */
132 UBool fromUIsSingleByteMode;
133 int8_t fromUDynamicWindow;
134
135 /*
136 * windowUse[] keeps track of the use of the dynamic windows:
137 * At nextWindowUseIndex there is the least recently used window,
138 * and the following windows (in a wrapping manner) are more and more
139 * recently used.
140 * At nextWindowUseIndex-1 there is the most recently used window.
141 */
142 uint8_t locale;
143 int8_t nextWindowUseIndex;
144 int8_t windowUse[8];
145 } SCSUData;
146
147 static const int8_t initialWindowUse[8]={ 7, 0, 3, 2, 4, 5, 6, 1 };
148 static const int8_t initialWindowUse_ja[8]={ 3, 2, 4, 1, 0, 7, 5, 6 };
149
150 enum {
151 lGeneric, l_ja
152 };
153
154 /* SCSU setup functions ----------------------------------------------------- */
155
156 static void
157 _SCSUReset(UConverter *cnv, UConverterResetChoice choice) {
158 SCSUData *scsu=(SCSUData *)cnv->extraInfo;
159
160 if(choice<=UCNV_RESET_TO_UNICODE) {
161 /* reset toUnicode */
162 uprv_memcpy(scsu->toUDynamicOffsets, initialDynamicOffsets, 32);
163
164 scsu->toUIsSingleByteMode=TRUE;
165 scsu->toUState=readCommand;
166 scsu->toUQuoteWindow=scsu->toUDynamicWindow=0;
167 scsu->toUByteOne=0;
168
169 cnv->toULength=0;
170 }
171 if(choice!=UCNV_RESET_TO_UNICODE) {
172 /* reset fromUnicode */
173 uprv_memcpy(scsu->fromUDynamicOffsets, initialDynamicOffsets, 32);
174
175 scsu->fromUIsSingleByteMode=TRUE;
176 scsu->fromUDynamicWindow=0;
177
178 scsu->nextWindowUseIndex=0;
179 switch(scsu->locale) {
180 case l_ja:
181 uprv_memcpy(scsu->windowUse, initialWindowUse_ja, 8);
182 break;
183 default:
184 uprv_memcpy(scsu->windowUse, initialWindowUse, 8);
185 break;
186 }
187
188 cnv->fromUChar32=0;
189 }
190 }
191
192 static void
193 _SCSUOpen(UConverter *cnv,
194 UConverterLoadArgs *pArgs,
195 UErrorCode *pErrorCode) {
196 const char *locale=pArgs->locale;
197 if(pArgs->onlyTestIsLoadable) {
198 return;
199 }
200 cnv->extraInfo=uprv_malloc(sizeof(SCSUData));
201 if(cnv->extraInfo!=NULL) {
202 if(locale!=NULL && locale[0]=='j' && locale[1]=='a' && (locale[2]==0 || locale[2]=='_')) {
203 ((SCSUData *)cnv->extraInfo)->locale=l_ja;
204 } else {
205 ((SCSUData *)cnv->extraInfo)->locale=lGeneric;
206 }
207 _SCSUReset(cnv, UCNV_RESET_BOTH);
208 } else {
209 *pErrorCode=U_MEMORY_ALLOCATION_ERROR;
210 }
211
212 /* Set the substitution character U+fffd as a Unicode string. */
213 cnv->subUChars[0]=0xfffd;
214 cnv->subCharLen=-1;
215 }
216
217 static void
218 _SCSUClose(UConverter *cnv) {
219 if(cnv->extraInfo!=NULL) {
220 if(!cnv->isExtraLocal) {
221 uprv_free(cnv->extraInfo);
222 }
223 cnv->extraInfo=NULL;
224 }
225 }
226
227 /* SCSU-to-Unicode conversion functions ------------------------------------- */
228
229 static void
230 _SCSUToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
231 UErrorCode *pErrorCode) {
232 UConverter *cnv;
233 SCSUData *scsu;
234 const uint8_t *source, *sourceLimit;
235 UChar *target;
236 const UChar *targetLimit;
237 int32_t *offsets;
238 UBool isSingleByteMode;
239 uint8_t state, byteOne;
240 int8_t quoteWindow, dynamicWindow;
241
242 int32_t sourceIndex, nextSourceIndex;
243
244 uint8_t b;
245
246 /* set up the local pointers */
247 cnv=pArgs->converter;
248 scsu=(SCSUData *)cnv->extraInfo;
249
250 source=(const uint8_t *)pArgs->source;
251 sourceLimit=(const uint8_t *)pArgs->sourceLimit;
252 target=pArgs->target;
253 targetLimit=pArgs->targetLimit;
254 offsets=pArgs->offsets;
255
256 /* get the state machine state */
257 isSingleByteMode=scsu->toUIsSingleByteMode;
258 state=scsu->toUState;
259 quoteWindow=scsu->toUQuoteWindow;
260 dynamicWindow=scsu->toUDynamicWindow;
261 byteOne=scsu->toUByteOne;
262
263 /* sourceIndex=-1 if the current character began in the previous buffer */
264 sourceIndex=state==readCommand ? 0 : -1;
265 nextSourceIndex=0;
266
267 /*
268 * conversion "loop"
269 *
270 * For performance, this is not a normal C loop.
271 * Instead, there are two code blocks for the two SCSU modes.
272 * The function branches to either one, and a change of the mode is done with a goto to
273 * the other branch.
274 *
275 * Each branch has two conventional loops:
276 * - a fast-path loop for the most common codes in the mode
277 * - a loop for all other codes in the mode
278 * When the fast-path runs into a code that it cannot handle, its loop ends and it
279 * runs into the following loop to handle the other codes.
280 * The end of the input or output buffer is also handled by the slower loop.
281 * The slow loop jumps (goto) to the fast-path loop again as soon as possible.
282 *
283 * The callback handling is done by returning with an error code.
284 * The conversion framework actually calls the callback function.
285 */
286 if(isSingleByteMode) {
287 /* fast path for single-byte mode */
288 if(state==readCommand) {
289 fastSingle:
290 while(source<sourceLimit && target<targetLimit && (b=*source)>=0x20) {
291 ++source;
292 ++nextSourceIndex;
293 if(b<=0x7f) {
294 /* write US-ASCII graphic character or DEL */
295 *target++=(UChar)b;
296 if(offsets!=NULL) {
297 *offsets++=sourceIndex;
298 }
299 } else {
300 /* write from dynamic window */
301 uint32_t c=scsu->toUDynamicOffsets[dynamicWindow]+(b&0x7f);
302 if(c<=0xffff) {
303 *target++=(UChar)c;
304 if(offsets!=NULL) {
305 *offsets++=sourceIndex;
306 }
307 } else {
308 /* output surrogate pair */
309 *target++=(UChar)(0xd7c0+(c>>10));
310 if(target<targetLimit) {
311 *target++=(UChar)(0xdc00|(c&0x3ff));
312 if(offsets!=NULL) {
313 *offsets++=sourceIndex;
314 *offsets++=sourceIndex;
315 }
316 } else {
317 /* target overflow */
318 if(offsets!=NULL) {
319 *offsets++=sourceIndex;
320 }
321 cnv->UCharErrorBuffer[0]=(UChar)(0xdc00|(c&0x3ff));
322 cnv->UCharErrorBufferLength=1;
323 *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
324 goto endloop;
325 }
326 }
327 }
328 sourceIndex=nextSourceIndex;
329 }
330 }
331
332 /* normal state machine for single-byte mode, minus handling for what fastSingle covers */
333 singleByteMode:
334 while(source<sourceLimit) {
335 if(target>=targetLimit) {
336 /* target is full */
337 *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
338 break;
339 }
340 b=*source++;
341 ++nextSourceIndex;
342 switch(state) {
343 case readCommand:
344 /* redundant conditions are commented out */
345 /* here: b<0x20 because otherwise we would be in fastSingle */
346 if((1UL<<b)&0x2601 /* binary 0010 0110 0000 0001, check for b==0xd || b==0xa || b==9 || b==0 */) {
347 /* CR/LF/TAB/NUL */
348 *target++=(UChar)b;
349 if(offsets!=NULL) {
350 *offsets++=sourceIndex;
351 }
352 sourceIndex=nextSourceIndex;
353 goto fastSingle;
354 } else if(SC0<=b) {
355 if(b<=SC7) {
356 dynamicWindow=(int8_t)(b-SC0);
357 sourceIndex=nextSourceIndex;
358 goto fastSingle;
359 } else /* if(SD0<=b && b<=SD7) */ {
360 dynamicWindow=(int8_t)(b-SD0);
361 state=defineOne;
362 }
363 } else if(/* SQ0<=b && */ b<=SQ7) {
364 quoteWindow=(int8_t)(b-SQ0);
365 state=quoteOne;
366 } else if(b==SDX) {
367 state=definePairOne;
368 } else if(b==SQU) {
369 state=quotePairOne;
370 } else if(b==SCU) {
371 sourceIndex=nextSourceIndex;
372 isSingleByteMode=FALSE;
373 goto fastUnicode;
374 } else /* Srs */ {
375 /* callback(illegal) */
376 *pErrorCode=U_ILLEGAL_CHAR_FOUND;
377 cnv->toUBytes[0]=b;
378 cnv->toULength=1;
379 goto endloop;
380 }
381
382 /* store the first byte of a multibyte sequence in toUBytes[] */
383 cnv->toUBytes[0]=b;
384 cnv->toULength=1;
385 break;
386 case quotePairOne:
387 byteOne=b;
388 cnv->toUBytes[1]=b;
389 cnv->toULength=2;
390 state=quotePairTwo;
391 break;
392 case quotePairTwo:
393 *target++=(UChar)((byteOne<<8)|b);
394 if(offsets!=NULL) {
395 *offsets++=sourceIndex;
396 }
397 sourceIndex=nextSourceIndex;
398 state=readCommand;
399 goto fastSingle;
400 case quoteOne:
401 if(b<0x80) {
402 /* all static offsets are in the BMP */
403 *target++=(UChar)(staticOffsets[quoteWindow]+b);
404 if(offsets!=NULL) {
405 *offsets++=sourceIndex;
406 }
407 } else {
408 /* write from dynamic window */
409 uint32_t c=scsu->toUDynamicOffsets[quoteWindow]+(b&0x7f);
410 if(c<=0xffff) {
411 *target++=(UChar)c;
412 if(offsets!=NULL) {
413 *offsets++=sourceIndex;
414 }
415 } else {
416 /* output surrogate pair */
417 *target++=(UChar)(0xd7c0+(c>>10));
418 if(target<targetLimit) {
419 *target++=(UChar)(0xdc00|(c&0x3ff));
420 if(offsets!=NULL) {
421 *offsets++=sourceIndex;
422 *offsets++=sourceIndex;
423 }
424 } else {
425 /* target overflow */
426 if(offsets!=NULL) {
427 *offsets++=sourceIndex;
428 }
429 cnv->UCharErrorBuffer[0]=(UChar)(0xdc00|(c&0x3ff));
430 cnv->UCharErrorBufferLength=1;
431 *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
432 goto endloop;
433 }
434 }
435 }
436 sourceIndex=nextSourceIndex;
437 state=readCommand;
438 goto fastSingle;
439 case definePairOne:
440 dynamicWindow=(int8_t)((b>>5)&7);
441 byteOne=(uint8_t)(b&0x1f);
442 cnv->toUBytes[1]=b;
443 cnv->toULength=2;
444 state=definePairTwo;
445 break;
446 case definePairTwo:
447 scsu->toUDynamicOffsets[dynamicWindow]=0x10000+(byteOne<<15UL | b<<7UL);
448 sourceIndex=nextSourceIndex;
449 state=readCommand;
450 goto fastSingle;
451 case defineOne:
452 if(b==0) {
453 /* callback(illegal): Reserved window offset value 0 */
454 cnv->toUBytes[1]=b;
455 cnv->toULength=2;
456 goto endloop;
457 } else if(b<gapThreshold) {
458 scsu->toUDynamicOffsets[dynamicWindow]=b<<7UL;
459 } else if((uint8_t)(b-gapThreshold)<(reservedStart-gapThreshold)) {
460 scsu->toUDynamicOffsets[dynamicWindow]=(b<<7UL)+gapOffset;
461 } else if(b>=fixedThreshold) {
462 scsu->toUDynamicOffsets[dynamicWindow]=fixedOffsets[b-fixedThreshold];
463 } else {
464 /* callback(illegal): Reserved window offset value 0xa8..0xf8 */
465 cnv->toUBytes[1]=b;
466 cnv->toULength=2;
467 goto endloop;
468 }
469 sourceIndex=nextSourceIndex;
470 state=readCommand;
471 goto fastSingle;
472 }
473 }
474 } else {
475 /* fast path for Unicode mode */
476 if(state==readCommand) {
477 fastUnicode:
478 while(source+1<sourceLimit && target<targetLimit && (uint8_t)((b=*source)-UC0)>(Urs-UC0)) {
479 *target++=(UChar)((b<<8)|source[1]);
480 if(offsets!=NULL) {
481 *offsets++=sourceIndex;
482 }
483 sourceIndex=nextSourceIndex;
484 nextSourceIndex+=2;
485 source+=2;
486 }
487 }
488
489 /* normal state machine for Unicode mode */
490 /* unicodeByteMode: */
491 while(source<sourceLimit) {
492 if(target>=targetLimit) {
493 /* target is full */
494 *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
495 break;
496 }
497 b=*source++;
498 ++nextSourceIndex;
499 switch(state) {
500 case readCommand:
501 if((uint8_t)(b-UC0)>(Urs-UC0)) {
502 byteOne=b;
503 cnv->toUBytes[0]=b;
504 cnv->toULength=1;
505 state=quotePairTwo;
506 } else if(/* UC0<=b && */ b<=UC7) {
507 dynamicWindow=(int8_t)(b-UC0);
508 sourceIndex=nextSourceIndex;
509 isSingleByteMode=TRUE;
510 goto fastSingle;
511 } else if(/* UD0<=b && */ b<=UD7) {
512 dynamicWindow=(int8_t)(b-UD0);
513 isSingleByteMode=TRUE;
514 cnv->toUBytes[0]=b;
515 cnv->toULength=1;
516 state=defineOne;
517 goto singleByteMode;
518 } else if(b==UDX) {
519 isSingleByteMode=TRUE;
520 cnv->toUBytes[0]=b;
521 cnv->toULength=1;
522 state=definePairOne;
523 goto singleByteMode;
524 } else if(b==UQU) {
525 cnv->toUBytes[0]=b;
526 cnv->toULength=1;
527 state=quotePairOne;
528 } else /* Urs */ {
529 /* callback(illegal) */
530 *pErrorCode=U_ILLEGAL_CHAR_FOUND;
531 cnv->toUBytes[0]=b;
532 cnv->toULength=1;
533 goto endloop;
534 }
535 break;
536 case quotePairOne:
537 byteOne=b;
538 cnv->toUBytes[1]=b;
539 cnv->toULength=2;
540 state=quotePairTwo;
541 break;
542 case quotePairTwo:
543 *target++=(UChar)((byteOne<<8)|b);
544 if(offsets!=NULL) {
545 *offsets++=sourceIndex;
546 }
547 sourceIndex=nextSourceIndex;
548 state=readCommand;
549 goto fastUnicode;
550 }
551 }
552 }
553 endloop:
554
555 /* set the converter state back into UConverter */
556 if(U_FAILURE(*pErrorCode) && *pErrorCode!=U_BUFFER_OVERFLOW_ERROR) {
557 /* reset to deal with the next character */
558 state=readCommand;
559 } else if(state==readCommand) {
560 /* not in a multi-byte sequence, reset toULength */
561 cnv->toULength=0;
562 }
563 scsu->toUIsSingleByteMode=isSingleByteMode;
564 scsu->toUState=state;
565 scsu->toUQuoteWindow=quoteWindow;
566 scsu->toUDynamicWindow=dynamicWindow;
567 scsu->toUByteOne=byteOne;
568
569 /* write back the updated pointers */
570 pArgs->source=(const char *)source;
571 pArgs->target=target;
572 pArgs->offsets=offsets;
573 return;
574 }
575
576 /*
577 * Identical to _SCSUToUnicodeWithOffsets but without offset handling.
578 * If a change is made in the original function, then either
579 * change this function the same way or
580 * re-copy the original function and remove the variables
581 * offsets, sourceIndex, and nextSourceIndex.
582 */
583 static void
584 _SCSUToUnicode(UConverterToUnicodeArgs *pArgs,
585 UErrorCode *pErrorCode) {
586 UConverter *cnv;
587 SCSUData *scsu;
588 const uint8_t *source, *sourceLimit;
589 UChar *target;
590 const UChar *targetLimit;
591 UBool isSingleByteMode;
592 uint8_t state, byteOne;
593 int8_t quoteWindow, dynamicWindow;
594
595 uint8_t b;
596
597 /* set up the local pointers */
598 cnv=pArgs->converter;
599 scsu=(SCSUData *)cnv->extraInfo;
600
601 source=(const uint8_t *)pArgs->source;
602 sourceLimit=(const uint8_t *)pArgs->sourceLimit;
603 target=pArgs->target;
604 targetLimit=pArgs->targetLimit;
605
606 /* get the state machine state */
607 isSingleByteMode=scsu->toUIsSingleByteMode;
608 state=scsu->toUState;
609 quoteWindow=scsu->toUQuoteWindow;
610 dynamicWindow=scsu->toUDynamicWindow;
611 byteOne=scsu->toUByteOne;
612
613 /*
614 * conversion "loop"
615 *
616 * For performance, this is not a normal C loop.
617 * Instead, there are two code blocks for the two SCSU modes.
618 * The function branches to either one, and a change of the mode is done with a goto to
619 * the other branch.
620 *
621 * Each branch has two conventional loops:
622 * - a fast-path loop for the most common codes in the mode
623 * - a loop for all other codes in the mode
624 * When the fast-path runs into a code that it cannot handle, its loop ends and it
625 * runs into the following loop to handle the other codes.
626 * The end of the input or output buffer is also handled by the slower loop.
627 * The slow loop jumps (goto) to the fast-path loop again as soon as possible.
628 *
629 * The callback handling is done by returning with an error code.
630 * The conversion framework actually calls the callback function.
631 */
632 if(isSingleByteMode) {
633 /* fast path for single-byte mode */
634 if(state==readCommand) {
635 fastSingle:
636 while(source<sourceLimit && target<targetLimit && (b=*source)>=0x20) {
637 ++source;
638 if(b<=0x7f) {
639 /* write US-ASCII graphic character or DEL */
640 *target++=(UChar)b;
641 } else {
642 /* write from dynamic window */
643 uint32_t c=scsu->toUDynamicOffsets[dynamicWindow]+(b&0x7f);
644 if(c<=0xffff) {
645 *target++=(UChar)c;
646 } else {
647 /* output surrogate pair */
648 *target++=(UChar)(0xd7c0+(c>>10));
649 if(target<targetLimit) {
650 *target++=(UChar)(0xdc00|(c&0x3ff));
651 } else {
652 /* target overflow */
653 cnv->UCharErrorBuffer[0]=(UChar)(0xdc00|(c&0x3ff));
654 cnv->UCharErrorBufferLength=1;
655 *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
656 goto endloop;
657 }
658 }
659 }
660 }
661 }
662
663 /* normal state machine for single-byte mode, minus handling for what fastSingle covers */
664 singleByteMode:
665 while(source<sourceLimit) {
666 if(target>=targetLimit) {
667 /* target is full */
668 *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
669 break;
670 }
671 b=*source++;
672 switch(state) {
673 case readCommand:
674 /* redundant conditions are commented out */
675 /* here: b<0x20 because otherwise we would be in fastSingle */
676 if((1UL<<b)&0x2601 /* binary 0010 0110 0000 0001, check for b==0xd || b==0xa || b==9 || b==0 */) {
677 /* CR/LF/TAB/NUL */
678 *target++=(UChar)b;
679 goto fastSingle;
680 } else if(SC0<=b) {
681 if(b<=SC7) {
682 dynamicWindow=(int8_t)(b-SC0);
683 goto fastSingle;
684 } else /* if(SD0<=b && b<=SD7) */ {
685 dynamicWindow=(int8_t)(b-SD0);
686 state=defineOne;
687 }
688 } else if(/* SQ0<=b && */ b<=SQ7) {
689 quoteWindow=(int8_t)(b-SQ0);
690 state=quoteOne;
691 } else if(b==SDX) {
692 state=definePairOne;
693 } else if(b==SQU) {
694 state=quotePairOne;
695 } else if(b==SCU) {
696 isSingleByteMode=FALSE;
697 goto fastUnicode;
698 } else /* Srs */ {
699 /* callback(illegal) */
700 *pErrorCode=U_ILLEGAL_CHAR_FOUND;
701 cnv->toUBytes[0]=b;
702 cnv->toULength=1;
703 goto endloop;
704 }
705
706 /* store the first byte of a multibyte sequence in toUBytes[] */
707 cnv->toUBytes[0]=b;
708 cnv->toULength=1;
709 break;
710 case quotePairOne:
711 byteOne=b;
712 cnv->toUBytes[1]=b;
713 cnv->toULength=2;
714 state=quotePairTwo;
715 break;
716 case quotePairTwo:
717 *target++=(UChar)((byteOne<<8)|b);
718 state=readCommand;
719 goto fastSingle;
720 case quoteOne:
721 if(b<0x80) {
722 /* all static offsets are in the BMP */
723 *target++=(UChar)(staticOffsets[quoteWindow]+b);
724 } else {
725 /* write from dynamic window */
726 uint32_t c=scsu->toUDynamicOffsets[quoteWindow]+(b&0x7f);
727 if(c<=0xffff) {
728 *target++=(UChar)c;
729 } else {
730 /* output surrogate pair */
731 *target++=(UChar)(0xd7c0+(c>>10));
732 if(target<targetLimit) {
733 *target++=(UChar)(0xdc00|(c&0x3ff));
734 } else {
735 /* target overflow */
736 cnv->UCharErrorBuffer[0]=(UChar)(0xdc00|(c&0x3ff));
737 cnv->UCharErrorBufferLength=1;
738 *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
739 goto endloop;
740 }
741 }
742 }
743 state=readCommand;
744 goto fastSingle;
745 case definePairOne:
746 dynamicWindow=(int8_t)((b>>5)&7);
747 byteOne=(uint8_t)(b&0x1f);
748 cnv->toUBytes[1]=b;
749 cnv->toULength=2;
750 state=definePairTwo;
751 break;
752 case definePairTwo:
753 scsu->toUDynamicOffsets[dynamicWindow]=0x10000+(byteOne<<15UL | b<<7UL);
754 state=readCommand;
755 goto fastSingle;
756 case defineOne:
757 if(b==0) {
758 /* callback(illegal): Reserved window offset value 0 */
759 cnv->toUBytes[1]=b;
760 cnv->toULength=2;
761 goto endloop;
762 } else if(b<gapThreshold) {
763 scsu->toUDynamicOffsets[dynamicWindow]=b<<7UL;
764 } else if((uint8_t)(b-gapThreshold)<(reservedStart-gapThreshold)) {
765 scsu->toUDynamicOffsets[dynamicWindow]=(b<<7UL)+gapOffset;
766 } else if(b>=fixedThreshold) {
767 scsu->toUDynamicOffsets[dynamicWindow]=fixedOffsets[b-fixedThreshold];
768 } else {
769 /* callback(illegal): Reserved window offset value 0xa8..0xf8 */
770 cnv->toUBytes[1]=b;
771 cnv->toULength=2;
772 goto endloop;
773 }
774 state=readCommand;
775 goto fastSingle;
776 }
777 }
778 } else {
779 /* fast path for Unicode mode */
780 if(state==readCommand) {
781 fastUnicode:
782 while(source+1<sourceLimit && target<targetLimit && (uint8_t)((b=*source)-UC0)>(Urs-UC0)) {
783 *target++=(UChar)((b<<8)|source[1]);
784 source+=2;
785 }
786 }
787
788 /* normal state machine for Unicode mode */
789 /* unicodeByteMode: */
790 while(source<sourceLimit) {
791 if(target>=targetLimit) {
792 /* target is full */
793 *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
794 break;
795 }
796 b=*source++;
797 switch(state) {
798 case readCommand:
799 if((uint8_t)(b-UC0)>(Urs-UC0)) {
800 byteOne=b;
801 cnv->toUBytes[0]=b;
802 cnv->toULength=1;
803 state=quotePairTwo;
804 } else if(/* UC0<=b && */ b<=UC7) {
805 dynamicWindow=(int8_t)(b-UC0);
806 isSingleByteMode=TRUE;
807 goto fastSingle;
808 } else if(/* UD0<=b && */ b<=UD7) {
809 dynamicWindow=(int8_t)(b-UD0);
810 isSingleByteMode=TRUE;
811 cnv->toUBytes[0]=b;
812 cnv->toULength=1;
813 state=defineOne;
814 goto singleByteMode;
815 } else if(b==UDX) {
816 isSingleByteMode=TRUE;
817 cnv->toUBytes[0]=b;
818 cnv->toULength=1;
819 state=definePairOne;
820 goto singleByteMode;
821 } else if(b==UQU) {
822 cnv->toUBytes[0]=b;
823 cnv->toULength=1;
824 state=quotePairOne;
825 } else /* Urs */ {
826 /* callback(illegal) */
827 *pErrorCode=U_ILLEGAL_CHAR_FOUND;
828 cnv->toUBytes[0]=b;
829 cnv->toULength=1;
830 goto endloop;
831 }
832 break;
833 case quotePairOne:
834 byteOne=b;
835 cnv->toUBytes[1]=b;
836 cnv->toULength=2;
837 state=quotePairTwo;
838 break;
839 case quotePairTwo:
840 *target++=(UChar)((byteOne<<8)|b);
841 state=readCommand;
842 goto fastUnicode;
843 }
844 }
845 }
846 endloop:
847
848 /* set the converter state back into UConverter */
849 if(U_FAILURE(*pErrorCode) && *pErrorCode!=U_BUFFER_OVERFLOW_ERROR) {
850 /* reset to deal with the next character */
851 state=readCommand;
852 } else if(state==readCommand) {
853 /* not in a multi-byte sequence, reset toULength */
854 cnv->toULength=0;
855 }
856 scsu->toUIsSingleByteMode=isSingleByteMode;
857 scsu->toUState=state;
858 scsu->toUQuoteWindow=quoteWindow;
859 scsu->toUDynamicWindow=dynamicWindow;
860 scsu->toUByteOne=byteOne;
861
862 /* write back the updated pointers */
863 pArgs->source=(const char *)source;
864 pArgs->target=target;
865 return;
866 }
867
868 /* SCSU-from-Unicode conversion functions ----------------------------------- */
869
870 /*
871 * This SCSU Encoder is fairly simple but uses all SCSU commands to achieve
872 * reasonable results. The lookahead is minimal.
873 * Many cases are simple:
874 * A character fits directly into the current mode, a dynamic or static window,
875 * or is not compressible. These cases are tested first.
876 * Real compression heuristics are applied to the rest, in code branches for
877 * single/Unicode mode and BMP/supplementary code points.
878 * The heuristics used here are extremely simple.
879 */
880
881 /* get the number of the window that this character is in, or -1 */
882 static int8_t
883 getWindow(const uint32_t offsets[8], uint32_t c) {
884 int i;
885 for(i=0; i<8; ++i) {
886 if((uint32_t)(c-offsets[i])<=0x7f) {
887 return (int8_t)(i);
888 }
889 }
890 return -1;
891 }
892
893 /* is the character in the dynamic window starting at the offset, or in the direct-encoded range? */
894 static UBool
895 isInOffsetWindowOrDirect(uint32_t offset, uint32_t c) {
896 return (UBool)(c<=offset+0x7f &&
897 (c>=offset || (c<=0x7f &&
898 (c>=0x20 || (1UL<<c)&0x2601))));
899 /* binary 0010 0110 0000 0001,
900 check for b==0xd || b==0xa || b==9 || b==0 */
901 }
902
903 /*
904 * getNextDynamicWindow returns the next dynamic window to be redefined
905 */
906 static int8_t
907 getNextDynamicWindow(SCSUData *scsu) {
908 int8_t window=scsu->windowUse[scsu->nextWindowUseIndex];
909 if(++scsu->nextWindowUseIndex==8) {
910 scsu->nextWindowUseIndex=0;
911 }
912 return window;
913 }
914
915 /*
916 * useDynamicWindow() adjusts
917 * windowUse[] and nextWindowUseIndex for the algorithm to choose
918 * the next dynamic window to be defined;
919 * a subclass may override it and provide its own algorithm.
920 */
921 static void
922 useDynamicWindow(SCSUData *scsu, int8_t window) {
923 /*
924 * move the existing window, which just became the most recently used one,
925 * up in windowUse[] to nextWindowUseIndex-1
926 */
927
928 /* first, find the index of the window - backwards to favor the more recently used windows */
929 int i, j;
930
931 i=scsu->nextWindowUseIndex;
932 do {
933 if(--i<0) {
934 i=7;
935 }
936 } while(scsu->windowUse[i]!=window);
937
938 /* now copy each windowUse[i+1] to [i] */
939 j=i+1;
940 if(j==8) {
941 j=0;
942 }
943 while(j!=scsu->nextWindowUseIndex) {
944 scsu->windowUse[i]=scsu->windowUse[j];
945 i=j;
946 if(++j==8) { j=0; }
947 }
948
949 /* finally, set the window into the most recently used index */
950 scsu->windowUse[i]=window;
951 }
952
953 /*
954 * calculate the offset and the code for a dynamic window that contains the character
955 * takes fixed offsets into account
956 * the offset of the window is stored in the offset variable,
957 * the code is returned
958 *
959 * return offset code: -1 none <=0xff code for SDn/UDn else code for SDX/UDX, subtract 0x200 to get the true code
960 */
961 static int
962 getDynamicOffset(uint32_t c, uint32_t *pOffset) {
963 int i;
964
965 for(i=0; i<7; ++i) {
966 if((uint32_t)(c-fixedOffsets[i])<=0x7f) {
967 *pOffset=fixedOffsets[i];
968 return 0xf9+i;
969 }
970 }
971
972 if(c<0x80) {
973 /* No dynamic window for US-ASCII. */
974 return -1;
975 } else if(c<0x3400 ||
976 (uint32_t)(c-0x10000)<(0x14000-0x10000) ||
977 (uint32_t)(c-0x1d000)<=(0x1ffff-0x1d000)
978 ) {
979 /* This character is in a code range for a "small", i.e., reasonably windowable, script. */
980 *pOffset=c&0x7fffff80;
981 return (int)(c>>7);
982 } else if(0xe000<=c && c!=0xfeff && c<0xfff0) {
983 /* For these characters we need to take the gapOffset into account. */
984 *pOffset=c&0x7fffff80;
985 return (int)((c-gapOffset)>>7);
986 } else {
987 return -1;
988 }
989 }
990
991 /*
992 * Idea for compression:
993 * - save SCSUData and other state before really starting work
994 * - at endloop, see if compression could be better with just unicode mode
995 * - don't do this if a callback has been called
996 * - if unicode mode would be smaller, then override the results with it - may need SCU at the beginning
997 * - different buffer handling!
998 *
999 * Drawback or need for corrective handling:
1000 * it is desirable to encode U+feff as SQU fe ff for the SCSU signature, and
1001 * it is desirable to start a document in US-ASCII/Latin-1 for as long as possible
1002 * not only for compression but also for HTML/XML documents with following charset/encoding announcers.
1003 *
1004 * How to achieve both?
1005 * - Only replace the result after an SDX or SCU?
1006 */
1007
1008 static void
1009 _SCSUFromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs,
1010 UErrorCode *pErrorCode) {
1011 UConverter *cnv;
1012 SCSUData *scsu;
1013 const UChar *source, *sourceLimit;
1014 uint8_t *target;
1015 int32_t targetCapacity;
1016 int32_t *offsets;
1017
1018 UBool isSingleByteMode;
1019 uint8_t dynamicWindow;
1020 uint32_t currentOffset;
1021
1022 uint32_t c, delta;
1023
1024 int32_t sourceIndex, nextSourceIndex;
1025
1026 int32_t length;
1027
1028 /* variables for compression heuristics */
1029 uint32_t offset;
1030 UChar lead, trail;
1031 int code;
1032 int8_t window;
1033
1034 /* set up the local pointers */
1035 cnv=pArgs->converter;
1036 scsu=(SCSUData *)cnv->extraInfo;
1037
1038 /* set up the local pointers */
1039 source=pArgs->source;
1040 sourceLimit=pArgs->sourceLimit;
1041 target=(uint8_t *)pArgs->target;
1042 targetCapacity=(int32_t)(pArgs->targetLimit-pArgs->target);
1043 offsets=pArgs->offsets;
1044
1045 /* get the state machine state */
1046 isSingleByteMode=scsu->fromUIsSingleByteMode;
1047 dynamicWindow=scsu->fromUDynamicWindow;
1048 currentOffset=scsu->fromUDynamicOffsets[dynamicWindow];
1049
1050 c=cnv->fromUChar32;
1051
1052 /* sourceIndex=-1 if the current character began in the previous buffer */
1053 sourceIndex= c==0 ? 0 : -1;
1054 nextSourceIndex=0;
1055
1056 /* similar conversion "loop" as in toUnicode */
1057 loop:
1058 if(isSingleByteMode) {
1059 if(c!=0 && targetCapacity>0) {
1060 goto getTrailSingle;
1061 }
1062
1063 /* state machine for single-byte mode */
1064 /* singleByteMode: */
1065 while(source<sourceLimit) {
1066 if(targetCapacity<=0) {
1067 /* target is full */
1068 *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
1069 break;
1070 }
1071 c=*source++;
1072 ++nextSourceIndex;
1073
1074 if((c-0x20)<=0x5f) {
1075 /* pass US-ASCII graphic character through */
1076 *target++=(uint8_t)c;
1077 if(offsets!=NULL) {
1078 *offsets++=sourceIndex;
1079 }
1080 --targetCapacity;
1081 } else if(c<0x20) {
1082 if((1UL<<c)&0x2601 /* binary 0010 0110 0000 0001, check for b==0xd || b==0xa || b==9 || b==0 */) {
1083 /* CR/LF/TAB/NUL */
1084 *target++=(uint8_t)c;
1085 if(offsets!=NULL) {
1086 *offsets++=sourceIndex;
1087 }
1088 --targetCapacity;
1089 } else {
1090 /* quote C0 control character */
1091 c|=SQ0<<8;
1092 length=2;
1093 goto outputBytes;
1094 }
1095 } else if((delta=c-currentOffset)<=0x7f) {
1096 /* use the current dynamic window */
1097 *target++=(uint8_t)(delta|0x80);
1098 if(offsets!=NULL) {
1099 *offsets++=sourceIndex;
1100 }
1101 --targetCapacity;
1102 } else if(U16_IS_SURROGATE(c)) {
1103 if(U16_IS_SURROGATE_LEAD(c)) {
1104 getTrailSingle:
1105 lead=(UChar)c;
1106 if(source<sourceLimit) {
1107 /* test the following code unit */
1108 trail=*source;
1109 if(U16_IS_TRAIL(trail)) {
1110 ++source;
1111 ++nextSourceIndex;
1112 c=U16_GET_SUPPLEMENTARY(c, trail);
1113 /* convert this surrogate code point */
1114 /* exit this condition tree */
1115 } else {
1116 /* this is an unmatched lead code unit (1st surrogate) */
1117 /* callback(illegal) */
1118 *pErrorCode=U_ILLEGAL_CHAR_FOUND;
1119 goto endloop;
1120 }
1121 } else {
1122 /* no more input */
1123 break;
1124 }
1125 } else {
1126 /* this is an unmatched trail code unit (2nd surrogate) */
1127 /* callback(illegal) */
1128 *pErrorCode=U_ILLEGAL_CHAR_FOUND;
1129 goto endloop;
1130 }
1131
1132 /* compress supplementary character U+10000..U+10ffff */
1133 if((delta=c-currentOffset)<=0x7f) {
1134 /* use the current dynamic window */
1135 *target++=(uint8_t)(delta|0x80);
1136 if(offsets!=NULL) {
1137 *offsets++=sourceIndex;
1138 }
1139 --targetCapacity;
1140 } else if((window=getWindow(scsu->fromUDynamicOffsets, c))>=0) {
1141 /* there is a dynamic window that contains this character, change to it */
1142 dynamicWindow=window;
1143 currentOffset=scsu->fromUDynamicOffsets[dynamicWindow];
1144 useDynamicWindow(scsu, dynamicWindow);
1145 c=((uint32_t)(SC0+dynamicWindow)<<8)|(c-currentOffset)|0x80;
1146 length=2;
1147 goto outputBytes;
1148 } else if((code=getDynamicOffset(c, &offset))>=0) {
1149 /* might check if there are more characters in this window to come */
1150 /* define an extended window with this character */
1151 code-=0x200;
1152 dynamicWindow=getNextDynamicWindow(scsu);
1153 currentOffset=scsu->fromUDynamicOffsets[dynamicWindow]=offset;
1154 useDynamicWindow(scsu, dynamicWindow);
1155 c=((uint32_t)SDX<<24)|((uint32_t)dynamicWindow<<21)|((uint32_t)code<<8)|(c-currentOffset)|0x80;
1156 length=4;
1157 goto outputBytes;
1158 } else {
1159 /* change to Unicode mode and output this (lead, trail) pair */
1160 isSingleByteMode=FALSE;
1161 *target++=(uint8_t)SCU;
1162 if(offsets!=NULL) {
1163 *offsets++=sourceIndex;
1164 }
1165 --targetCapacity;
1166 c=((uint32_t)lead<<16)|trail;
1167 length=4;
1168 goto outputBytes;
1169 }
1170 } else if(c<0xa0) {
1171 /* quote C1 control character */
1172 c=(c&0x7f)|(SQ0+1)<<8; /* SQ0+1==SQ1 */
1173 length=2;
1174 goto outputBytes;
1175 } else if(c==0xfeff || c>=0xfff0) {
1176 /* quote signature character=byte order mark and specials */
1177 c|=SQU<<16;
1178 length=3;
1179 goto outputBytes;
1180 } else {
1181 /* compress all other BMP characters */
1182 if((window=getWindow(scsu->fromUDynamicOffsets, c))>=0) {
1183 /* there is a window defined that contains this character - switch to it or quote from it? */
1184 if(source>=sourceLimit || isInOffsetWindowOrDirect(scsu->fromUDynamicOffsets[window], *source)) {
1185 /* change to dynamic window */
1186 dynamicWindow=window;
1187 currentOffset=scsu->fromUDynamicOffsets[dynamicWindow];
1188 useDynamicWindow(scsu, dynamicWindow);
1189 c=((uint32_t)(SC0+dynamicWindow)<<8)|(c-currentOffset)|0x80;
1190 length=2;
1191 goto outputBytes;
1192 } else {
1193 /* quote from dynamic window */
1194 c=((uint32_t)(SQ0+window)<<8)|(c-scsu->fromUDynamicOffsets[window])|0x80;
1195 length=2;
1196 goto outputBytes;
1197 }
1198 } else if((window=getWindow(staticOffsets, c))>=0) {
1199 /* quote from static window */
1200 c=((uint32_t)(SQ0+window)<<8)|(c-staticOffsets[window]);
1201 length=2;
1202 goto outputBytes;
1203 } else if((code=getDynamicOffset(c, &offset))>=0) {
1204 /* define a dynamic window with this character */
1205 dynamicWindow=getNextDynamicWindow(scsu);
1206 currentOffset=scsu->fromUDynamicOffsets[dynamicWindow]=offset;
1207 useDynamicWindow(scsu, dynamicWindow);
1208 c=((uint32_t)(SD0+dynamicWindow)<<16)|((uint32_t)code<<8)|(c-currentOffset)|0x80;
1209 length=3;
1210 goto outputBytes;
1211 } else if((uint32_t)(c-0x3400)<(0xd800-0x3400) &&
1212 (source>=sourceLimit || (uint32_t)(*source-0x3400)<(0xd800-0x3400))
1213 ) {
1214 /*
1215 * this character is not compressible (a BMP ideograph or similar);
1216 * switch to Unicode mode if this is the last character in the block
1217 * or there is at least one more ideograph following immediately
1218 */
1219 isSingleByteMode=FALSE;
1220 c|=SCU<<16;
1221 length=3;
1222 goto outputBytes;
1223 } else {
1224 /* quote Unicode */
1225 c|=SQU<<16;
1226 length=3;
1227 goto outputBytes;
1228 }
1229 }
1230
1231 /* normal end of conversion: prepare for a new character */
1232 c=0;
1233 sourceIndex=nextSourceIndex;
1234 }
1235 } else {
1236 if(c!=0 && targetCapacity>0) {
1237 goto getTrailUnicode;
1238 }
1239
1240 /* state machine for Unicode mode */
1241 /* unicodeByteMode: */
1242 while(source<sourceLimit) {
1243 if(targetCapacity<=0) {
1244 /* target is full */
1245 *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
1246 break;
1247 }
1248 c=*source++;
1249 ++nextSourceIndex;
1250
1251 if((uint32_t)(c-0x3400)<(0xd800-0x3400)) {
1252 /* not compressible, write character directly */
1253 if(targetCapacity>=2) {
1254 *target++=(uint8_t)(c>>8);
1255 *target++=(uint8_t)c;
1256 if(offsets!=NULL) {
1257 *offsets++=sourceIndex;
1258 *offsets++=sourceIndex;
1259 }
1260 targetCapacity-=2;
1261 } else {
1262 length=2;
1263 goto outputBytes;
1264 }
1265 } else if((uint32_t)(c-0x3400)>=(0xf300-0x3400) /* c<0x3400 || c>=0xf300 */) {
1266 /* compress BMP character if the following one is not an uncompressible ideograph */
1267 if(!(source<sourceLimit && (uint32_t)(*source-0x3400)<(0xd800-0x3400))) {
1268 if(((uint32_t)(c-0x30)<10 || (uint32_t)(c-0x61)<26 || (uint32_t)(c-0x41)<26)) {
1269 /* ASCII digit or letter */
1270 isSingleByteMode=TRUE;
1271 c|=((uint32_t)(UC0+dynamicWindow)<<8)|c;
1272 length=2;
1273 goto outputBytes;
1274 } else if((window=getWindow(scsu->fromUDynamicOffsets, c))>=0) {
1275 /* there is a dynamic window that contains this character, change to it */
1276 isSingleByteMode=TRUE;
1277 dynamicWindow=window;
1278 currentOffset=scsu->fromUDynamicOffsets[dynamicWindow];
1279 useDynamicWindow(scsu, dynamicWindow);
1280 c=((uint32_t)(UC0+dynamicWindow)<<8)|(c-currentOffset)|0x80;
1281 length=2;
1282 goto outputBytes;
1283 } else if((code=getDynamicOffset(c, &offset))>=0) {
1284 /* define a dynamic window with this character */
1285 isSingleByteMode=TRUE;
1286 dynamicWindow=getNextDynamicWindow(scsu);
1287 currentOffset=scsu->fromUDynamicOffsets[dynamicWindow]=offset;
1288 useDynamicWindow(scsu, dynamicWindow);
1289 c=((uint32_t)(UD0+dynamicWindow)<<16)|((uint32_t)code<<8)|(c-currentOffset)|0x80;
1290 length=3;
1291 goto outputBytes;
1292 }
1293 }
1294
1295 /* don't know how to compress this character, just write it directly */
1296 length=2;
1297 goto outputBytes;
1298 } else if(c<0xe000) {
1299 /* c is a surrogate */
1300 if(U16_IS_SURROGATE_LEAD(c)) {
1301 getTrailUnicode:
1302 lead=(UChar)c;
1303 if(source<sourceLimit) {
1304 /* test the following code unit */
1305 trail=*source;
1306 if(U16_IS_TRAIL(trail)) {
1307 ++source;
1308 ++nextSourceIndex;
1309 c=U16_GET_SUPPLEMENTARY(c, trail);
1310 /* convert this surrogate code point */
1311 /* exit this condition tree */
1312 } else {
1313 /* this is an unmatched lead code unit (1st surrogate) */
1314 /* callback(illegal) */
1315 *pErrorCode=U_ILLEGAL_CHAR_FOUND;
1316 goto endloop;
1317 }
1318 } else {
1319 /* no more input */
1320 break;
1321 }
1322 } else {
1323 /* this is an unmatched trail code unit (2nd surrogate) */
1324 /* callback(illegal) */
1325 *pErrorCode=U_ILLEGAL_CHAR_FOUND;
1326 goto endloop;
1327 }
1328
1329 /* compress supplementary character */
1330 if( (window=getWindow(scsu->fromUDynamicOffsets, c))>=0 &&
1331 !(source<sourceLimit && (uint32_t)(*source-0x3400)<(0xd800-0x3400))
1332 ) {
1333 /*
1334 * there is a dynamic window that contains this character and
1335 * the following character is not uncompressible,
1336 * change to the window
1337 */
1338 isSingleByteMode=TRUE;
1339 dynamicWindow=window;
1340 currentOffset=scsu->fromUDynamicOffsets[dynamicWindow];
1341 useDynamicWindow(scsu, dynamicWindow);
1342 c=((uint32_t)(UC0+dynamicWindow)<<8)|(c-currentOffset)|0x80;
1343 length=2;
1344 goto outputBytes;
1345 } else if(source<sourceLimit && lead==*source && /* too lazy to check trail in same window as source[1] */
1346 (code=getDynamicOffset(c, &offset))>=0
1347 ) {
1348 /* two supplementary characters in (probably) the same window - define an extended one */
1349 isSingleByteMode=TRUE;
1350 code-=0x200;
1351 dynamicWindow=getNextDynamicWindow(scsu);
1352 currentOffset=scsu->fromUDynamicOffsets[dynamicWindow]=offset;
1353 useDynamicWindow(scsu, dynamicWindow);
1354 c=((uint32_t)UDX<<24)|((uint32_t)dynamicWindow<<21)|((uint32_t)code<<8)|(c-currentOffset)|0x80;
1355 length=4;
1356 goto outputBytes;
1357 } else {
1358 /* don't know how to compress this character, just write it directly */
1359 c=((uint32_t)lead<<16)|trail;
1360 length=4;
1361 goto outputBytes;
1362 }
1363 } else /* 0xe000<=c<0xf300 */ {
1364 /* quote to avoid SCSU tags */
1365 c|=UQU<<16;
1366 length=3;
1367 goto outputBytes;
1368 }
1369
1370 /* normal end of conversion: prepare for a new character */
1371 c=0;
1372 sourceIndex=nextSourceIndex;
1373 }
1374 }
1375 endloop:
1376
1377 /* set the converter state back into UConverter */
1378 scsu->fromUIsSingleByteMode=isSingleByteMode;
1379 scsu->fromUDynamicWindow=dynamicWindow;
1380
1381 cnv->fromUChar32=c;
1382
1383 /* write back the updated pointers */
1384 pArgs->source=source;
1385 pArgs->target=(char *)target;
1386 pArgs->offsets=offsets;
1387 return;
1388
1389 outputBytes:
1390 /* write the output character bytes from c and length [code copied from ucnvmbcs.c] */
1391 /* from the first if in the loop we know that targetCapacity>0 */
1392 if(length<=targetCapacity) {
1393 if(offsets==NULL) {
1394 switch(length) {
1395 /* each branch falls through to the next one */
1396 case 4:
1397 *target++=(uint8_t)(c>>24);
1398 case 3: /*fall through*/
1399 *target++=(uint8_t)(c>>16);
1400 case 2: /*fall through*/
1401 *target++=(uint8_t)(c>>8);
1402 case 1: /*fall through*/
1403 *target++=(uint8_t)c;
1404 default:
1405 /* will never occur */
1406 break;
1407 }
1408 } else {
1409 switch(length) {
1410 /* each branch falls through to the next one */
1411 case 4:
1412 *target++=(uint8_t)(c>>24);
1413 *offsets++=sourceIndex;
1414 case 3: /*fall through*/
1415 *target++=(uint8_t)(c>>16);
1416 *offsets++=sourceIndex;
1417 case 2: /*fall through*/
1418 *target++=(uint8_t)(c>>8);
1419 *offsets++=sourceIndex;
1420 case 1: /*fall through*/
1421 *target++=(uint8_t)c;
1422 *offsets++=sourceIndex;
1423 default:
1424 /* will never occur */
1425 break;
1426 }
1427 }
1428 targetCapacity-=length;
1429
1430 /* normal end of conversion: prepare for a new character */
1431 c=0;
1432 sourceIndex=nextSourceIndex;
1433 goto loop;
1434 } else {
1435 uint8_t *p;
1436
1437 /*
1438 * We actually do this backwards here:
1439 * In order to save an intermediate variable, we output
1440 * first to the overflow buffer what does not fit into the
1441 * regular target.
1442 */
1443 /* we know that 0<=targetCapacity<length<=4 */
1444 /* targetCapacity==0 when SCU+supplementary where SCU used up targetCapacity==1 */
1445 length-=targetCapacity;
1446 p=(uint8_t *)cnv->charErrorBuffer;
1447 switch(length) {
1448 /* each branch falls through to the next one */
1449 case 4:
1450 *p++=(uint8_t)(c>>24);
1451 case 3: /*fall through*/
1452 *p++=(uint8_t)(c>>16);
1453 case 2: /*fall through*/
1454 *p++=(uint8_t)(c>>8);
1455 case 1: /*fall through*/
1456 *p=(uint8_t)c;
1457 default:
1458 /* will never occur */
1459 break;
1460 }
1461 cnv->charErrorBufferLength=(int8_t)length;
1462
1463 /* now output what fits into the regular target */
1464 c>>=8*length; /* length was reduced by targetCapacity */
1465 switch(targetCapacity) {
1466 /* each branch falls through to the next one */
1467 case 3:
1468 *target++=(uint8_t)(c>>16);
1469 if(offsets!=NULL) {
1470 *offsets++=sourceIndex;
1471 }
1472 case 2: /*fall through*/
1473 *target++=(uint8_t)(c>>8);
1474 if(offsets!=NULL) {
1475 *offsets++=sourceIndex;
1476 }
1477 case 1: /*fall through*/
1478 *target++=(uint8_t)c;
1479 if(offsets!=NULL) {
1480 *offsets++=sourceIndex;
1481 }
1482 default:
1483 break;
1484 }
1485
1486 /* target overflow */
1487 targetCapacity=0;
1488 *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
1489 c=0;
1490 goto endloop;
1491 }
1492 }
1493
1494 /*
1495 * Identical to _SCSUFromUnicodeWithOffsets but without offset handling.
1496 * If a change is made in the original function, then either
1497 * change this function the same way or
1498 * re-copy the original function and remove the variables
1499 * offsets, sourceIndex, and nextSourceIndex.
1500 */
1501 static void
1502 _SCSUFromUnicode(UConverterFromUnicodeArgs *pArgs,
1503 UErrorCode *pErrorCode) {
1504 UConverter *cnv;
1505 SCSUData *scsu;
1506 const UChar *source, *sourceLimit;
1507 uint8_t *target;
1508 int32_t targetCapacity;
1509
1510 UBool isSingleByteMode;
1511 uint8_t dynamicWindow;
1512 uint32_t currentOffset;
1513
1514 uint32_t c, delta;
1515
1516 int32_t length;
1517
1518 /* variables for compression heuristics */
1519 uint32_t offset;
1520 UChar lead, trail;
1521 int code;
1522 int8_t window;
1523
1524 /* set up the local pointers */
1525 cnv=pArgs->converter;
1526 scsu=(SCSUData *)cnv->extraInfo;
1527
1528 /* set up the local pointers */
1529 source=pArgs->source;
1530 sourceLimit=pArgs->sourceLimit;
1531 target=(uint8_t *)pArgs->target;
1532 targetCapacity=(int32_t)(pArgs->targetLimit-pArgs->target);
1533
1534 /* get the state machine state */
1535 isSingleByteMode=scsu->fromUIsSingleByteMode;
1536 dynamicWindow=scsu->fromUDynamicWindow;
1537 currentOffset=scsu->fromUDynamicOffsets[dynamicWindow];
1538
1539 c=cnv->fromUChar32;
1540
1541 /* similar conversion "loop" as in toUnicode */
1542 loop:
1543 if(isSingleByteMode) {
1544 if(c!=0 && targetCapacity>0) {
1545 goto getTrailSingle;
1546 }
1547
1548 /* state machine for single-byte mode */
1549 /* singleByteMode: */
1550 while(source<sourceLimit) {
1551 if(targetCapacity<=0) {
1552 /* target is full */
1553 *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
1554 break;
1555 }
1556 c=*source++;
1557
1558 if((c-0x20)<=0x5f) {
1559 /* pass US-ASCII graphic character through */
1560 *target++=(uint8_t)c;
1561 --targetCapacity;
1562 } else if(c<0x20) {
1563 if((1UL<<c)&0x2601 /* binary 0010 0110 0000 0001, check for b==0xd || b==0xa || b==9 || b==0 */) {
1564 /* CR/LF/TAB/NUL */
1565 *target++=(uint8_t)c;
1566 --targetCapacity;
1567 } else {
1568 /* quote C0 control character */
1569 c|=SQ0<<8;
1570 length=2;
1571 goto outputBytes;
1572 }
1573 } else if((delta=c-currentOffset)<=0x7f) {
1574 /* use the current dynamic window */
1575 *target++=(uint8_t)(delta|0x80);
1576 --targetCapacity;
1577 } else if(U16_IS_SURROGATE(c)) {
1578 if(U16_IS_SURROGATE_LEAD(c)) {
1579 getTrailSingle:
1580 lead=(UChar)c;
1581 if(source<sourceLimit) {
1582 /* test the following code unit */
1583 trail=*source;
1584 if(U16_IS_TRAIL(trail)) {
1585 ++source;
1586 c=U16_GET_SUPPLEMENTARY(c, trail);
1587 /* convert this surrogate code point */
1588 /* exit this condition tree */
1589 } else {
1590 /* this is an unmatched lead code unit (1st surrogate) */
1591 /* callback(illegal) */
1592 *pErrorCode=U_ILLEGAL_CHAR_FOUND;
1593 goto endloop;
1594 }
1595 } else {
1596 /* no more input */
1597 break;
1598 }
1599 } else {
1600 /* this is an unmatched trail code unit (2nd surrogate) */
1601 /* callback(illegal) */
1602 *pErrorCode=U_ILLEGAL_CHAR_FOUND;
1603 goto endloop;
1604 }
1605
1606 /* compress supplementary character U+10000..U+10ffff */
1607 if((delta=c-currentOffset)<=0x7f) {
1608 /* use the current dynamic window */
1609 *target++=(uint8_t)(delta|0x80);
1610 --targetCapacity;
1611 } else if((window=getWindow(scsu->fromUDynamicOffsets, c))>=0) {
1612 /* there is a dynamic window that contains this character, change to it */
1613 dynamicWindow=window;
1614 currentOffset=scsu->fromUDynamicOffsets[dynamicWindow];
1615 useDynamicWindow(scsu, dynamicWindow);
1616 c=((uint32_t)(SC0+dynamicWindow)<<8)|(c-currentOffset)|0x80;
1617 length=2;
1618 goto outputBytes;
1619 } else if((code=getDynamicOffset(c, &offset))>=0) {
1620 /* might check if there are more characters in this window to come */
1621 /* define an extended window with this character */
1622 code-=0x200;
1623 dynamicWindow=getNextDynamicWindow(scsu);
1624 currentOffset=scsu->fromUDynamicOffsets[dynamicWindow]=offset;
1625 useDynamicWindow(scsu, dynamicWindow);
1626 c=((uint32_t)SDX<<24)|((uint32_t)dynamicWindow<<21)|((uint32_t)code<<8)|(c-currentOffset)|0x80;
1627 length=4;
1628 goto outputBytes;
1629 } else {
1630 /* change to Unicode mode and output this (lead, trail) pair */
1631 isSingleByteMode=FALSE;
1632 *target++=(uint8_t)SCU;
1633 --targetCapacity;
1634 c=((uint32_t)lead<<16)|trail;
1635 length=4;
1636 goto outputBytes;
1637 }
1638 } else if(c<0xa0) {
1639 /* quote C1 control character */
1640 c=(c&0x7f)|(SQ0+1)<<8; /* SQ0+1==SQ1 */
1641 length=2;
1642 goto outputBytes;
1643 } else if(c==0xfeff || c>=0xfff0) {
1644 /* quote signature character=byte order mark and specials */
1645 c|=SQU<<16;
1646 length=3;
1647 goto outputBytes;
1648 } else {
1649 /* compress all other BMP characters */
1650 if((window=getWindow(scsu->fromUDynamicOffsets, c))>=0) {
1651 /* there is a window defined that contains this character - switch to it or quote from it? */
1652 if(source>=sourceLimit || isInOffsetWindowOrDirect(scsu->fromUDynamicOffsets[window], *source)) {
1653 /* change to dynamic window */
1654 dynamicWindow=window;
1655 currentOffset=scsu->fromUDynamicOffsets[dynamicWindow];
1656 useDynamicWindow(scsu, dynamicWindow);
1657 c=((uint32_t)(SC0+dynamicWindow)<<8)|(c-currentOffset)|0x80;
1658 length=2;
1659 goto outputBytes;
1660 } else {
1661 /* quote from dynamic window */
1662 c=((uint32_t)(SQ0+window)<<8)|(c-scsu->fromUDynamicOffsets[window])|0x80;
1663 length=2;
1664 goto outputBytes;
1665 }
1666 } else if((window=getWindow(staticOffsets, c))>=0) {
1667 /* quote from static window */
1668 c=((uint32_t)(SQ0+window)<<8)|(c-staticOffsets[window]);
1669 length=2;
1670 goto outputBytes;
1671 } else if((code=getDynamicOffset(c, &offset))>=0) {
1672 /* define a dynamic window with this character */
1673 dynamicWindow=getNextDynamicWindow(scsu);
1674 currentOffset=scsu->fromUDynamicOffsets[dynamicWindow]=offset;
1675 useDynamicWindow(scsu, dynamicWindow);
1676 c=((uint32_t)(SD0+dynamicWindow)<<16)|((uint32_t)code<<8)|(c-currentOffset)|0x80;
1677 length=3;
1678 goto outputBytes;
1679 } else if((uint32_t)(c-0x3400)<(0xd800-0x3400) &&
1680 (source>=sourceLimit || (uint32_t)(*source-0x3400)<(0xd800-0x3400))
1681 ) {
1682 /*
1683 * this character is not compressible (a BMP ideograph or similar);
1684 * switch to Unicode mode if this is the last character in the block
1685 * or there is at least one more ideograph following immediately
1686 */
1687 isSingleByteMode=FALSE;
1688 c|=SCU<<16;
1689 length=3;
1690 goto outputBytes;
1691 } else {
1692 /* quote Unicode */
1693 c|=SQU<<16;
1694 length=3;
1695 goto outputBytes;
1696 }
1697 }
1698
1699 /* normal end of conversion: prepare for a new character */
1700 c=0;
1701 }
1702 } else {
1703 if(c!=0 && targetCapacity>0) {
1704 goto getTrailUnicode;
1705 }
1706
1707 /* state machine for Unicode mode */
1708 /* unicodeByteMode: */
1709 while(source<sourceLimit) {
1710 if(targetCapacity<=0) {
1711 /* target is full */
1712 *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
1713 break;
1714 }
1715 c=*source++;
1716
1717 if((uint32_t)(c-0x3400)<(0xd800-0x3400)) {
1718 /* not compressible, write character directly */
1719 if(targetCapacity>=2) {
1720 *target++=(uint8_t)(c>>8);
1721 *target++=(uint8_t)c;
1722 targetCapacity-=2;
1723 } else {
1724 length=2;
1725 goto outputBytes;
1726 }
1727 } else if((uint32_t)(c-0x3400)>=(0xf300-0x3400) /* c<0x3400 || c>=0xf300 */) {
1728 /* compress BMP character if the following one is not an uncompressible ideograph */
1729 if(!(source<sourceLimit && (uint32_t)(*source-0x3400)<(0xd800-0x3400))) {
1730 if(((uint32_t)(c-0x30)<10 || (uint32_t)(c-0x61)<26 || (uint32_t)(c-0x41)<26)) {
1731 /* ASCII digit or letter */
1732 isSingleByteMode=TRUE;
1733 c|=((uint32_t)(UC0+dynamicWindow)<<8)|c;
1734 length=2;
1735 goto outputBytes;
1736 } else if((window=getWindow(scsu->fromUDynamicOffsets, c))>=0) {
1737 /* there is a dynamic window that contains this character, change to it */
1738 isSingleByteMode=TRUE;
1739 dynamicWindow=window;
1740 currentOffset=scsu->fromUDynamicOffsets[dynamicWindow];
1741 useDynamicWindow(scsu, dynamicWindow);
1742 c=((uint32_t)(UC0+dynamicWindow)<<8)|(c-currentOffset)|0x80;
1743 length=2;
1744 goto outputBytes;
1745 } else if((code=getDynamicOffset(c, &offset))>=0) {
1746 /* define a dynamic window with this character */
1747 isSingleByteMode=TRUE;
1748 dynamicWindow=getNextDynamicWindow(scsu);
1749 currentOffset=scsu->fromUDynamicOffsets[dynamicWindow]=offset;
1750 useDynamicWindow(scsu, dynamicWindow);
1751 c=((uint32_t)(UD0+dynamicWindow)<<16)|((uint32_t)code<<8)|(c-currentOffset)|0x80;
1752 length=3;
1753 goto outputBytes;
1754 }
1755 }
1756
1757 /* don't know how to compress this character, just write it directly */
1758 length=2;
1759 goto outputBytes;
1760 } else if(c<0xe000) {
1761 /* c is a surrogate */
1762 if(U16_IS_SURROGATE_LEAD(c)) {
1763 getTrailUnicode:
1764 lead=(UChar)c;
1765 if(source<sourceLimit) {
1766 /* test the following code unit */
1767 trail=*source;
1768 if(U16_IS_TRAIL(trail)) {
1769 ++source;
1770 c=U16_GET_SUPPLEMENTARY(c, trail);
1771 /* convert this surrogate code point */
1772 /* exit this condition tree */
1773 } else {
1774 /* this is an unmatched lead code unit (1st surrogate) */
1775 /* callback(illegal) */
1776 *pErrorCode=U_ILLEGAL_CHAR_FOUND;
1777 goto endloop;
1778 }
1779 } else {
1780 /* no more input */
1781 break;
1782 }
1783 } else {
1784 /* this is an unmatched trail code unit (2nd surrogate) */
1785 /* callback(illegal) */
1786 *pErrorCode=U_ILLEGAL_CHAR_FOUND;
1787 goto endloop;
1788 }
1789
1790 /* compress supplementary character */
1791 if( (window=getWindow(scsu->fromUDynamicOffsets, c))>=0 &&
1792 !(source<sourceLimit && (uint32_t)(*source-0x3400)<(0xd800-0x3400))
1793 ) {
1794 /*
1795 * there is a dynamic window that contains this character and
1796 * the following character is not uncompressible,
1797 * change to the window
1798 */
1799 isSingleByteMode=TRUE;
1800 dynamicWindow=window;
1801 currentOffset=scsu->fromUDynamicOffsets[dynamicWindow];
1802 useDynamicWindow(scsu, dynamicWindow);
1803 c=((uint32_t)(UC0+dynamicWindow)<<8)|(c-currentOffset)|0x80;
1804 length=2;
1805 goto outputBytes;
1806 } else if(source<sourceLimit && lead==*source && /* too lazy to check trail in same window as source[1] */
1807 (code=getDynamicOffset(c, &offset))>=0
1808 ) {
1809 /* two supplementary characters in (probably) the same window - define an extended one */
1810 isSingleByteMode=TRUE;
1811 code-=0x200;
1812 dynamicWindow=getNextDynamicWindow(scsu);
1813 currentOffset=scsu->fromUDynamicOffsets[dynamicWindow]=offset;
1814 useDynamicWindow(scsu, dynamicWindow);
1815 c=((uint32_t)UDX<<24)|((uint32_t)dynamicWindow<<21)|((uint32_t)code<<8)|(c-currentOffset)|0x80;
1816 length=4;
1817 goto outputBytes;
1818 } else {
1819 /* don't know how to compress this character, just write it directly */
1820 c=((uint32_t)lead<<16)|trail;
1821 length=4;
1822 goto outputBytes;
1823 }
1824 } else /* 0xe000<=c<0xf300 */ {
1825 /* quote to avoid SCSU tags */
1826 c|=UQU<<16;
1827 length=3;
1828 goto outputBytes;
1829 }
1830
1831 /* normal end of conversion: prepare for a new character */
1832 c=0;
1833 }
1834 }
1835 endloop:
1836
1837 /* set the converter state back into UConverter */
1838 scsu->fromUIsSingleByteMode=isSingleByteMode;
1839 scsu->fromUDynamicWindow=dynamicWindow;
1840
1841 cnv->fromUChar32=c;
1842
1843 /* write back the updated pointers */
1844 pArgs->source=source;
1845 pArgs->target=(char *)target;
1846 return;
1847
1848 outputBytes:
1849 /* write the output character bytes from c and length [code copied from ucnvmbcs.c] */
1850 /* from the first if in the loop we know that targetCapacity>0 */
1851 if(length<=targetCapacity) {
1852 switch(length) {
1853 /* each branch falls through to the next one */
1854 case 4:
1855 *target++=(uint8_t)(c>>24);
1856 case 3: /*fall through*/
1857 *target++=(uint8_t)(c>>16);
1858 case 2: /*fall through*/
1859 *target++=(uint8_t)(c>>8);
1860 case 1: /*fall through*/
1861 *target++=(uint8_t)c;
1862 default:
1863 /* will never occur */
1864 break;
1865 }
1866 targetCapacity-=length;
1867
1868 /* normal end of conversion: prepare for a new character */
1869 c=0;
1870 goto loop;
1871 } else {
1872 uint8_t *p;
1873
1874 /*
1875 * We actually do this backwards here:
1876 * In order to save an intermediate variable, we output
1877 * first to the overflow buffer what does not fit into the
1878 * regular target.
1879 */
1880 /* we know that 0<=targetCapacity<length<=4 */
1881 /* targetCapacity==0 when SCU+supplementary where SCU used up targetCapacity==1 */
1882 length-=targetCapacity;
1883 p=(uint8_t *)cnv->charErrorBuffer;
1884 switch(length) {
1885 /* each branch falls through to the next one */
1886 case 4:
1887 *p++=(uint8_t)(c>>24);
1888 case 3: /*fall through*/
1889 *p++=(uint8_t)(c>>16);
1890 case 2: /*fall through*/
1891 *p++=(uint8_t)(c>>8);
1892 case 1: /*fall through*/
1893 *p=(uint8_t)c;
1894 default:
1895 /* will never occur */
1896 break;
1897 }
1898 cnv->charErrorBufferLength=(int8_t)length;
1899
1900 /* now output what fits into the regular target */
1901 c>>=8*length; /* length was reduced by targetCapacity */
1902 switch(targetCapacity) {
1903 /* each branch falls through to the next one */
1904 case 3:
1905 *target++=(uint8_t)(c>>16);
1906 case 2: /*fall through*/
1907 *target++=(uint8_t)(c>>8);
1908 case 1: /*fall through*/
1909 *target++=(uint8_t)c;
1910 default:
1911 break;
1912 }
1913
1914 /* target overflow */
1915 targetCapacity=0;
1916 *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
1917 c=0;
1918 goto endloop;
1919 }
1920 }
1921
1922 /* miscellaneous ------------------------------------------------------------ */
1923
1924 static const char *
1925 _SCSUGetName(const UConverter *cnv) {
1926 SCSUData *scsu=(SCSUData *)cnv->extraInfo;
1927
1928 switch(scsu->locale) {
1929 case l_ja:
1930 return "SCSU,locale=ja";
1931 default:
1932 return "SCSU";
1933 }
1934 }
1935
1936 /* structure for SafeClone calculations */
1937 struct cloneSCSUStruct
1938 {
1939 UConverter cnv;
1940 SCSUData mydata;
1941 };
1942
1943 static UConverter *
1944 _SCSUSafeClone(const UConverter *cnv,
1945 void *stackBuffer,
1946 int32_t *pBufferSize,
1947 UErrorCode *status)
1948 {
1949 struct cloneSCSUStruct * localClone;
1950 int32_t bufferSizeNeeded = sizeof(struct cloneSCSUStruct);
1951
1952 if (U_FAILURE(*status)){
1953 return 0;
1954 }
1955
1956 if (*pBufferSize == 0){ /* 'preflighting' request - set needed size into *pBufferSize */
1957 *pBufferSize = bufferSizeNeeded;
1958 return 0;
1959 }
1960
1961 localClone = (struct cloneSCSUStruct *)stackBuffer;
1962 /* ucnv.c/ucnv_safeClone() copied the main UConverter already */
1963
1964 uprv_memcpy(&localClone->mydata, cnv->extraInfo, sizeof(SCSUData));
1965 localClone->cnv.extraInfo = &localClone->mydata;
1966 localClone->cnv.isExtraLocal = TRUE;
1967
1968 return &localClone->cnv;
1969 }
1970
1971
1972 static const UConverterImpl _SCSUImpl={
1973 UCNV_SCSU,
1974
1975 NULL,
1976 NULL,
1977
1978 _SCSUOpen,
1979 _SCSUClose,
1980 _SCSUReset,
1981
1982 _SCSUToUnicode,
1983 _SCSUToUnicodeWithOffsets,
1984 _SCSUFromUnicode,
1985 _SCSUFromUnicodeWithOffsets,
1986 NULL,
1987
1988 NULL,
1989 _SCSUGetName,
1990 NULL,
1991 _SCSUSafeClone,
1992 ucnv_getCompleteUnicodeSet
1993 };
1994
1995 static const UConverterStaticData _SCSUStaticData={
1996 sizeof(UConverterStaticData),
1997 "SCSU",
1998 1212, /* CCSID for SCSU */
1999 UCNV_IBM, UCNV_SCSU,
2000 1, 3, /* one UChar generates at least 1 byte and at most 3 bytes */
2001 /*
2002 * The subchar here is ignored because _SCSUOpen() sets U+fffd as a Unicode
2003 * substitution string.
2004 */
2005 { 0x0e, 0xff, 0xfd, 0 }, 3,
2006 FALSE, FALSE,
2007 0,
2008 0,
2009 { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } /* reserved */
2010 };
2011
2012 const UConverterSharedData _SCSUData={
2013 sizeof(UConverterSharedData), ~((uint32_t)0),
2014 NULL, NULL, &_SCSUStaticData, FALSE, &_SCSUImpl,
2015 0
2016 };
2017
2018 #endif

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial