icuSources/common/ucnvlat1.c

   1 /*
   2 **********************************************************************
   3 *   Copyright (C) 2000-2012, International Business Machines
   4 *   Corporation and others.  All Rights Reserved.
   5 **********************************************************************
   6 *   file name:  ucnvlat1.cpp
   7 *   encoding:   US-ASCII
   8 *   tab size:   8 (not used)
   9 *   indentation:4
  10 *
  11 *   created on: 2000feb07
  12 *   created by: Markus W. Scherer
  13 */
  14
  15 #include "unicode/utypes.h"
  16
  17 #if !UCONFIG_NO_CONVERSION
  18
  19 #include "unicode/ucnv.h"
  20 #include "unicode/uset.h"
  21 #include "unicode/utf8.h"
  22 #include "ucnv_bld.h"
  23 #include "ucnv_cnv.h"
  24
  25 /* control optimizations according to the platform */
  26 #define LATIN1_UNROLL_FROM_UNICODE 1
  27
  28 /* ISO 8859-1 --------------------------------------------------------------- */
  29
  30 /* This is a table-less and callback-less version of ucnv_MBCSSingleToBMPWithOffsets(). */
  31 static void
  32 _Latin1ToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
  33                             UErrorCode *pErrorCode) {
  34     const uint8_t *source;
  35     UChar *target;
  36     int32_t targetCapacity, length;
  37     int32_t *offsets;
  38
  39     int32_t sourceIndex;
  40
  41     /* set up the local pointers */
  42     source=(const uint8_t *)pArgs->source;
  43     target=pArgs->target;
  44     targetCapacity=(int32_t)(pArgs->targetLimit-pArgs->target);
  45     offsets=pArgs->offsets;
  46
  47     sourceIndex=0;
  48
  49     /*
  50      * since the conversion here is 1:1 UChar:uint8_t, we need only one counter
  51      * for the minimum of the sourceLength and targetCapacity
  52      */
  53     length=(int32_t)((const uint8_t *)pArgs->sourceLimit-source);
  54     if(length<=targetCapacity) {
  55         targetCapacity=length;
  56     } else {
  57         /* target will be full */
  58         *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
  59         length=targetCapacity;
  60     }
  61
  62     if(targetCapacity>=8) {
  63         /* This loop is unrolled for speed and improved pipelining. */
  64         int32_t count, loops;
  65
  66         loops=count=targetCapacity>>3;
  67         length=targetCapacity&=0x7;
  68         do {
  69             target[0]=source[0];
  70             target[1]=source[1];
  71             target[2]=source[2];
  72             target[3]=source[3];
  73             target[4]=source[4];
  74             target[5]=source[5];
  75             target[6]=source[6];
  76             target[7]=source[7];
  77             target+=8;
  78             source+=8;
  79         } while(--count>0);
  80
  81         if(offsets!=NULL) {
  82             do {
  83                 offsets[0]=sourceIndex++;
  84                 offsets[1]=sourceIndex++;
  85                 offsets[2]=sourceIndex++;
  86                 offsets[3]=sourceIndex++;
  87                 offsets[4]=sourceIndex++;
  88                 offsets[5]=sourceIndex++;
  89                 offsets[6]=sourceIndex++;
  90                 offsets[7]=sourceIndex++;
  91                 offsets+=8;
  92             } while(--loops>0);
  93         }
  94     }
  95
  96     /* conversion loop */
  97     while(targetCapacity>0) {
  98         *target++=*source++;
  99         --targetCapacity;
 100     }
 101
 102     /* write back the updated pointers */
 103     pArgs->source=(const char *)source;
 104     pArgs->target=target;
 105
 106     /* set offsets */
 107     if(offsets!=NULL) {
 108         while(length>0) {
 109             *offsets++=sourceIndex++;
 110             --length;
 111         }
 112         pArgs->offsets=offsets;
 113     }
 114 }
 115
 116 /* This is a table-less and callback-less version of ucnv_MBCSSingleGetNextUChar(). */
 117 static UChar32
 118 _Latin1GetNextUChar(UConverterToUnicodeArgs *pArgs,
 119                     UErrorCode *pErrorCode) {
 120     const uint8_t *source=(const uint8_t *)pArgs->source;
 121     if(source<(const uint8_t *)pArgs->sourceLimit) {
 122         pArgs->source=(const char *)(source+1);
 123         return *source;
 124     }
 125
 126     /* no output because of empty input */
 127     *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
 128     return 0xffff;
 129 }
 130
 131 /* This is a table-less version of ucnv_MBCSSingleFromBMPWithOffsets(). */
 132 static void
 133 _Latin1FromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs,
 134                               UErrorCode *pErrorCode) {
 135     UConverter *cnv;
 136     const UChar *source, *sourceLimit;
 137     uint8_t *target, *oldTarget;
 138     int32_t targetCapacity, length;
 139     int32_t *offsets;
 140
 141     UChar32 cp;
 142     UChar c, max;
 143
 144     int32_t sourceIndex;
 145
 146     /* set up the local pointers */
 147     cnv=pArgs->converter;
 148     source=pArgs->source;
 149     sourceLimit=pArgs->sourceLimit;
 150     target=oldTarget=(uint8_t *)pArgs->target;
 151     targetCapacity=(int32_t)(pArgs->targetLimit-pArgs->target);
 152     offsets=pArgs->offsets;
 153
 154     if(cnv->sharedData==&_Latin1Data) {
 155         max=0xff; /* Latin-1 */
 156     } else {
 157         max=0x7f; /* US-ASCII */
 158     }
 159
 160     /* get the converter state from UConverter */
 161     cp=cnv->fromUChar32;
 162
 163     /* sourceIndex=-1 if the current character began in the previous buffer */
 164     sourceIndex= cp==0 ? 0 : -1;
 165
 166     /*
 167      * since the conversion here is 1:1 UChar:uint8_t, we need only one counter
 168      * for the minimum of the sourceLength and targetCapacity
 169      */
 170     length=(int32_t)(sourceLimit-source);
 171     if(length<targetCapacity) {
 172         targetCapacity=length;
 173     }
 174
 175     /* conversion loop */
 176     if(cp!=0 && targetCapacity>0) {
 177         goto getTrail;
 178     }
 179
 180 #if LATIN1_UNROLL_FROM_UNICODE
 181     /* unroll the loop with the most common case */
 182     if(targetCapacity>=16) {
 183         int32_t count, loops;
 184         UChar u, oredChars;
 185
 186         loops=count=targetCapacity>>4;
 187         do {
 188             oredChars=u=*source++;
 189             *target++=(uint8_t)u;
 190             oredChars|=u=*source++;
 191             *target++=(uint8_t)u;
 192             oredChars|=u=*source++;
 193             *target++=(uint8_t)u;
 194             oredChars|=u=*source++;
 195             *target++=(uint8_t)u;
 196             oredChars|=u=*source++;
 197             *target++=(uint8_t)u;
 198             oredChars|=u=*source++;
 199             *target++=(uint8_t)u;
 200             oredChars|=u=*source++;
 201             *target++=(uint8_t)u;
 202             oredChars|=u=*source++;
 203             *target++=(uint8_t)u;
 204             oredChars|=u=*source++;
 205             *target++=(uint8_t)u;
 206             oredChars|=u=*source++;
 207             *target++=(uint8_t)u;
 208             oredChars|=u=*source++;
 209             *target++=(uint8_t)u;
 210             oredChars|=u=*source++;
 211             *target++=(uint8_t)u;
 212             oredChars|=u=*source++;
 213             *target++=(uint8_t)u;
 214             oredChars|=u=*source++;
 215             *target++=(uint8_t)u;
 216             oredChars|=u=*source++;
 217             *target++=(uint8_t)u;
 218             oredChars|=u=*source++;
 219             *target++=(uint8_t)u;
 220
 221             /* were all 16 entries really valid? */
 222             if(oredChars>max) {
 223                 /* no, return to the first of these 16 */
 224                 source-=16;
 225                 target-=16;
 226                 break;
 227             }
 228         } while(--count>0);
 229         count=loops-count;
 230         targetCapacity-=16*count;
 231
 232         if(offsets!=NULL) {
 233             oldTarget+=16*count;
 234             while(count>0) {
 235                 *offsets++=sourceIndex++;
 236                 *offsets++=sourceIndex++;
 237                 *offsets++=sourceIndex++;
 238                 *offsets++=sourceIndex++;
 239                 *offsets++=sourceIndex++;
 240                 *offsets++=sourceIndex++;
 241                 *offsets++=sourceIndex++;
 242                 *offsets++=sourceIndex++;
 243                 *offsets++=sourceIndex++;
 244                 *offsets++=sourceIndex++;
 245                 *offsets++=sourceIndex++;
 246                 *offsets++=sourceIndex++;
 247                 *offsets++=sourceIndex++;
 248                 *offsets++=sourceIndex++;
 249                 *offsets++=sourceIndex++;
 250                 *offsets++=sourceIndex++;
 251                 --count;
 252             }
 253         }
 254     }
 255 #endif
 256
 257     /* conversion loop */
 258     c=0;
 259     while(targetCapacity>0 && (c=*source++)<=max) {
 260         /* convert the Unicode code point */
 261         *target++=(uint8_t)c;
 262         --targetCapacity;
 263     }
 264
 265     if(c>max) {
 266         cp=c;
 267         if(!U_IS_SURROGATE(cp)) {
 268             /* callback(unassigned) */
 269         } else if(U_IS_SURROGATE_LEAD(cp)) {
 270 getTrail:
 271             if(source<sourceLimit) {
 272                 /* test the following code unit */
 273                 UChar trail=*source;
 274                 if(U16_IS_TRAIL(trail)) {
 275                     ++source;
 276                     cp=U16_GET_SUPPLEMENTARY(cp, trail);
 277                     /* this codepage does not map supplementary code points */
 278                     /* callback(unassigned) */
 279                 } else {
 280                     /* this is an unmatched lead code unit (1st surrogate) */
 281                     /* callback(illegal) */
 282                 }
 283             } else {
 284                 /* no more input */
 285                 cnv->fromUChar32=cp;
 286                 goto noMoreInput;
 287             }
 288         } else {
 289             /* this is an unmatched trail code unit (2nd surrogate) */
 290             /* callback(illegal) */
 291         }
 292
 293         *pErrorCode= U_IS_SURROGATE(cp) ? U_ILLEGAL_CHAR_FOUND : U_INVALID_CHAR_FOUND;
 294         cnv->fromUChar32=cp;
 295     }
 296 noMoreInput:
 297
 298     /* set offsets since the start */
 299     if(offsets!=NULL) {
 300         size_t count=target-oldTarget;
 301         while(count>0) {
 302             *offsets++=sourceIndex++;
 303             --count;
 304         }
 305     }
 306
 307     if(U_SUCCESS(*pErrorCode) && source<sourceLimit && target>=(uint8_t *)pArgs->targetLimit) {
 308         /* target is full */
 309         *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
 310     }
 311
 312     /* write back the updated pointers */
 313     pArgs->source=source;
 314     pArgs->target=(char *)target;
 315     pArgs->offsets=offsets;
 316 }
 317
 318 /* Convert UTF-8 to Latin-1. Adapted from ucnv_SBCSFromUTF8(). */
 319 static void
 320 ucnv_Latin1FromUTF8(UConverterFromUnicodeArgs *pFromUArgs,
 321                     UConverterToUnicodeArgs *pToUArgs,
 322                     UErrorCode *pErrorCode) {
 323     UConverter *utf8;
 324     const uint8_t *source, *sourceLimit;
 325     uint8_t *target;
 326     int32_t targetCapacity;
 327
 328     UChar32 c;
 329     uint8_t b, t1;
 330
 331     /* set up the local pointers */
 332     utf8=pToUArgs->converter;
 333     source=(uint8_t *)pToUArgs->source;
 334     sourceLimit=(uint8_t *)pToUArgs->sourceLimit;
 335     target=(uint8_t *)pFromUArgs->target;
 336     targetCapacity=(int32_t)(pFromUArgs->targetLimit-pFromUArgs->target);
 337
 338     /* get the converter state from the UTF-8 UConverter */
 339     c=(UChar32)utf8->toUnicodeStatus;
 340     if(c!=0 && source<sourceLimit) {
 341         if(targetCapacity==0) {
 342             *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
 343             return;
 344         } else if(c>=0xc2 && c<=0xc3 && (t1=(uint8_t)(*source-0x80)) <= 0x3f) {
 345             ++source;
 346             *target++=(uint8_t)(((c&3)<<6)|t1);
 347             --targetCapacity;
 348
 349             utf8->toUnicodeStatus=0;
 350             utf8->toULength=0;
 351         } else {
 352             /* complicated, illegal or unmappable input: fall back to the pivoting implementation */
 353             *pErrorCode=U_USING_DEFAULT_WARNING;
 354             return;
 355         }
 356     }
 357
 358     /*
 359      * Make sure that the last byte sequence before sourceLimit is complete
 360      * or runs into a lead byte.
 361      * In the conversion loop compare source with sourceLimit only once
 362      * per multi-byte character.
 363      * For Latin-1, adjust sourceLimit only for 1 trail byte because
 364      * the conversion loop handles at most 2-byte sequences.
 365      */
 366     if(source<sourceLimit && U8_IS_LEAD(*(sourceLimit-1))) {
 367         --sourceLimit;
 368     }
 369
 370     /* conversion loop */
 371     while(source<sourceLimit) {
 372         if(targetCapacity>0) {
 373             b=*source++;
 374             if((int8_t)b>=0) {
 375                 /* convert ASCII */
 376                 *target++=(uint8_t)b;
 377                 --targetCapacity;
 378             } else if( /* handle U+0080..U+00FF inline */
 379                        b>=0xc2 && b<=0xc3 &&
 380                        (t1=(uint8_t)(*source-0x80)) <= 0x3f
 381             ) {
 382                 ++source;
 383                 *target++=(uint8_t)(((b&3)<<6)|t1);
 384                 --targetCapacity;
 385             } else {
 386                 /* complicated, illegal or unmappable input: fall back to the pivoting implementation */
 387                 pToUArgs->source=(char *)(source-1);
 388                 pFromUArgs->target=(char *)target;
 389                 *pErrorCode=U_USING_DEFAULT_WARNING;
 390                 return;
 391             }
 392         } else {
 393             /* target is full */
 394             *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
 395             break;
 396         }
 397     }
 398
 399     /*
 400      * The sourceLimit may have been adjusted before the conversion loop
 401      * to stop before a truncated sequence.
 402      * If so, then collect the truncated sequence now.
 403      * For Latin-1, there is at most exactly one lead byte because of the
 404      * smaller sourceLimit adjustment logic.
 405      */
 406     if(U_SUCCESS(*pErrorCode) && source<(sourceLimit=(uint8_t *)pToUArgs->sourceLimit)) {
 407         utf8->toUnicodeStatus=utf8->toUBytes[0]=b=*source++;
 408         utf8->toULength=1;
 409         utf8->mode=U8_COUNT_TRAIL_BYTES(b)+1;
 410     }
 411
 412     /* write back the updated pointers */
 413     pToUArgs->source=(char *)source;
 414     pFromUArgs->target=(char *)target;
 415 }
 416
 417 static void
 418 _Latin1GetUnicodeSet(const UConverter *cnv,
 419                      const USetAdder *sa,
 420                      UConverterUnicodeSet which,
 421                      UErrorCode *pErrorCode) {
 422     sa->addRange(sa->set, 0, 0xff);
 423 }
 424
 425 static const UConverterImpl _Latin1Impl={
 426     UCNV_LATIN_1,
 427
 428     NULL,
 429     NULL,
 430
 431     NULL,
 432     NULL,
 433     NULL,
 434
 435     _Latin1ToUnicodeWithOffsets,
 436     _Latin1ToUnicodeWithOffsets,
 437     _Latin1FromUnicodeWithOffsets,
 438     _Latin1FromUnicodeWithOffsets,
 439     _Latin1GetNextUChar,
 440
 441     NULL,
 442     NULL,
 443     NULL,
 444     NULL,
 445     _Latin1GetUnicodeSet,
 446
 447     NULL,
 448     ucnv_Latin1FromUTF8
 449 };
 450
 451 static const UConverterStaticData _Latin1StaticData={
 452     sizeof(UConverterStaticData),
 453     "ISO-8859-1",
 454     819, UCNV_IBM, UCNV_LATIN_1, 1, 1,
 455     { 0x1a, 0, 0, 0 }, 1, FALSE, FALSE,
 456     0,
 457     0,
 458     { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } /* reserved */
 459 };
 460
 461 const UConverterSharedData _Latin1Data={
 462     sizeof(UConverterSharedData), ~((uint32_t) 0),
 463     NULL, NULL, &_Latin1StaticData, FALSE, &_Latin1Impl,
 464     0
 465 };
 466
 467 /* US-ASCII ----------------------------------------------------------------- */
 468
 469 /* This is a table-less version of ucnv_MBCSSingleToBMPWithOffsets(). */
 470 static void
 471 _ASCIIToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
 472                            UErrorCode *pErrorCode) {
 473     const uint8_t *source, *sourceLimit;
 474     UChar *target, *oldTarget;
 475     int32_t targetCapacity, length;
 476     int32_t *offsets;
 477
 478     int32_t sourceIndex;
 479
 480     uint8_t c;
 481
 482     /* set up the local pointers */
 483     source=(const uint8_t *)pArgs->source;
 484     sourceLimit=(const uint8_t *)pArgs->sourceLimit;
 485     target=oldTarget=pArgs->target;
 486     targetCapacity=(int32_t)(pArgs->targetLimit-pArgs->target);
 487     offsets=pArgs->offsets;
 488
 489     /* sourceIndex=-1 if the current character began in the previous buffer */
 490     sourceIndex=0;
 491
 492     /*
 493      * since the conversion here is 1:1 UChar:uint8_t, we need only one counter
 494      * for the minimum of the sourceLength and targetCapacity
 495      */
 496     length=(int32_t)(sourceLimit-source);
 497     if(length<targetCapacity) {
 498         targetCapacity=length;
 499     }
 500
 501     if(targetCapacity>=8) {
 502         /* This loop is unrolled for speed and improved pipelining. */
 503         int32_t count, loops;
 504         UChar oredChars;
 505
 506         loops=count=targetCapacity>>3;
 507         do {
 508             oredChars=target[0]=source[0];
 509             oredChars|=target[1]=source[1];
 510             oredChars|=target[2]=source[2];
 511             oredChars|=target[3]=source[3];
 512             oredChars|=target[4]=source[4];
 513             oredChars|=target[5]=source[5];
 514             oredChars|=target[6]=source[6];
 515             oredChars|=target[7]=source[7];
 516
 517             /* were all 16 entries really valid? */
 518             if(oredChars>0x7f) {
 519                 /* no, return to the first of these 16 */
 520                 break;
 521             }
 522             source+=8;
 523             target+=8;
 524         } while(--count>0);
 525         count=loops-count;
 526         targetCapacity-=count*8;
 527
 528         if(offsets!=NULL) {
 529             oldTarget+=count*8;
 530             while(count>0) {
 531                 offsets[0]=sourceIndex++;
 532                 offsets[1]=sourceIndex++;
 533                 offsets[2]=sourceIndex++;
 534                 offsets[3]=sourceIndex++;
 535                 offsets[4]=sourceIndex++;
 536                 offsets[5]=sourceIndex++;
 537                 offsets[6]=sourceIndex++;
 538                 offsets[7]=sourceIndex++;
 539                 offsets+=8;
 540                 --count;
 541             }
 542         }
 543     }
 544
 545     /* conversion loop */
 546     c=0;
 547     while(targetCapacity>0 && (c=*source++)<=0x7f) {
 548         *target++=c;
 549         --targetCapacity;
 550     }
 551
 552     if(c>0x7f) {
 553         /* callback(illegal); copy the current bytes to toUBytes[] */
 554         UConverter *cnv=pArgs->converter;
 555         cnv->toUBytes[0]=c;
 556         cnv->toULength=1;
 557         *pErrorCode=U_ILLEGAL_CHAR_FOUND;
 558     } else if(source<sourceLimit && target>=pArgs->targetLimit) {
 559         /* target is full */
 560         *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
 561     }
 562
 563     /* set offsets since the start */
 564     if(offsets!=NULL) {
 565         size_t count=target-oldTarget;
 566         while(count>0) {
 567             *offsets++=sourceIndex++;
 568             --count;
 569         }
 570     }
 571
 572     /* write back the updated pointers */
 573     pArgs->source=(const char *)source;
 574     pArgs->target=target;
 575     pArgs->offsets=offsets;
 576 }
 577
 578 /* This is a table-less version of ucnv_MBCSSingleGetNextUChar(). */
 579 static UChar32
 580 _ASCIIGetNextUChar(UConverterToUnicodeArgs *pArgs,
 581                    UErrorCode *pErrorCode) {
 582     const uint8_t *source;
 583     uint8_t b;
 584
 585     source=(const uint8_t *)pArgs->source;
 586     if(source<(const uint8_t *)pArgs->sourceLimit) {
 587         b=*source++;
 588         pArgs->source=(const char *)source;
 589         if(b<=0x7f) {
 590             return b;
 591         } else {
 592             UConverter *cnv=pArgs->converter;
 593             cnv->toUBytes[0]=b;
 594             cnv->toULength=1;
 595             *pErrorCode=U_ILLEGAL_CHAR_FOUND;
 596             return 0xffff;
 597         }
 598     }
 599
 600     /* no output because of empty input */
 601     *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
 602     return 0xffff;
 603 }
 604
 605 /* "Convert" UTF-8 to US-ASCII: Validate and copy. */
 606 static void
 607 ucnv_ASCIIFromUTF8(UConverterFromUnicodeArgs *pFromUArgs,
 608                    UConverterToUnicodeArgs *pToUArgs,
 609                    UErrorCode *pErrorCode) {
 610     const uint8_t *source, *sourceLimit;
 611     uint8_t *target;
 612     int32_t targetCapacity, length;
 613
 614     uint8_t c;
 615
 616     if(pToUArgs->converter->toUnicodeStatus!=0) {
 617         /* no handling of partial UTF-8 characters here, fall back to pivoting */
 618         *pErrorCode=U_USING_DEFAULT_WARNING;
 619         return;
 620     }
 621
 622     /* set up the local pointers */
 623     source=(const uint8_t *)pToUArgs->source;
 624     sourceLimit=(const uint8_t *)pToUArgs->sourceLimit;
 625     target=(uint8_t *)pFromUArgs->target;
 626     targetCapacity=(int32_t)(pFromUArgs->targetLimit-pFromUArgs->target);
 627
 628     /*
 629      * since the conversion here is 1:1 uint8_t:uint8_t, we need only one counter
 630      * for the minimum of the sourceLength and targetCapacity
 631      */
 632     length=(int32_t)(sourceLimit-source);
 633     if(length<targetCapacity) {
 634         targetCapacity=length;
 635     }
 636
 637     /* unroll the loop with the most common case */
 638     if(targetCapacity>=16) {
 639         int32_t count, loops;
 640         uint8_t oredChars;
 641
 642         loops=count=targetCapacity>>4;
 643         do {
 644             oredChars=*target++=*source++;
 645             oredChars|=*target++=*source++;
 646             oredChars|=*target++=*source++;
 647             oredChars|=*target++=*source++;
 648             oredChars|=*target++=*source++;
 649             oredChars|=*target++=*source++;
 650             oredChars|=*target++=*source++;
 651             oredChars|=*target++=*source++;
 652             oredChars|=*target++=*source++;
 653             oredChars|=*target++=*source++;
 654             oredChars|=*target++=*source++;
 655             oredChars|=*target++=*source++;
 656             oredChars|=*target++=*source++;
 657             oredChars|=*target++=*source++;
 658             oredChars|=*target++=*source++;
 659             oredChars|=*target++=*source++;
 660
 661             /* were all 16 entries really valid? */
 662             if(oredChars>0x7f) {
 663                 /* no, return to the first of these 16 */
 664                 source-=16;
 665                 target-=16;
 666                 break;
 667             }
 668         } while(--count>0);
 669         count=loops-count;
 670         targetCapacity-=16*count;
 671     }
 672
 673     /* conversion loop */
 674     c=0;
 675     while(targetCapacity>0 && (c=*source)<=0x7f) {
 676         ++source;
 677         *target++=c;
 678         --targetCapacity;
 679     }
 680
 681     if(c>0x7f) {
 682         /* non-ASCII character, handle in standard converter */
 683         *pErrorCode=U_USING_DEFAULT_WARNING;
 684     } else if(source<sourceLimit && target>=(const uint8_t *)pFromUArgs->targetLimit) {
 685         /* target is full */
 686         *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
 687     }
 688
 689     /* write back the updated pointers */
 690     pToUArgs->source=(const char *)source;
 691     pFromUArgs->target=(char *)target;
 692 }
 693
 694 static void
 695 _ASCIIGetUnicodeSet(const UConverter *cnv,
 696                     const USetAdder *sa,
 697                     UConverterUnicodeSet which,
 698                     UErrorCode *pErrorCode) {
 699     sa->addRange(sa->set, 0, 0x7f);
 700 }
 701
 702 static const UConverterImpl _ASCIIImpl={
 703     UCNV_US_ASCII,
 704
 705     NULL,
 706     NULL,
 707
 708     NULL,
 709     NULL,
 710     NULL,
 711
 712     _ASCIIToUnicodeWithOffsets,
 713     _ASCIIToUnicodeWithOffsets,
 714     _Latin1FromUnicodeWithOffsets,
 715     _Latin1FromUnicodeWithOffsets,
 716     _ASCIIGetNextUChar,
 717
 718     NULL,
 719     NULL,
 720     NULL,
 721     NULL,
 722     _ASCIIGetUnicodeSet,
 723
 724     NULL,
 725     ucnv_ASCIIFromUTF8
 726 };
 727
 728 static const UConverterStaticData _ASCIIStaticData={
 729     sizeof(UConverterStaticData),
 730     "US-ASCII",
 731     367, UCNV_IBM, UCNV_US_ASCII, 1, 1,
 732     { 0x1a, 0, 0, 0 }, 1, FALSE, FALSE,
 733     0,
 734     0,
 735     { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } /* reserved */
 736 };
 737
 738 const UConverterSharedData _ASCIIData={
 739     sizeof(UConverterSharedData), ~((uint32_t) 0),
 740     NULL, NULL, &_ASCIIStaticData, FALSE, &_ASCIIImpl,
 741     0
 742 };
 743
 744 #endif