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