icuSources/common/ucnvlat1.c

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