• <ins id="pjuwb"></ins>
    <blockquote id="pjuwb"><pre id="pjuwb"></pre></blockquote>
    <noscript id="pjuwb"></noscript>
          <sup id="pjuwb"><pre id="pjuwb"></pre></sup>
            <dd id="pjuwb"></dd>
            <abbr id="pjuwb"></abbr>

            Kisser Leon

            這個kisser不太冷
            posts - 100, comments - 102, trackbacks - 0, articles - 0

            ConvertUTF.c

            Posted on 2007-03-08 16:02 kk 閱讀(3321) 評論(0)  編輯 收藏 引用 所屬分類: IT
            UTF8和UTF16和UTF32之間的相互轉(zhuǎn)化

            /* ================================================================ */
            /*
            File:?? ?ConvertUTF.C
            Author: Mark E. Davis
            Copyright (C) 1994 Taligent, Inc. All rights reserved.

            This code is copyrighted. Under the copyright laws, this code may not
            be copied, in whole or part, without prior written consent of Taligent.

            Taligent grants the right to use or reprint this code as long as this
            ENTIRE copyright notice is reproduced in the code or reproduction.
            The code is provided AS-IS, AND TALIGENT DISCLAIMS ALL WARRANTIES,
            EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO IMPLIED
            WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.? IN
            NO EVENT WILL TALIGENT BE LIABLE FOR ANY DAMAGES WHATSOEVER (INCLUDING,
            WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS
            INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR OTHER PECUNIARY
            LOSS) ARISING OUT OF THE USE OR INABILITY TO USE THIS CODE, EVEN
            IF TALIGENT HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
            BECAUSE SOME STATES DO NOT ALLOW THE EXCLUSION OR LIMITATION OF
            LIABILITY FOR CONSEQUENTIAL OR INCIDENTAL DAMAGES, THE ABOVE
            LIMITATION MAY NOT APPLY TO YOU.

            RESTRICTED RIGHTS LEGEND: Use, duplication, or disclosure by the
            government is subject to restrictions as set forth in subparagraph
            (c)(l)(ii) of the Rights in Technical Data and Computer Software
            clause at DFARS 252.227-7013 and FAR 52.227-19.

            This code may be protected by one or more U.S. and International
            Patents.

            TRADEMARKS: Taligent and the Taligent Design Mark are registered
            trademarks of Taligent, Inc.
            */
            /* ================================================================ */

            #include "ConvertUTF.h"

            /* ================================================================ */

            const int halfShift?? ??? ??? ??? ?= 10;
            const UCS4 halfBase?? ??? ??? ??? ?= 0x0010000UL;
            const UCS4 halfMask?? ??? ??? ??? ?= 0x3FFUL;
            const UCS4 kSurrogateHighStart?? ?= 0xD800UL;
            const UCS4 kSurrogateHighEnd?? ?= 0xDBFFUL;
            const UCS4 kSurrogateLowStart?? ?= 0xDC00UL;
            const UCS4 kSurrogateLowEnd?? ??? ?= 0xDFFFUL;

            /* ================================================================ */

            ConversionResult?? ?ConvertUCS4toUTF16 (
            ?? ??? ?UCS4** sourceStart, const UCS4* sourceEnd,
            ?? ??? ?UTF16** targetStart, const UTF16* targetEnd) {
            ?? ?ConversionResult result = kUTFConversionOK;
            ?? ?register UCS4* source = *sourceStart;
            ?? ?register UTF16* target = *targetStart;
            ?? ?while (source < sourceEnd) {
            ?? ??? ?register UCS4 ch;
            ?? ??? ?if (target >= targetEnd) {
            ?? ??? ??? ?result = kUTFConversionTargetExhausted; break;
            ?? ??? ?};
            ?? ??? ?ch = *source++;
            ?? ??? ?if (ch <= kMaximumUCS2) {
            ?? ??? ??? ?*target++ = ch;
            ?? ??? ?} else if (ch > kMaximumUTF16) {
            ?? ??? ??? ?*target++ = kReplacementCharacter;
            ?? ??? ?} else {
            ?? ??? ??? ?if (target + 1 >= targetEnd) {
            ?? ??? ??? ??? ?result = kUTFConversionTargetExhausted; break;
            ?? ??? ??? ?};
            ?? ??? ??? ?ch -= halfBase;
            ?? ??? ??? ?*target++ = (ch >> halfShift) + kSurrogateHighStart;
            ?? ??? ??? ?*target++ = (ch & halfMask) + kSurrogateLowStart;
            ?? ??? ?};
            ?? ?};
            ?? ?*sourceStart = source;
            ?? ?*targetStart = target;
            ?? ?return result;
            };

            /* ================================================================ */

            ConversionResult?? ?ConvertUTF16toUCS4 (
            ?? ??? ?UTF16** sourceStart, UTF16* sourceEnd,
            ?? ??? ?UCS4** targetStart, const UCS4* targetEnd) {
            ?? ?ConversionResult result = kUTFConversionOK;
            ?? ?register UTF16* source = *sourceStart;
            ?? ?register UCS4* target = *targetStart;
            ?? ?while (source < sourceEnd) {
            ?? ??? ?register UCS4 ch;
            ?? ??? ?ch = *source++;
            ?? ??? ?if (ch >= kSurrogateHighStart && ch <= kSurrogateHighEnd && source < sourceEnd) {
            ?? ??? ??? ?register UCS4 ch2 = *source;
            ?? ??? ??? ?if (ch2 >= kSurrogateLowStart && ch2 <= kSurrogateLowEnd) {
            ?? ??? ??? ??? ?ch = ((ch - kSurrogateHighStart) << halfShift)
            ?? ??? ??? ??? ??? ?+ (ch2 - kSurrogateLowStart) + halfBase;
            ?? ??? ??? ??? ?++source;
            ?? ??? ??? ?};
            ?? ??? ?};
            ?? ??? ?if (target >= targetEnd) {
            ?? ??? ??? ?result = kUTFConversionTargetExhausted; break;
            ?? ??? ?};
            ?? ??? ?*target++ = ch;
            ?? ?};
            ?? ?*sourceStart = source;
            ?? ?*targetStart = target;
            ?? ?return result;
            };

            /* ================================================================ */

            UCS4 offsetsFromUTF8[6] =?? ?{0x00000000UL, 0x00003080UL, 0x000E2080UL,
            ?? ??? ??? ??? ??? ? ?? ? ?? ? 0x03C82080UL, 0xFA082080UL, 0x82082080UL};
            char bytesFromUTF8[256] = {
            ?? ?0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
            ?? ?0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
            ?? ?0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
            ?? ?0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
            ?? ?0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
            ?? ?0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
            ?? ?1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
            ?? ?2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5};

            UTF8 firstByteMark[7] = {0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC};

            /* ================================================================ */
            /*?? ?This code is similar in effect to making successive calls on the
            mbtowc and wctomb routines in FSS-UTF. However, it is considerably
            different in code:
            * it is adapted to be consistent with UTF16,
            * the interface converts a whole buffer to avoid function-call overhead
            * constants have been gathered.
            * loops & conditionals have been removed as much as possible for
            efficiency, in favor of drop-through switch statements.
            */

            /* ================================================================ */
            ConversionResult?? ?ConvertUTF16toUTF8 (
            ?? ??? ?UTF16** sourceStart, const UTF16* sourceEnd,
            ?? ??? ?UTF8** targetStart, const UTF8* targetEnd)
            {
            ?? ?ConversionResult result = kUTFConversionOK;
            ?? ?register UTF16* source = *sourceStart;
            ?? ?register UTF8* target = *targetStart;
            ?? ?while (source < sourceEnd) {
            ?? ??? ?register UCS4 ch;
            ?? ??? ?register unsigned short bytesToWrite = 0;
            ?? ??? ?register const UCS4 byteMask = 0xBF;
            ?? ??? ?register const UCS4 byteMark = 0x80;
            ?? ??? ?ch = *source++;
            ?? ??? ?if (ch >= kSurrogateHighStart && ch <= kSurrogateHighEnd
            ?? ??? ??? ??? ?&& source < sourceEnd) {
            ?? ??? ??? ?register UCS4 ch2 = *source;
            ?? ??? ??? ?if (ch2 >= kSurrogateLowStart && ch2 <= kSurrogateLowEnd) {
            ?? ??? ??? ??? ?ch = ((ch - kSurrogateHighStart) << halfShift)
            ?? ??? ??? ??? ??? ?+ (ch2 - kSurrogateLowStart) + halfBase;
            ?? ??? ??? ??? ?++source;
            ?? ??? ??? ?};
            ?? ??? ?};
            ?? ??? ?if (ch < 0x80) {?? ??? ??? ??? ?bytesToWrite = 1;
            ?? ??? ?} else if (ch < 0x800) {?? ??? ?bytesToWrite = 2;
            ?? ??? ?} else if (ch < 0x10000) {?? ??? ?bytesToWrite = 3;
            ?? ??? ?} else if (ch < 0x200000) {?? ??? ?bytesToWrite = 4;
            ?? ??? ?} else if (ch < 0x4000000) {?? ?bytesToWrite = 5;
            ?? ??? ?} else if (ch <= kMaximumUCS4){?? ?bytesToWrite = 6;
            ?? ??? ?} else {?? ??? ??? ??? ??? ??? ?bytesToWrite = 2;
            ?? ??? ??? ??? ??? ??? ??? ??? ??? ??? ?ch = kReplacementCharacter;
            ?? ??? ?}; /* I wish there were a smart way to avoid this conditional */
            ?? ??? ?
            ?? ??? ?target += bytesToWrite;
            ?? ??? ?if (target > targetEnd) {
            ?? ??? ??? ?target -= bytesToWrite; result = kUTFConversionTargetExhausted; break;
            ?? ??? ?};
            ?? ??? ?switch (bytesToWrite) {?? ?/* note: code falls through cases! */
            ?? ??? ??? ?case 6:?? ?*--target = (ch | byteMark) & byteMask; ch >>= 6;
            ?? ??? ??? ?case 5:?? ?*--target = (ch | byteMark) & byteMask; ch >>= 6;
            ?? ??? ??? ?case 4:?? ?*--target = (ch | byteMark) & byteMask; ch >>= 6;
            ?? ??? ??? ?case 3:?? ?*--target = (ch | byteMark) & byteMask; ch >>= 6;
            ?? ??? ??? ?case 2:?? ?*--target = (ch | byteMark) & byteMask; ch >>= 6;
            ?? ??? ??? ?case 1:?? ?*--target =? ch | firstByteMark[bytesToWrite];
            ?? ??? ?};
            ?? ??? ?target += bytesToWrite;
            ?? ?};
            ?? ?*sourceStart = source;
            ?? ?*targetStart = target;
            ?? ?return result;
            };

            /* ================================================================ */

            ConversionResult?? ?ConvertUTF8toUTF16 (
            ?? ??? ?UTF8** sourceStart, const UTF8* sourceEnd,
            ?? ??? ?UTF16** targetStart, const UTF16* targetEnd)
            {
            ?? ?ConversionResult result = kUTFConversionOK;
            ?? ?register UTF8* source = *sourceStart;
            ?? ?register UTF16* target = *targetStart;
            ?? ?while (source < sourceEnd) {
            ?? ??? ?register UCS4 ch = 0;
            ?? ??? ?register unsigned short extraBytesToWrite = bytesFromUTF8[*source];
            ?? ??? ?if (source + extraBytesToWrite > sourceEnd) {
            ?? ??? ??? ?result = kUTFConversionSourceExhausted; break;
            ?? ??? ?};
            ?? ??? ?switch(extraBytesToWrite) {?? ?/* note: code falls through cases! */
            ?? ??? ??? ?case 5:?? ?ch += *source++; ch <<= 6;
            ?? ??? ??? ?case 4:?? ?ch += *source++; ch <<= 6;
            ?? ??? ??? ?case 3:?? ?ch += *source++; ch <<= 6;
            ?? ??? ??? ?case 2:?? ?ch += *source++; ch <<= 6;
            ?? ??? ??? ?case 1:?? ?ch += *source++; ch <<= 6;
            ?? ??? ??? ?case 0:?? ?ch += *source++;
            ?? ??? ?};
            ?? ??? ?ch -= offsetsFromUTF8[extraBytesToWrite];

            ?? ??? ?if (target >= targetEnd) {
            ?? ??? ??? ?result = kUTFConversionTargetExhausted; break;
            ?? ??? ?};
            ?? ??? ?if (ch <= kMaximumUCS2) {
            ?? ??? ??? ?*target++ = ch;
            ?? ??? ?} else if (ch > kMaximumUTF16) {
            ?? ??? ??? ?*target++ = kReplacementCharacter;
            ?? ??? ?} else {
            ?? ??? ??? ?if (target + 1 >= targetEnd) {
            ?? ??? ??? ??? ?result = kUTFConversionTargetExhausted; break;
            ?? ??? ??? ?};
            ?? ??? ??? ?ch -= halfBase;
            ?? ??? ??? ?*target++ = (ch >> halfShift) + kSurrogateHighStart;
            ?? ??? ??? ?*target++ = (ch & halfMask) + kSurrogateLowStart;
            ?? ??? ?};
            ?? ?};
            ?? ?*sourceStart = source;
            ?? ?*targetStart = target;
            ?? ?return result;
            };

            /* ================================================================ */
            ConversionResult?? ?ConvertUCS4toUTF8 (
            ?? ??? ?UCS4** sourceStart, const UCS4* sourceEnd,
            ?? ??? ?UTF8** targetStart, const UTF8* targetEnd)
            {
            ?? ?ConversionResult result = kUTFConversionOK;
            ?? ?register UCS4* source = *sourceStart;
            ?? ?register UTF8* target = *targetStart;
            ?? ?while (source < sourceEnd) {
            ?? ??? ?register UCS4 ch;
            ?? ??? ?register unsigned short bytesToWrite = 0;
            ?? ??? ?register const UCS4 byteMask = 0xBF;
            ?? ??? ?register const UCS4 byteMark = 0x80;
            ?? ??? ?ch = *source++;
            ?? ??? ?if (ch >= kSurrogateHighStart && ch <= kSurrogateHighEnd
            ?? ??? ??? ??? ?&& source < sourceEnd) {
            ?? ??? ??? ?register UCS4 ch2 = *source;
            ?? ??? ??? ?if (ch2 >= kSurrogateLowStart && ch2 <= kSurrogateLowEnd) {
            ?? ??? ??? ??? ?ch = ((ch - kSurrogateHighStart) << halfShift)
            ?? ??? ??? ??? ??? ?+ (ch2 - kSurrogateLowStart) + halfBase;
            ?? ??? ??? ??? ?++source;
            ?? ??? ??? ?};
            ?? ??? ?};
            ?? ??? ?if (ch < 0x80) {?? ??? ??? ??? ?bytesToWrite = 1;
            ?? ??? ?} else if (ch < 0x800) {?? ??? ?bytesToWrite = 2;
            ?? ??? ?} else if (ch < 0x10000) {?? ??? ?bytesToWrite = 3;
            ?? ??? ?} else if (ch < 0x200000) {?? ??? ?bytesToWrite = 4;
            ?? ??? ?} else if (ch < 0x4000000) {?? ?bytesToWrite = 5;
            ?? ??? ?} else if (ch <= kMaximumUCS4){?? ?bytesToWrite = 6;
            ?? ??? ?} else {?? ??? ??? ??? ??? ??? ?bytesToWrite = 2;
            ?? ??? ??? ??? ??? ??? ??? ??? ??? ??? ?ch = kReplacementCharacter;
            ?? ??? ?}; /* I wish there were a smart way to avoid this conditional */
            ?? ??? ?
            ?? ??? ?target += bytesToWrite;
            ?? ??? ?if (target > targetEnd) {
            ?? ??? ??? ?target -= bytesToWrite; result = kUTFConversionTargetExhausted; break;
            ?? ??? ?};
            ?? ??? ?switch (bytesToWrite) {?? ?/* note: code falls through cases! */
            ?? ??? ??? ?case 6:?? ?*--target = (ch | byteMark) & byteMask; ch >>= 6;
            ?? ??? ??? ?case 5:?? ?*--target = (ch | byteMark) & byteMask; ch >>= 6;
            ?? ??? ??? ?case 4:?? ?*--target = (ch | byteMark) & byteMask; ch >>= 6;
            ?? ??? ??? ?case 3:?? ?*--target = (ch | byteMark) & byteMask; ch >>= 6;
            ?? ??? ??? ?case 2:?? ?*--target = (ch | byteMark) & byteMask; ch >>= 6;
            ?? ??? ??? ?case 1:?? ?*--target =? ch | firstByteMark[bytesToWrite];
            ?? ??? ?};
            ?? ??? ?target += bytesToWrite;
            ?? ?};
            ?? ?*sourceStart = source;
            ?? ?*targetStart = target;
            ?? ?return result;
            };

            /* ================================================================ */

            ConversionResult?? ?ConvertUTF8toUCS4 (
            ?? ??? ?UTF8** sourceStart, const UTF8* sourceEnd,
            ?? ??? ?UCS4** targetStart, const UCS4* targetEnd)
            {
            ?? ?ConversionResult result = kUTFConversionOK;
            ?? ?register UTF8* source = *sourceStart;
            ?? ?register UCS4* target = *targetStart;
            ?? ?while (source < sourceEnd) {
            ?? ??? ?register UCS4 ch = 0;
            ?? ??? ?register unsigned short extraBytesToWrite = bytesFromUTF8[*source];
            ?? ??? ?if (source + extraBytesToWrite > sourceEnd) {
            ?? ??? ??? ?result = kUTFConversionSourceExhausted; break;
            ?? ??? ?};
            ?? ??? ?switch(extraBytesToWrite) {?? ?/* note: code falls through cases! */
            ?? ??? ??? ?case 5:?? ?ch += *source++; ch <<= 6;
            ?? ??? ??? ?case 4:?? ?ch += *source++; ch <<= 6;
            ?? ??? ??? ?case 3:?? ?ch += *source++; ch <<= 6;
            ?? ??? ??? ?case 2:?? ?ch += *source++; ch <<= 6;
            ?? ??? ??? ?case 1:?? ?ch += *source++; ch <<= 6;
            ?? ??? ??? ?case 0:?? ?ch += *source++;
            ?? ??? ?};
            ?? ??? ?ch -= offsetsFromUTF8[extraBytesToWrite];

            ?? ??? ?if (target >= targetEnd) {
            ?? ??? ??? ?result = kUTFConversionTargetExhausted; break;
            ?? ??? ?};
            ?? ??? ?if (ch <= kMaximumUCS2) {
            ?? ??? ??? ?*target++ = ch;
            ?? ??? ?} else if (ch > kMaximumUCS4) {
            ?? ??? ??? ?*target++ = kReplacementCharacter;
            ?? ??? ?} else {
            ?? ??? ??? ?if (target + 1 >= targetEnd) {
            ?? ??? ??? ??? ?result = kUTFConversionTargetExhausted; break;
            ?? ??? ??? ?};
            ?? ??? ??? ?ch -= halfBase;
            ?? ??? ??? ?*target++ = (ch >> halfShift) + kSurrogateHighStart;
            ?? ??? ??? ?*target++ = (ch & halfMask) + kSurrogateLowStart;
            ?? ??? ?};
            ?? ?};
            ?? ?*sourceStart = source;
            ?? ?*targetStart = target;
            ?? ?return result;
            };

            88久久精品无码一区二区毛片 | 麻豆精品久久久一区二区| 国产精品一久久香蕉产线看 | 久久99精品国产麻豆| 久久青草国产精品一区| 亚洲国产精品综合久久网络| 久久精品国产AV一区二区三区| 久久福利青草精品资源站| 亚洲日韩欧美一区久久久久我 | 狠狠色综合网站久久久久久久高清| 久久亚洲春色中文字幕久久久| 久久综合伊人77777麻豆| 欧美熟妇另类久久久久久不卡 | 久久精品国产半推半就| 欧美一区二区久久精品| 91久久精品电影| 久久精品aⅴ无码中文字字幕重口| 久久精品国产72国产精福利| 99999久久久久久亚洲| 欧美精品九九99久久在观看| 国产叼嘿久久精品久久| 国产精品久久久久久一区二区三区| 中文无码久久精品| 日韩电影久久久被窝网| 久久国产热这里只有精品| 国产精品VIDEOSSEX久久发布| 国产产无码乱码精品久久鸭| 久久亚洲精品人成综合网| 亚洲AV无码久久精品色欲| 国产aⅴ激情无码久久| 欧美亚洲国产精品久久| 人妻无码αv中文字幕久久琪琪布 人妻无码精品久久亚瑟影视 | 国产精品久久久久久久久| 久久精品人人槡人妻人人玩AV| 奇米影视7777久久精品| 亚洲中文字幕无码久久精品1| 久久人人爽人人人人爽AV| 99精品久久久久久久婷婷| 久久精品夜夜夜夜夜久久| AV无码久久久久不卡蜜桃| 嫩草影院久久国产精品|