| // © 2016 and later: Unicode, Inc. and others. | |
| // License & terms of use: http://www.unicode.org/copyright.html | |
| /* | |
| ********************************************************************** | |
| * Copyright (C) 2000-2015, International Business Machines | |
| * Corporation and others. All Rights Reserved. | |
| ********************************************************************** | |
| * file name: ucnvlat1.cpp | |
| * encoding: UTF-8 | |
| * tab size: 8 (not used) | |
| * indentation:4 | |
| * | |
| * created on: 2000feb07 | |
| * created by: Markus W. Scherer | |
| */ | |
| #include "unicode/utypes.h" | |
| #if !UCONFIG_NO_CONVERSION | |
| #include "unicode/ucnv.h" | |
| #include "unicode/uset.h" | |
| #include "unicode/utf8.h" | |
| #include "ucnv_bld.h" | |
| #include "ucnv_cnv.h" | |
| #include "ustr_imp.h" | |
| /* control optimizations according to the platform */ | |
| #define LATIN1_UNROLL_FROM_UNICODE 1 | |
| /* ISO 8859-1 --------------------------------------------------------------- */ | |
| /* This is a table-less and callback-less version of ucnv_MBCSSingleToBMPWithOffsets(). */ | |
| U_CDECL_BEGIN | |
| static void U_CALLCONV | |
| _Latin1ToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs, | |
| UErrorCode *pErrorCode) { | |
| const uint8_t *source; | |
| UChar *target; | |
| int32_t targetCapacity, length; | |
| int32_t *offsets; | |
| int32_t sourceIndex; | |
| /* set up the local pointers */ | |
| source=(const uint8_t *)pArgs->source; | |
| target=pArgs->target; | |
| targetCapacity=(int32_t)(pArgs->targetLimit-pArgs->target); | |
| offsets=pArgs->offsets; | |
| sourceIndex=0; | |
| /* | |
| * since the conversion here is 1:1 UChar:uint8_t, we need only one counter | |
| * for the minimum of the sourceLength and targetCapacity | |
| */ | |
| length=(int32_t)((const uint8_t *)pArgs->sourceLimit-source); | |
| if(length<=targetCapacity) { | |
| targetCapacity=length; | |
| } else { | |
| /* target will be full */ | |
| *pErrorCode=U_BUFFER_OVERFLOW_ERROR; | |
| length=targetCapacity; | |
| } | |
| if(targetCapacity>=8) { | |
| /* This loop is unrolled for speed and improved pipelining. */ | |
| int32_t count, loops; | |
| loops=count=targetCapacity>>3; | |
| length=targetCapacity&=0x7; | |
| do { | |
| target[0]=source[0]; | |
| target[1]=source[1]; | |
| target[2]=source[2]; | |
| target[3]=source[3]; | |
| target[4]=source[4]; | |
| target[5]=source[5]; | |
| target[6]=source[6]; | |
| target[7]=source[7]; | |
| target+=8; | |
| source+=8; | |
| } while(--count>0); | |
| if(offsets!=NULL) { | |
| do { | |
| offsets[0]=sourceIndex++; | |
| offsets[1]=sourceIndex++; | |
| offsets[2]=sourceIndex++; | |
| offsets[3]=sourceIndex++; | |
| offsets[4]=sourceIndex++; | |
| offsets[5]=sourceIndex++; | |
| offsets[6]=sourceIndex++; | |
| offsets[7]=sourceIndex++; | |
| offsets+=8; | |
| } while(--loops>0); | |
| } | |
| } | |
| /* conversion loop */ | |
| while(targetCapacity>0) { | |
| *target++=*source++; | |
| --targetCapacity; | |
| } | |
| /* write back the updated pointers */ | |
| pArgs->source=(const char *)source; | |
| pArgs->target=target; | |
| /* set offsets */ | |
| if(offsets!=NULL) { | |
| while(length>0) { | |
| *offsets++=sourceIndex++; | |
| --length; | |
| } | |
| pArgs->offsets=offsets; | |
| } | |
| } | |
| /* This is a table-less and callback-less version of ucnv_MBCSSingleGetNextUChar(). */ | |
| static UChar32 U_CALLCONV | |
| _Latin1GetNextUChar(UConverterToUnicodeArgs *pArgs, | |
| UErrorCode *pErrorCode) { | |
| const uint8_t *source=(const uint8_t *)pArgs->source; | |
| if(source<(const uint8_t *)pArgs->sourceLimit) { | |
| pArgs->source=(const char *)(source+1); | |
| return *source; | |
| } | |
| /* no output because of empty input */ | |
| *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR; | |
| return 0xffff; | |
| } | |
| /* This is a table-less version of ucnv_MBCSSingleFromBMPWithOffsets(). */ | |
| static void U_CALLCONV | |
| _Latin1FromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs, | |
| UErrorCode *pErrorCode) { | |
| UConverter *cnv; | |
| const UChar *source, *sourceLimit; | |
| uint8_t *target, *oldTarget; | |
| int32_t targetCapacity, length; | |
| int32_t *offsets; | |
| UChar32 cp; | |
| UChar c, max; | |
| int32_t sourceIndex; | |
| /* set up the local pointers */ | |
| cnv=pArgs->converter; | |
| source=pArgs->source; | |
| sourceLimit=pArgs->sourceLimit; | |
| target=oldTarget=(uint8_t *)pArgs->target; | |
| targetCapacity=(int32_t)(pArgs->targetLimit-pArgs->target); | |
| offsets=pArgs->offsets; | |
| if(cnv->sharedData==&_Latin1Data) { | |
| max=0xff; /* Latin-1 */ | |
| } else { | |
| max=0x7f; /* US-ASCII */ | |
| } | |
| /* get the converter state from UConverter */ | |
| cp=cnv->fromUChar32; | |
| /* sourceIndex=-1 if the current character began in the previous buffer */ | |
| sourceIndex= cp==0 ? 0 : -1; | |
| /* | |
| * since the conversion here is 1:1 UChar:uint8_t, we need only one counter | |
| * for the minimum of the sourceLength and targetCapacity | |
| */ | |
| length=(int32_t)(sourceLimit-source); | |
| if(length<targetCapacity) { | |
| targetCapacity=length; | |
| } | |
| /* conversion loop */ | |
| if(cp!=0 && targetCapacity>0) { | |
| goto getTrail; | |
| } | |
| #if LATIN1_UNROLL_FROM_UNICODE | |
| /* unroll the loop with the most common case */ | |
| if(targetCapacity>=16) { | |
| int32_t count, loops; | |
| UChar u, oredChars; | |
| loops=count=targetCapacity>>4; | |
| do { | |
| oredChars=u=*source++; | |
| *target++=(uint8_t)u; | |
| oredChars|=u=*source++; | |
| *target++=(uint8_t)u; | |
| oredChars|=u=*source++; | |
| *target++=(uint8_t)u; | |
| oredChars|=u=*source++; | |
| *target++=(uint8_t)u; | |
| oredChars|=u=*source++; | |
| *target++=(uint8_t)u; | |
| oredChars|=u=*source++; | |
| *target++=(uint8_t)u; | |
| oredChars|=u=*source++; | |
| *target++=(uint8_t)u; | |
| oredChars|=u=*source++; | |
| *target++=(uint8_t)u; | |
| oredChars|=u=*source++; | |
| *target++=(uint8_t)u; | |
| oredChars|=u=*source++; | |
| *target++=(uint8_t)u; | |
| oredChars|=u=*source++; | |
| *target++=(uint8_t)u; | |
| oredChars|=u=*source++; | |
| *target++=(uint8_t)u; | |
| oredChars|=u=*source++; | |
| *target++=(uint8_t)u; | |
| oredChars|=u=*source++; | |
| *target++=(uint8_t)u; | |
| oredChars|=u=*source++; | |
| *target++=(uint8_t)u; | |
| oredChars|=u=*source++; | |
| *target++=(uint8_t)u; | |
| /* were all 16 entries really valid? */ | |
| if(oredChars>max) { | |
| /* no, return to the first of these 16 */ | |
| source-=16; | |
| target-=16; | |
| break; | |
| } | |
| } while(--count>0); | |
| count=loops-count; | |
| targetCapacity-=16*count; | |
| if(offsets!=NULL) { | |
| oldTarget+=16*count; | |
| while(count>0) { | |
| *offsets++=sourceIndex++; | |
| *offsets++=sourceIndex++; | |
| *offsets++=sourceIndex++; | |
| *offsets++=sourceIndex++; | |
| *offsets++=sourceIndex++; | |
| *offsets++=sourceIndex++; | |
| *offsets++=sourceIndex++; | |
| *offsets++=sourceIndex++; | |
| *offsets++=sourceIndex++; | |
| *offsets++=sourceIndex++; | |
| *offsets++=sourceIndex++; | |
| *offsets++=sourceIndex++; | |
| *offsets++=sourceIndex++; | |
| *offsets++=sourceIndex++; | |
| *offsets++=sourceIndex++; | |
| *offsets++=sourceIndex++; | |
| --count; | |
| } | |
| } | |
| } | |
| #endif | |
| /* conversion loop */ | |
| c=0; | |
| while(targetCapacity>0 && (c=*source++)<=max) { | |
| /* convert the Unicode code point */ | |
| *target++=(uint8_t)c; | |
| --targetCapacity; | |
| } | |
| if(c>max) { | |
| cp=c; | |
| if(!U_IS_SURROGATE(cp)) { | |
| /* callback(unassigned) */ | |
| } else if(U_IS_SURROGATE_LEAD(cp)) { | |
| getTrail: | |
| if(source<sourceLimit) { | |
| /* test the following code unit */ | |
| UChar trail=*source; | |
| if(U16_IS_TRAIL(trail)) { | |
| ++source; | |
| cp=U16_GET_SUPPLEMENTARY(cp, trail); | |
| /* this codepage does not map supplementary code points */ | |
| /* callback(unassigned) */ | |
| } else { | |
| /* this is an unmatched lead code unit (1st surrogate) */ | |
| /* callback(illegal) */ | |
| } | |
| } else { | |
| /* no more input */ | |
| cnv->fromUChar32=cp; | |
| goto noMoreInput; | |
| } | |
| } else { | |
| /* this is an unmatched trail code unit (2nd surrogate) */ | |
| /* callback(illegal) */ | |
| } | |
| *pErrorCode= U_IS_SURROGATE(cp) ? U_ILLEGAL_CHAR_FOUND : U_INVALID_CHAR_FOUND; | |
| cnv->fromUChar32=cp; | |
| } | |
| noMoreInput: | |
| /* set offsets since the start */ | |
| if(offsets!=NULL) { | |
| size_t count=target-oldTarget; | |
| while(count>0) { | |
| *offsets++=sourceIndex++; | |
| --count; | |
| } | |
| } | |
| if(U_SUCCESS(*pErrorCode) && source<sourceLimit && target>=(uint8_t *)pArgs->targetLimit) { | |
| /* target is full */ | |
| *pErrorCode=U_BUFFER_OVERFLOW_ERROR; | |
| } | |
| /* write back the updated pointers */ | |
| pArgs->source=source; | |
| pArgs->target=(char *)target; | |
| pArgs->offsets=offsets; | |
| } | |
| /* Convert UTF-8 to Latin-1. Adapted from ucnv_SBCSFromUTF8(). */ | |
| static void U_CALLCONV | |
| ucnv_Latin1FromUTF8(UConverterFromUnicodeArgs *pFromUArgs, | |
| UConverterToUnicodeArgs *pToUArgs, | |
| UErrorCode *pErrorCode) { | |
| UConverter *utf8; | |
| const uint8_t *source, *sourceLimit; | |
| uint8_t *target; | |
| int32_t targetCapacity; | |
| UChar32 c; | |
| uint8_t b, t1; | |
| /* set up the local pointers */ | |
| utf8=pToUArgs->converter; | |
| source=(uint8_t *)pToUArgs->source; | |
| sourceLimit=(uint8_t *)pToUArgs->sourceLimit; | |
| target=(uint8_t *)pFromUArgs->target; | |
| targetCapacity=(int32_t)(pFromUArgs->targetLimit-pFromUArgs->target); | |
| /* get the converter state from the UTF-8 UConverter */ | |
| if (utf8->toULength > 0) { | |
| c=(UChar32)utf8->toUnicodeStatus; | |
| } else { | |
| c = 0; | |
| } | |
| if(c!=0 && source<sourceLimit) { | |
| if(targetCapacity==0) { | |
| *pErrorCode=U_BUFFER_OVERFLOW_ERROR; | |
| return; | |
| } else if(c>=0xc2 && c<=0xc3 && (t1=(uint8_t)(*source-0x80)) <= 0x3f) { | |
| ++source; | |
| *target++=(uint8_t)(((c&3)<<6)|t1); | |
| --targetCapacity; | |
| utf8->toUnicodeStatus=0; | |
| utf8->toULength=0; | |
| } else { | |
| /* complicated, illegal or unmappable input: fall back to the pivoting implementation */ | |
| *pErrorCode=U_USING_DEFAULT_WARNING; | |
| return; | |
| } | |
| } | |
| /* | |
| * Make sure that the last byte sequence before sourceLimit is complete | |
| * or runs into a lead byte. | |
| * In the conversion loop compare source with sourceLimit only once | |
| * per multi-byte character. | |
| * For Latin-1, adjust sourceLimit only for 1 trail byte because | |
| * the conversion loop handles at most 2-byte sequences. | |
| */ | |
| if(source<sourceLimit && U8_IS_LEAD(*(sourceLimit-1))) { | |
| --sourceLimit; | |
| } | |
| /* conversion loop */ | |
| while(source<sourceLimit) { | |
| if(targetCapacity>0) { | |
| b=*source++; | |
| if(U8_IS_SINGLE(b)) { | |
| /* convert ASCII */ | |
| *target++=(uint8_t)b; | |
| --targetCapacity; | |
| } else if( /* handle U+0080..U+00FF inline */ | |
| b>=0xc2 && b<=0xc3 && | |
| (t1=(uint8_t)(*source-0x80)) <= 0x3f | |
| ) { | |
| ++source; | |
| *target++=(uint8_t)(((b&3)<<6)|t1); | |
| --targetCapacity; | |
| } else { | |
| /* complicated, illegal or unmappable input: fall back to the pivoting implementation */ | |
| pToUArgs->source=(char *)(source-1); | |
| pFromUArgs->target=(char *)target; | |
| *pErrorCode=U_USING_DEFAULT_WARNING; | |
| return; | |
| } | |
| } else { | |
| /* target is full */ | |
| *pErrorCode=U_BUFFER_OVERFLOW_ERROR; | |
| break; | |
| } | |
| } | |
| /* | |
| * The sourceLimit may have been adjusted before the conversion loop | |
| * to stop before a truncated sequence. | |
| * If so, then collect the truncated sequence now. | |
| * For Latin-1, there is at most exactly one lead byte because of the | |
| * smaller sourceLimit adjustment logic. | |
| */ | |
| if(U_SUCCESS(*pErrorCode) && source<(sourceLimit=(uint8_t *)pToUArgs->sourceLimit)) { | |
| utf8->toUnicodeStatus=utf8->toUBytes[0]=b=*source++; | |
| utf8->toULength=1; | |
| utf8->mode=U8_COUNT_BYTES(b); | |
| } | |
| /* write back the updated pointers */ | |
| pToUArgs->source=(char *)source; | |
| pFromUArgs->target=(char *)target; | |
| } | |
| static void U_CALLCONV | |
| _Latin1GetUnicodeSet(const UConverter *cnv, | |
| const USetAdder *sa, | |
| UConverterUnicodeSet which, | |
| UErrorCode *pErrorCode) { | |
| (void)cnv; | |
| (void)which; | |
| (void)pErrorCode; | |
| sa->addRange(sa->set, 0, 0xff); | |
| } | |
| U_CDECL_END | |
| static const UConverterImpl _Latin1Impl={ | |
| UCNV_LATIN_1, | |
| NULL, | |
| NULL, | |
| NULL, | |
| NULL, | |
| NULL, | |
| _Latin1ToUnicodeWithOffsets, | |
| _Latin1ToUnicodeWithOffsets, | |
| _Latin1FromUnicodeWithOffsets, | |
| _Latin1FromUnicodeWithOffsets, | |
| _Latin1GetNextUChar, | |
| NULL, | |
| NULL, | |
| NULL, | |
| NULL, | |
| _Latin1GetUnicodeSet, | |
| NULL, | |
| ucnv_Latin1FromUTF8 | |
| }; | |
| static const UConverterStaticData _Latin1StaticData={ | |
| sizeof(UConverterStaticData), | |
| "ISO-8859-1", | |
| 819, UCNV_IBM, UCNV_LATIN_1, 1, 1, | |
| { 0x1a, 0, 0, 0 }, 1, FALSE, FALSE, | |
| 0, | |
| 0, | |
| { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } /* reserved */ | |
| }; | |
| const UConverterSharedData _Latin1Data= | |
| UCNV_IMMUTABLE_SHARED_DATA_INITIALIZER(&_Latin1StaticData, &_Latin1Impl); | |
| /* US-ASCII ----------------------------------------------------------------- */ | |
| U_CDECL_BEGIN | |
| /* This is a table-less version of ucnv_MBCSSingleToBMPWithOffsets(). */ | |
| static void U_CALLCONV | |
| _ASCIIToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs, | |
| UErrorCode *pErrorCode) { | |
| const uint8_t *source, *sourceLimit; | |
| UChar *target, *oldTarget; | |
| int32_t targetCapacity, length; | |
| int32_t *offsets; | |
| int32_t sourceIndex; | |
| uint8_t c; | |
| /* set up the local pointers */ | |
| source=(const uint8_t *)pArgs->source; | |
| sourceLimit=(const uint8_t *)pArgs->sourceLimit; | |
| target=oldTarget=pArgs->target; | |
| targetCapacity=(int32_t)(pArgs->targetLimit-pArgs->target); | |
| offsets=pArgs->offsets; | |
| /* sourceIndex=-1 if the current character began in the previous buffer */ | |
| sourceIndex=0; | |
| /* | |
| * since the conversion here is 1:1 UChar:uint8_t, we need only one counter | |
| * for the minimum of the sourceLength and targetCapacity | |
| */ | |
| length=(int32_t)(sourceLimit-source); | |
| if(length<targetCapacity) { | |
| targetCapacity=length; | |
| } | |
| if(targetCapacity>=8) { | |
| /* This loop is unrolled for speed and improved pipelining. */ | |
| int32_t count, loops; | |
| UChar oredChars; | |
| loops=count=targetCapacity>>3; | |
| do { | |
| oredChars=target[0]=source[0]; | |
| oredChars|=target[1]=source[1]; | |
| oredChars|=target[2]=source[2]; | |
| oredChars|=target[3]=source[3]; | |
| oredChars|=target[4]=source[4]; | |
| oredChars|=target[5]=source[5]; | |
| oredChars|=target[6]=source[6]; | |
| oredChars|=target[7]=source[7]; | |
| /* were all 16 entries really valid? */ | |
| if(oredChars>0x7f) { | |
| /* no, return to the first of these 16 */ | |
| break; | |
| } | |
| source+=8; | |
| target+=8; | |
| } while(--count>0); | |
| count=loops-count; | |
| targetCapacity-=count*8; | |
| if(offsets!=NULL) { | |
| oldTarget+=count*8; | |
| while(count>0) { | |
| offsets[0]=sourceIndex++; | |
| offsets[1]=sourceIndex++; | |
| offsets[2]=sourceIndex++; | |
| offsets[3]=sourceIndex++; | |
| offsets[4]=sourceIndex++; | |
| offsets[5]=sourceIndex++; | |
| offsets[6]=sourceIndex++; | |
| offsets[7]=sourceIndex++; | |
| offsets+=8; | |
| --count; | |
| } | |
| } | |
| } | |
| /* conversion loop */ | |
| c=0; | |
| while(targetCapacity>0 && (c=*source++)<=0x7f) { | |
| *target++=c; | |
| --targetCapacity; | |
| } | |
| if(c>0x7f) { | |
| /* callback(illegal); copy the current bytes to toUBytes[] */ | |
| UConverter *cnv=pArgs->converter; | |
| cnv->toUBytes[0]=c; | |
| cnv->toULength=1; | |
| *pErrorCode=U_ILLEGAL_CHAR_FOUND; | |
| } else if(source<sourceLimit && target>=pArgs->targetLimit) { | |
| /* target is full */ | |
| *pErrorCode=U_BUFFER_OVERFLOW_ERROR; | |
| } | |
| /* set offsets since the start */ | |
| if(offsets!=NULL) { | |
| size_t count=target-oldTarget; | |
| while(count>0) { | |
| *offsets++=sourceIndex++; | |
| --count; | |
| } | |
| } | |
| /* write back the updated pointers */ | |
| pArgs->source=(const char *)source; | |
| pArgs->target=target; | |
| pArgs->offsets=offsets; | |
| } | |
| /* This is a table-less version of ucnv_MBCSSingleGetNextUChar(). */ | |
| static UChar32 U_CALLCONV | |
| _ASCIIGetNextUChar(UConverterToUnicodeArgs *pArgs, | |
| UErrorCode *pErrorCode) { | |
| const uint8_t *source; | |
| uint8_t b; | |
| source=(const uint8_t *)pArgs->source; | |
| if(source<(const uint8_t *)pArgs->sourceLimit) { | |
| b=*source++; | |
| pArgs->source=(const char *)source; | |
| if(b<=0x7f) { | |
| return b; | |
| } else { | |
| UConverter *cnv=pArgs->converter; | |
| cnv->toUBytes[0]=b; | |
| cnv->toULength=1; | |
| *pErrorCode=U_ILLEGAL_CHAR_FOUND; | |
| return 0xffff; | |
| } | |
| } | |
| /* no output because of empty input */ | |
| *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR; | |
| return 0xffff; | |
| } | |
| /* "Convert" UTF-8 to US-ASCII: Validate and copy. */ | |
| static void U_CALLCONV | |
| ucnv_ASCIIFromUTF8(UConverterFromUnicodeArgs *pFromUArgs, | |
| UConverterToUnicodeArgs *pToUArgs, | |
| UErrorCode *pErrorCode) { | |
| const uint8_t *source, *sourceLimit; | |
| uint8_t *target; | |
| int32_t targetCapacity, length; | |
| uint8_t c; | |
| if(pToUArgs->converter->toULength > 0) { | |
| /* no handling of partial UTF-8 characters here, fall back to pivoting */ | |
| *pErrorCode=U_USING_DEFAULT_WARNING; | |
| return; | |
| } | |
| /* set up the local pointers */ | |
| source=(const uint8_t *)pToUArgs->source; | |
| sourceLimit=(const uint8_t *)pToUArgs->sourceLimit; | |
| target=(uint8_t *)pFromUArgs->target; | |
| targetCapacity=(int32_t)(pFromUArgs->targetLimit-pFromUArgs->target); | |
| /* | |
| * since the conversion here is 1:1 uint8_t:uint8_t, we need only one counter | |
| * for the minimum of the sourceLength and targetCapacity | |
| */ | |
| length=(int32_t)(sourceLimit-source); | |
| if(length<targetCapacity) { | |
| targetCapacity=length; | |
| } | |
| /* unroll the loop with the most common case */ | |
| if(targetCapacity>=16) { | |
| int32_t count, loops; | |
| uint8_t oredChars; | |
| loops=count=targetCapacity>>4; | |
| do { | |
| oredChars=*target++=*source++; | |
| oredChars|=*target++=*source++; | |
| oredChars|=*target++=*source++; | |
| oredChars|=*target++=*source++; | |
| oredChars|=*target++=*source++; | |
| oredChars|=*target++=*source++; | |
| oredChars|=*target++=*source++; | |
| oredChars|=*target++=*source++; | |
| oredChars|=*target++=*source++; | |
| oredChars|=*target++=*source++; | |
| oredChars|=*target++=*source++; | |
| oredChars|=*target++=*source++; | |
| oredChars|=*target++=*source++; | |
| oredChars|=*target++=*source++; | |
| oredChars|=*target++=*source++; | |
| oredChars|=*target++=*source++; | |
| /* were all 16 entries really valid? */ | |
| if(oredChars>0x7f) { | |
| /* no, return to the first of these 16 */ | |
| source-=16; | |
| target-=16; | |
| break; | |
| } | |
| } while(--count>0); | |
| count=loops-count; | |
| targetCapacity-=16*count; | |
| } | |
| /* conversion loop */ | |
| c=0; | |
| while(targetCapacity>0 && (c=*source)<=0x7f) { | |
| ++source; | |
| *target++=c; | |
| --targetCapacity; | |
| } | |
| if(c>0x7f) { | |
| /* non-ASCII character, handle in standard converter */ | |
| *pErrorCode=U_USING_DEFAULT_WARNING; | |
| } else if(source<sourceLimit && target>=(const uint8_t *)pFromUArgs->targetLimit) { | |
| /* target is full */ | |
| *pErrorCode=U_BUFFER_OVERFLOW_ERROR; | |
| } | |
| /* write back the updated pointers */ | |
| pToUArgs->source=(const char *)source; | |
| pFromUArgs->target=(char *)target; | |
| } | |
| static void U_CALLCONV | |
| _ASCIIGetUnicodeSet(const UConverter *cnv, | |
| const USetAdder *sa, | |
| UConverterUnicodeSet which, | |
| UErrorCode *pErrorCode) { | |
| (void)cnv; | |
| (void)which; | |
| (void)pErrorCode; | |
| sa->addRange(sa->set, 0, 0x7f); | |
| } | |
| U_CDECL_END | |
| static const UConverterImpl _ASCIIImpl={ | |
| UCNV_US_ASCII, | |
| NULL, | |
| NULL, | |
| NULL, | |
| NULL, | |
| NULL, | |
| _ASCIIToUnicodeWithOffsets, | |
| _ASCIIToUnicodeWithOffsets, | |
| _Latin1FromUnicodeWithOffsets, | |
| _Latin1FromUnicodeWithOffsets, | |
| _ASCIIGetNextUChar, | |
| NULL, | |
| NULL, | |
| NULL, | |
| NULL, | |
| _ASCIIGetUnicodeSet, | |
| NULL, | |
| ucnv_ASCIIFromUTF8 | |
| }; | |
| static const UConverterStaticData _ASCIIStaticData={ | |
| sizeof(UConverterStaticData), | |
| "US-ASCII", | |
| 367, UCNV_IBM, UCNV_US_ASCII, 1, 1, | |
| { 0x1a, 0, 0, 0 }, 1, FALSE, FALSE, | |
| 0, | |
| 0, | |
| { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } /* reserved */ | |
| }; | |
| const UConverterSharedData _ASCIIData= | |
| UCNV_IMMUTABLE_SHARED_DATA_INITIALIZER(&_ASCIIStaticData, &_ASCIIImpl); | |
| #endif |