|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//
// Ported to managed code from c_gb18030.c and related gb18030 dll files
//
//
// Abstract:
//
// Managed implementation of GB18030-2000 (code page 54936) ported from implementation in c_g18030.dll
// If you find a bug here you should check there (in windows) as well and visa versa.
// This file contains functions to convert GB18030-2000 (code page 54936) into Unicode, and vice versa.
//
// Notes:
// GB18030-2000 (aka GBK2K) is designed to be mostly compatible with GBK (codepage 936),
// while supports the full range of Unicode code points (BMP + 16 supplementary planes).
//
// The structure for GB18030 is:
// * Single byte:
// 0x00 ~ 0x7f
// * Two-byte:
// 0x81 ~ 0xfe, 0x40 ~ 0x7e (leading byte, trailing byte)
// 0x81 ~ 0xfe, 0x80 ~ 0xfe (leading byte, trailing byte)
// * Four-byte:
// 0x81 ~ 0xfe, 0x30 ~ 0x39, 0x81 ~ 0xfe, 0x30 ~ 0x39.
// The surrogate pair will be encoded from 0x90, 0x30, 0x81, 0x30
//
// The BMP range is fully supported in GB18030 using 1-byte, 2-byte and 4-byte sequences.
// In valid 4-byte GB18030, there are two gaps that can not be mapped to Unicode characters.
// 0x84, 0x31, 0xa5, 0x30 (just after the GB18030 bytes for U+FFFF(*)) ~ 0x8f, 0x39, 0xfe, 0x39 (just before the first GB18030 bytes for U+D800,U+DC00)
// 0xe3, 0x32, 0x9a, 0x36 (just after the GB18030 bytes for U+DBFF U+DFFF(**)) ~ 0xfe, 0x39, 0xfe, 0x39
//
//
// Note1: U+FFFF = 0x84, 0x31, 0xa4, 0x39
// Note2: U+DBFF U+DFFF = 0xe3, 0x32, 0x9a, 0x35
//
// Tables used in GB18030Encoding:
//
// Our data is similar to the 936 Code Page, so we start from there to build our tables. We build the
// normal double byte mapUnicodeToBytes and mapBytesToUnicode tables by applying differences from 936.
// We also build a map4BytesToUnicode table and a mapUnicodeTo4BytesFlags
//
// * mapUnicodeTo4BytesFlags
// This is an array of bytes, so we have to do a / 8 and << %8 to check the appropriate bit (see Is4Byte())
// If the bit is set its true.
//
// true - If set/true this is a 4 byte code. The value in mapUnicodeToBytes will be the 4 byte offset
// false - If cleared/false this is a 1 or 2 byte code. The value in mapUnicodeToBytes will be the 2 bytes.
//
// * mapUnicodeToBytes
// Contains either the 2 byte value of double byte GB18030 or the 4 byte offset for 4 byte GB18030,
// depending on the value of the flag in mapUnicodeTo4BytesFlags
//
// * mapBytesToUnicode
// mapBytesToUnicode maps 2 byte GB 18030 to Unicode like other DBCS code pages.
//
// * map4BytesToUnicode
// map4BytesToUnicode is indexed by the 4 byte offset and contains the unicode value for each 4 byte offset
//
//
// 4 Byte sequences
// We generally use the offset for the 4 byte sequence, such as:
//
// The index value is the offset of the 4-byte GB18030.
//
// 4-byte GB18030 Index value
// ============== ===========
// 81,30,81,30 0
// 81,30,81,31 1
// 81,30,81,32 2
// ... ...
//
// The value of map4BytesToUnicode contains the Unicode codepoint for the offset of the
// corresponding 4-byte GB18030.
//
// E.g. map4BytesToUnicode[0] = 0x0080. This means that GB18030 0x81, 0x30, 0x81, 0x30 will be converted to Unicode U+0800.
//
// 4 Byte Surrogate Sequences
// Those work similarly to the normal 4 byte sequences, but start at a different offset
//
// We don't override IsAlwaysNormalized because GB18030 covers all of the unicode space, so isn't guaranteed to be normal.
//
using System;
using System.Diagnostics;
using System.Globalization;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Text;
namespace System.Text
{
/*=================================GB18030Encoding============================
**
** This is used to support GB18030-2000 encoding (code page 54936).
**
==============================================================================*/
internal sealed class GB18030Encoding : DBCSCodePageEncoding
{
// This is the table of 4 byte conversions.
private const int GBLast4ByteCode = 0x99FB;
internal unsafe char* map4BytesToUnicode = null; // new char[GBLast4ByteCode + 1]; // Need to map all 4 byte sequences to Unicode
internal unsafe byte* mapUnicodeTo4BytesFlags = null; // new byte[0x10000 / 8]; // Need 1 bit for each code point to say if its 4 byte or not
private const int GB18030 = 54936;
// First and last character of surrogate range as offset from 4 byte GB18030 GB81308130
private const int GBSurrogateOffset = 0x2E248; // GB90308130
private const int GBLastSurrogateOffset = 0x12E247; // GBE3329A35
// We have to load the 936 code page tables, so impersonate 936 as our base
internal GB18030Encoding()
// For GB18030Encoding just use default replacement fallbacks because its only for bad surrogates
: base(GB18030, 936, EncoderFallback.ReplacementFallback, DecoderFallback.ReplacementFallback)
{
}
// This loads our base 936 code page and then applies the changes from the tableUnicodeToGBDiffs table.
// See table comments for table format.
protected override unsafe void LoadManagedCodePage()
{
// Use base code page loading algorithm.
iExtraBytes = (GBLast4ByteCode + 1) * 2 + 0x10000 / 8;
// Load most of our code page
base.LoadManagedCodePage();
// Point to our new data sections
byte* pNativeMemory = (byte*)safeNativeMemoryHandle!.DangerousGetHandle();
mapUnicodeTo4BytesFlags = pNativeMemory + 65536 * 2 * 2;
map4BytesToUnicode = (char*)(pNativeMemory + 65536 * 2 * 2 + 0x10000 / 8);
// Once we've done our base LoadManagedCodePage, we'll have to add our fixes
char unicodeCount = (char)0;
ushort count4Byte = 0;
for (int index = 0; index < _tableUnicodeToGBDiffs.Length; index++)
{
ushort data = _tableUnicodeToGBDiffs[index];
// Check high bit
if ((data & 0x8000) != 0)
{
// Make be exact value
if (data > 0x9000 && data != 0xD1A6)
{
// It was an exact value (gb18040[data] = unicode)
mapBytesToUnicode[data] = unicodeCount;
mapUnicodeToBytes[unicodeCount] = data;
unicodeCount++;
}
else
{
// It was a CP 936 compatible data, that table's already loaded, just increment our pointer
unicodeCount += unchecked((char)(data & 0x7FFF));
}
}
else
{
// It was GB 18030 4 byte data, next <data> characters are 4 byte sequences.
while (data > 0)
{
Debug.Assert(count4Byte <= GBLast4ByteCode,
"[GB18030Encoding.LoadManagedCodePage] Found too many 4 byte codes in data table.");
// Set the 4 byte -> Unicode value
map4BytesToUnicode[count4Byte] = unicodeCount;
// Set the unicode -> 4 bytes value, including flag that its a 4 byte sequence
mapUnicodeToBytes[unicodeCount] = count4Byte;
// Set the flag saying its a 4 byte sequence
mapUnicodeTo4BytesFlags[unicodeCount / 8] |= unchecked((byte)(1 << (unicodeCount % 8)));
unchecked
{
unicodeCount++;
}
count4Byte++;
data--;
}
}
}
// unicodeCount should've wrapped back to 0
Debug.Assert(unicodeCount == 0,
"[GB18030Encoding.LoadManagedCodePage] Expected unicodeCount to wrap around to 0 as all chars were processed");
// We should've read in GBLast4ByteCode 4 byte sequences
Debug.Assert(count4Byte == GBLast4ByteCode + 1,
$"[GB18030Encoding.LoadManagedCodePage] Expected 0x99FB to be last 4 byte offset, found 0x{count4Byte:X4}");
}
// Is4Byte
// Checks the 4 byte table and returns true if this is a 4 byte code.
// Its a 4 byte code if the flag is set in mapUnicodeTo4BytesFlags
internal unsafe bool Is4Byte(char charTest)
{
// See what kind it is
byte b4Byte = mapUnicodeTo4BytesFlags[charTest / 8];
return (b4Byte != 0 && (b4Byte & (1 << (charTest % 8))) != 0);
}
// GetByteCount
public override unsafe int GetByteCount(char* chars, int count, EncoderNLS? encoder)
{
// Just call GetBytes() with null bytes
return GetBytes(chars, count, null, 0, encoder);
}
public override unsafe int GetBytes(char* chars, int charCount,
byte* bytes, int byteCount, EncoderNLS? encoder)
{
// Just need to ASSERT, this is called by something else internal that checked parameters already
// We'll allow null bytes as a count
// Debug.Assert(bytes != null, "[GB18030Encoding.GetBytes]bytes is null");
Debug.Assert(byteCount >= 0, "[GB18030Encoding.GetBytes]byteCount is negative");
Debug.Assert(chars != null, "[GB18030Encoding.GetBytes]chars is null");
Debug.Assert(charCount >= 0, "[GB18030Encoding.GetBytes]charCount is negative");
// Assert because we shouldn't be able to have a null encoder.
Debug.Assert(EncoderFallback != null, "[GB18030Encoding.GetBytes]Attempting to use null encoder fallback");
// Get any left over characters
char charLeftOver = (char)0;
if (encoder != null)
charLeftOver = encoder.charLeftOver;
// prepare our helpers
EncodingByteBuffer buffer = new EncodingByteBuffer(this, encoder, bytes, byteCount, chars, charCount);
// Try again if we were MustFlush
TryAgain:
// Go ahead and do it, including the fallback.
while (buffer.MoreData)
{
// Get next char
char ch = buffer.GetNextChar();
// Have to check for charLeftOver
if (charLeftOver != 0)
{
Debug.Assert(char.IsHighSurrogate(charLeftOver),
$"[GB18030Encoding.GetBytes] leftover character should be high surrogate, not 0x{(int)charLeftOver:X4}");
// If our next char isn't a low surrogate, then we need to do fallback.
if (!char.IsLowSurrogate(ch))
{
// No low surrogate, fallback high surrogate & try this one again
buffer.MovePrevious(false); // (Ignoring this character, don't throw)
if (!buffer.Fallback(charLeftOver))
{
charLeftOver = (char)0;
break;
}
charLeftOver = (char)0;
continue;
}
else
{
// Next is a surrogate, add it as surrogate pair
// Need 4 bytes for surrogates
// Get our offset
int offset = ((charLeftOver - 0xd800) << 10) + (ch - 0xdc00);
byte byte4 = (byte)((offset % 0x0a) + 0x30);
offset /= 0x0a;
byte byte3 = (byte)((offset % 0x7e) + 0x81);
offset /= 0x7e;
byte byte2 = (byte)((offset % 0x0a) + 0x30);
offset /= 0x0a;
Debug.Assert(offset < 0x6f,
$"[GB18030Encoding.GetBytes](1) Expected offset < 0x6f, not 0x{offset:X2}");
charLeftOver = (char)0;
if (!buffer.AddByte((byte)(offset + 0x90), byte2, byte3, byte4))
{
// Didn't work, need to back up for both surrogates (AddByte already backed up one)
buffer.MovePrevious(false); // (don't throw)
break;
}
}
charLeftOver = '\0';
}
// ASCII's easiest
else if (ch <= 0x7f)
{
// Need a byte
if (!buffer.AddByte((byte)ch))
break;
}
// See if its a surrogate pair
else if (char.IsHighSurrogate(ch))
{
// Remember it for next time
charLeftOver = ch;
}
else if (char.IsLowSurrogate(ch))
{
// Low surrogates should've been found already
if (!buffer.Fallback(ch))
break;
}
else
{
// Not surrogate or ASCII, get value
ushort iBytes = mapUnicodeToBytes[ch];
// See what kind it is
if (Is4Byte(ch))
{
//
// This Unicode character will be converted to four-byte GB18030.
//
// Need 4 bytes
byte byte4 = (byte)((iBytes % 0x0a) + 0x30);
iBytes /= 0x0a;
byte byte3 = (byte)((iBytes % 0x7e) + 0x81);
iBytes /= 0x7e;
byte byte2 = (byte)((iBytes % 0x0a) + 0x30);
iBytes /= 0x0a;
Debug.Assert(iBytes < 0x7e,
$"[GB18030Encoding.GetBytes]Expected iBytes < 0x7e, not 0x{iBytes:X2}");
if (!buffer.AddByte((byte)(iBytes + 0x81), byte2, byte3, byte4))
break;
}
else
{
// Its 2 byte, use it
if (!buffer.AddByte(unchecked((byte)(iBytes >> 8)), unchecked((byte)(iBytes & 0xff))))
break;
}
}
}
// Do we need to flush our charLeftOver?
if ((encoder == null || encoder.MustFlush) && (charLeftOver > 0))
{
// Fall it back
buffer.Fallback(charLeftOver);
charLeftOver = (char)0;
goto TryAgain;
}
// Fallback stuck it in encoder if necessary, but we have to clear MustFlash cases
// (Check bytes != null, don't clear it if we're just counting)
if (encoder != null)
{
// Remember our charLeftOver
if (bytes != null)
encoder.charLeftOver = charLeftOver;
encoder.m_charsUsed = buffer.CharsUsed;
}
// Return our length
return buffer.Count;
}
// Helper methods
internal static bool IsGBLeadByte(short ch)
{
// return true if we're in the lead byte range
return ((ch) >= 0x81 && (ch) <= 0xfe);
}
internal static bool IsGBTwoByteTrailing(short ch)
{
// Return true if we are in range for the trailing byte of a 2 byte sequence
return (((ch) >= 0x40 && (ch) <= 0x7e) ||
((ch) >= 0x80 && (ch) <= 0xfe));
}
internal static bool IsGBFourByteTrailing(short ch)
{
// Return true if we are in range for the trailing byte of a 4 byte sequence
return ((ch) >= 0x30 && (ch) <= 0x39);
}
internal static int GetFourBytesOffset(short offset1, short offset2, short offset3, short offset4)
{
return ((offset1 - 0x81) * 0x0a * 0x7e * 0x0a +
(offset2 - 0x30) * 0x7e * 0x0a +
(offset3 - 0x81) * 0x0a +
offset4 - 0x30);
}
// This is internal and called by something else,
public override unsafe int GetCharCount(byte* bytes, int count, DecoderNLS? baseDecoder)
{
// Just call GetChars() with null chars to count
return GetChars(bytes, count, null, 0, baseDecoder);
}
public override unsafe int GetChars(byte* bytes, int byteCount,
char* chars, int charCount, DecoderNLS? baseDecoder)
{
// Just need to ASSERT, this is called by something else internal that checked parameters already
// We'll allow null chars as a count
Debug.Assert(bytes != null, "[GB18030Encoding.GetChars]bytes is null");
Debug.Assert(byteCount >= 0, "[GB18030Encoding.GetChars]byteCount is negative");
// Debug.Assert(chars != null, "[GB18030Encoding.GetChars]chars is null");
Debug.Assert(charCount >= 0, "[GB18030Encoding.GetChars]charCount is negative");
// Fix our decoder
GB18030Decoder? decoder = (GB18030Decoder?)baseDecoder;
// Get our info.
EncodingCharBuffer buffer = new EncodingCharBuffer(this, decoder, chars, charCount, bytes, byteCount);
// Need temp bytes because we can't muss up decoder
short byte1 = -1;
short byte2 = -1;
short byte3 = -1;
short byte4 = -1;
// See if there was anything to get out of the decoder
if (decoder != null && decoder.bLeftOver1 != -1)
{
// Need temp bytes because we can't muss up decoder
byte1 = decoder.bLeftOver1;
byte2 = decoder.bLeftOver2;
byte3 = decoder.bLeftOver3;
byte4 = decoder.bLeftOver4;
// Loop because we might have too many in buffer
// This could happen if we are working on a 4 byte sequence, but it isn't valid.
while (byte1 != -1)
{
// If its not a lead byte, use ? or its value, then scoot them down & try again
// This could happen if we previously had a bad 4 byte sequence and this is a trail byte
if (!IsGBLeadByte(byte1))
{
// This is either a ? or ASCII, need 1 char output
if (byte1 <= 0x7f)
{
if (!buffer.AddChar((char)byte1)) // Its ASCII
break;
}
else
{
if (!buffer.Fallback((byte)byte1)) // Not a valid byte
break;
}
byte1 = byte2;
byte2 = byte3;
byte3 = byte4;
byte4 = -1;
continue;
}
// Read in more bytes as needed
while (byte2 == -1 ||
(IsGBFourByteTrailing(byte2) && byte4 == -1))
{
// Do we have room?
if (!buffer.MoreData)
{
// No input left to read, do we have to flush?
if (!decoder.MustFlush)
{
// Don't stick stuff in decoder when counting
if (chars != null)
{
// Don't have to flush, won't have any chars
// Decoder is correct, just return
decoder.bLeftOver1 = byte1;
decoder.bLeftOver2 = byte2;
decoder.bLeftOver3 = byte3;
decoder.bLeftOver4 = byte4;
}
decoder.m_bytesUsed = buffer.BytesUsed;
return buffer.Count;
}
// We'll have to flush, add a ? and scoot them down to try again
// We could be trying for a 4 byte sequence but byte 3 could be ascii and should be spit out
// Breaking will do this because we have zeros
break;
}
// Read them in
if (byte2 == -1) byte2 = buffer.GetNextByte();
else if (byte3 == -1) byte3 = buffer.GetNextByte();
else byte4 = buffer.GetNextByte();
}
// Now we have our 2 or 4 bytes
if (IsGBTwoByteTrailing(byte2))
{
//
// The trailing byte is a GB18030 two-byte sequence trailing byte.
//
int iTwoBytes = byte1 << 8;
iTwoBytes |= unchecked((byte)byte2);
if (!buffer.AddChar(mapBytesToUnicode[iTwoBytes], 2))
break;
// We're done with it
byte1 = -1;
byte2 = -1;
}
else if (IsGBFourByteTrailing(byte2) &&
IsGBLeadByte(byte3) &&
IsGBFourByteTrailing(byte4))
{
//
// Four-byte GB18030
//
int sFourBytesOffset = GetFourBytesOffset(
byte1, byte2, byte3, byte4);
// What kind is it?
if (sFourBytesOffset <= GBLast4ByteCode)
{
//
// The Unicode will be in the BMP range.
//
if (!buffer.AddChar(map4BytesToUnicode[sFourBytesOffset], 4))
break;
}
else if (sFourBytesOffset >= GBSurrogateOffset &&
sFourBytesOffset <= GBLastSurrogateOffset)
{
//
// This will be converted to a surrogate pair, need another char
//
// Use our surrogate
sFourBytesOffset -= GBSurrogateOffset;
if (!buffer.AddChar(unchecked((char)(0xd800 + (sFourBytesOffset / 0x400))),
unchecked((char)(0xdc00 + (sFourBytesOffset % 0x400))), 4))
break;
}
else
{
// Real GB18030 codepoint, but can't be mapped to unicode
// We already checked our buffer space.
// Do fallback here if we implement decoderfallbacks.
if (!buffer.Fallback((byte)byte1, (byte)byte2, (byte)byte3, (byte)byte4))
break;
}
// We're done with this one
byte1 = -1;
byte2 = -1;
byte3 = -1;
byte4 = -1;
}
else
{
// Not a valid sequence, use '?' for 1st byte & scoot them all down 1
if (!buffer.Fallback((byte)byte1))
break;
// Move all bytes down 1
byte1 = byte2;
byte2 = byte3;
byte3 = byte4;
byte4 = -1;
}
}
}
// Loop, just do '?' replacement because we don't have fallbacks for decodings.
while (buffer.MoreData)
{
byte ch = buffer.GetNextByte();
// ASCII case is easy
if (ch <= 0x7f)
{
// ASCII, have room?
if (!buffer.AddChar((char)ch))
break; // No room in convert buffer, so stop
}
// See if its a lead byte
else if (IsGBLeadByte(ch))
{
// ch is a lead byte, have room for more?
if (buffer.MoreData)
{
byte ch2 = buffer.GetNextByte();
if (IsGBTwoByteTrailing(ch2))
{
//
// The trailing byte is a GB18030 two-byte sequence trailing byte.
//
//
// Two-byte GB18030
//
int iTwoBytes = ch << 8;
iTwoBytes |= ch2;
if (!buffer.AddChar(mapBytesToUnicode[iTwoBytes], 2))
break;
}
else if (IsGBFourByteTrailing(ch2))
{
// Do we have room for Four Byte Sequence? (already have 1 byte)
if (buffer.EvenMoreData(2))
{
// Is it a valid 4 byte sequence?
byte ch3 = buffer.GetNextByte();
byte ch4 = buffer.GetNextByte();
if (IsGBLeadByte(ch3) &&
IsGBFourByteTrailing(ch4))
{
//
// Four-byte GB18030
//
int sFourBytesOffset = GetFourBytesOffset(ch, ch2, ch3, ch4);
// What kind is it?
// We'll be at least 1 BMP char or a '?' char.
if (sFourBytesOffset <= GBLast4ByteCode)
{
//
// The Unicode will be in the BMP range.
//
if (!buffer.AddChar(map4BytesToUnicode[sFourBytesOffset], 4))
break;
}
else if (sFourBytesOffset >= GBSurrogateOffset &&
sFourBytesOffset <= GBLastSurrogateOffset)
{
//
// This will be converted to a surrogate pair, need another char
//
// Use our surrogate
sFourBytesOffset -= GBSurrogateOffset;
if (!buffer.AddChar(unchecked((char)(0xd800 + (sFourBytesOffset / 0x400))),
unchecked((char)(0xdc00 + (sFourBytesOffset % 0x400))), 4))
break;
}
else
{
// Real GB18030 codepoint, but can't be mapped to unicode
if (!buffer.Fallback(ch, ch2, ch3, ch4))
break;
}
}
else
{
// Not a valid 2 or 4 byte sequence, use '?' for ch and try other 3 again
buffer.AdjustBytes(-3);
if (!buffer.Fallback(ch))
break;
}
}
else
{
// No room for 4 bytes, have 2 already, may be one more
// Lead byte but no place to stick it
if (decoder != null && !decoder.MustFlush)
{
// (make sure not to set decoder if counting, so check chars)
if (chars != null)
{
// We'll be able to stick the remainder in the decoder
byte1 = ch;
byte2 = ch2;
if (buffer.MoreData)
byte3 = buffer.GetNextByte();
else
byte3 = -1;
byte4 = -1;
}
break;
}
// Won't go in decoder, we'll use '?' for it.
if (!buffer.Fallback(ch, ch2))
break;
}
}
else
{
// Unknown byte sequence, fall back lead byte and try 2nd one again
buffer.AdjustBytes(-1);
if (!buffer.Fallback(ch))
break;
}
}
else
{
// Lead byte but don't know about trail byte
// (make sure not to set decoder if counting, so check bytes)
if (decoder != null && !decoder.MustFlush)
{
// We'll be able to stick it in the decoder
// (don't actually do it when counting though)
if (chars != null)
{
byte1 = ch;
byte2 = -1;
byte3 = -1;
byte4 = -1;
}
break;
}
if (!buffer.Fallback(ch))
break;
}
}
else
{
// Not ASCII and not a lead byte, we'll use '?' for it if we have room
if (!buffer.Fallback(ch))
break;
}
}
// Need to flush the decoder if necessary
// (make sure not to set decoder if counting, so check bytes)
if (decoder != null)
{
if (chars != null)
{
decoder.bLeftOver1 = byte1;
decoder.bLeftOver2 = byte2;
decoder.bLeftOver3 = byte3;
decoder.bLeftOver4 = byte4;
}
decoder.m_bytesUsed = buffer.BytesUsed;
}
// Return the # of characters we found
return buffer.Count;
}
public override int GetMaxByteCount(int charCount)
{
if (charCount < 0)
throw new ArgumentOutOfRangeException(nameof(charCount), SR.ArgumentOutOfRange_NeedNonNegNum);
// Characters would be # of characters + 1 in case high surrogate is ? * max fallback
long byteCount = (long)charCount + 1;
if (EncoderFallback.MaxCharCount > 1)
byteCount *= EncoderFallback.MaxCharCount;
// We could have 4 bytes for each char, no extra for surrogates because 18030 can do whole unicode range.
byteCount *= 4;
if (byteCount > 0x7fffffff)
throw new ArgumentOutOfRangeException(nameof(charCount), SR.ArgumentOutOfRange_GetByteCountOverflow);
return (int)byteCount;
}
public override int GetMaxCharCount(int byteCount)
{
if (byteCount < 0)
throw new ArgumentOutOfRangeException(nameof(byteCount), SR.ArgumentOutOfRange_NeedNonNegNum);
// Just return length, we could have a single char for each byte + whatever extra our decoder could do to us.
// If decoder is messed up it could spit out 3 ?s.
long charCount = ((long)byteCount) + 3;
// Take fallback size into consideration
if (DecoderFallback.MaxCharCount > 1)
charCount *= DecoderFallback.MaxCharCount;
if (charCount > 0x7fffffff)
throw new ArgumentOutOfRangeException(nameof(byteCount), SR.ArgumentOutOfRange_GetCharCountOverflow);
return (int)charCount;
}
public override Decoder GetDecoder()
{
return new GB18030Decoder(this);
}
internal sealed class GB18030Decoder : DecoderNLS
{
internal short bLeftOver1 = -1;
internal short bLeftOver2 = -1;
internal short bLeftOver3 = -1;
internal short bLeftOver4 = -1;
internal GB18030Decoder(EncodingNLS encoding) : base(encoding)
{
// DecoderNLS Calls reset
}
public override void Reset()
{
bLeftOver1 = -1;
bLeftOver2 = -1;
bLeftOver3 = -1;
bLeftOver4 = -1;
m_fallbackBuffer?.Reset();
}
// Anything left in our decoder?
internal override bool HasState
{
get
{
return (bLeftOver1 >= 0);
}
}
}
// tableUnicodeToGBDiffs
//
// This compressed data enumerates the differences between gb18030 and the 936 code page as follows:
//
// <count> & 0x8000 == 0x8000 The next count <count> characters are identical to 936 characters.
// <count> & 0x8000 == 0x0000 The next count <count> characters are 4 byte gb18030 characters.
// Except for:
// <count> >= 0x9000 && <count> != 0xD1A6 This character is this 2 byte GB18030 value.
//
private readonly ushort[] _tableUnicodeToGBDiffs =
{
0x8080, // U+0000 - U+007F ( 128 chars) use CP 936 conversion.
0x0024, // U+0080 - U+00A3 ( 36 chars) are GB18030 81 30 81 30 - 81 30 84 35 (offset 0000 - 0023)
0x8001, // U+00A4 - U+00A4 ( 1 chars) use CP 936 conversion.
0x0002, // U+00A5 - U+00A6 ( 2 chars) are GB18030 81 30 84 36 - 81 30 84 37 (offset 0024 - 0025)
0x8002, // U+00A7 - U+00A8 ( 2 chars) use CP 936 conversion.
0x0007, // U+00A9 - U+00AF ( 7 chars) are GB18030 81 30 84 38 - 81 30 85 34 (offset 0026 - 002C)
0x8002, // U+00B0 - U+00B1 ( 2 chars) use CP 936 conversion.
0x0005, // U+00B2 - U+00B6 ( 5 chars) are GB18030 81 30 85 35 - 81 30 85 39 (offset 002D - 0031)
0x8001, // U+00B7 - U+00B7 ( 1 chars) use CP 936 conversion.
0x001F, // U+00B8 - U+00D6 ( 31 chars) are GB18030 81 30 86 30 - 81 30 89 30 (offset 0032 - 0050)
0x8001, // U+00D7 - U+00D7 ( 1 chars) use CP 936 conversion.
0x0008, // U+00D8 - U+00DF ( 8 chars) are GB18030 81 30 89 31 - 81 30 89 38 (offset 0051 - 0058)
0x8002, // U+00E0 - U+00E1 ( 2 chars) use CP 936 conversion.
0x0006, // U+00E2 - U+00E7 ( 6 chars) are GB18030 81 30 89 39 - 81 30 8A 34 (offset 0059 - 005E)
0x8003, // U+00E8 - U+00EA ( 3 chars) use CP 936 conversion.
0x0001, // U+00EB - U+00EB ( 1 chars) are GB18030 81 30 8A 35 - 81 30 8A 35 (offset 005F - 005F)
0x8002, // U+00EC - U+00ED ( 2 chars) use CP 936 conversion.
0x0004, // U+00EE - U+00F1 ( 4 chars) are GB18030 81 30 8A 36 - 81 30 8A 39 (offset 0060 - 0063)
0x8002, // U+00F2 - U+00F3 ( 2 chars) use CP 936 conversion.
0x0003, // U+00F4 - U+00F6 ( 3 chars) are GB18030 81 30 8B 30 - 81 30 8B 32 (offset 0064 - 0066)
0x8001, // U+00F7 - U+00F7 ( 1 chars) use CP 936 conversion.
0x0001, // U+00F8 - U+00F8 ( 1 chars) are GB18030 81 30 8B 33 - 81 30 8B 33 (offset 0067 - 0067)
0x8002, // U+00F9 - U+00FA ( 2 chars) use CP 936 conversion.
0x0001, // U+00FB - U+00FB ( 1 chars) are GB18030 81 30 8B 34 - 81 30 8B 34 (offset 0068 - 0068)
0x8001, // U+00FC - U+00FC ( 1 chars) use CP 936 conversion.
0x0004, // U+00FD - U+0100 ( 4 chars) are GB18030 81 30 8B 35 - 81 30 8B 38 (offset 0069 - 006C)
0x8001, // U+0101 - U+0101 ( 1 chars) use CP 936 conversion.
0x0011, // U+0102 - U+0112 ( 17 chars) are GB18030 81 30 8B 39 - 81 30 8D 35 (offset 006D - 007D)
0x8001, // U+0113 - U+0113 ( 1 chars) use CP 936 conversion.
0x0007, // U+0114 - U+011A ( 7 chars) are GB18030 81 30 8D 36 - 81 30 8E 32 (offset 007E - 0084)
0x8001, // U+011B - U+011B ( 1 chars) use CP 936 conversion.
0x000F, // U+011C - U+012A ( 15 chars) are GB18030 81 30 8E 33 - 81 30 8F 37 (offset 0085 - 0093)
0x8001, // U+012B - U+012B ( 1 chars) use CP 936 conversion.
0x0018, // U+012C - U+0143 ( 24 chars) are GB18030 81 30 8F 38 - 81 30 92 31 (offset 0094 - 00AB)
0x8001, // U+0144 - U+0144 ( 1 chars) use CP 936 conversion.
0x0003, // U+0145 - U+0147 ( 3 chars) are GB18030 81 30 92 32 - 81 30 92 34 (offset 00AC - 00AE)
0x8001, // U+0148 - U+0148 ( 1 chars) use CP 936 conversion.
0x0004, // U+0149 - U+014C ( 4 chars) are GB18030 81 30 92 35 - 81 30 92 38 (offset 00AF - 00B2)
0x8001, // U+014D - U+014D ( 1 chars) use CP 936 conversion.
0x001D, // U+014E - U+016A ( 29 chars) are GB18030 81 30 92 39 - 81 30 95 37 (offset 00B3 - 00CF)
0x8001, // U+016B - U+016B ( 1 chars) use CP 936 conversion.
0x0062, // U+016C - U+01CD ( 98 chars) are GB18030 81 30 95 38 - 81 30 9F 35 (offset 00D0 - 0131)
0x8001, // U+01CE - U+01CE ( 1 chars) use CP 936 conversion.
0x0001, // U+01CF - U+01CF ( 1 chars) are GB18030 81 30 9F 36 - 81 30 9F 36 (offset 0132 - 0132)
0x8001, // U+01D0 - U+01D0 ( 1 chars) use CP 936 conversion.
0x0001, // U+01D1 - U+01D1 ( 1 chars) are GB18030 81 30 9F 37 - 81 30 9F 37 (offset 0133 - 0133)
0x8001, // U+01D2 - U+01D2 ( 1 chars) use CP 936 conversion.
0x0001, // U+01D3 - U+01D3 ( 1 chars) are GB18030 81 30 9F 38 - 81 30 9F 38 (offset 0134 - 0134)
0x8001, // U+01D4 - U+01D4 ( 1 chars) use CP 936 conversion.
0x0001, // U+01D5 - U+01D5 ( 1 chars) are GB18030 81 30 9F 39 - 81 30 9F 39 (offset 0135 - 0135)
0x8001, // U+01D6 - U+01D6 ( 1 chars) use CP 936 conversion.
0x0001, // U+01D7 - U+01D7 ( 1 chars) are GB18030 81 30 A0 30 - 81 30 A0 30 (offset 0136 - 0136)
0x8001, // U+01D8 - U+01D8 ( 1 chars) use CP 936 conversion.
0x0001, // U+01D9 - U+01D9 ( 1 chars) are GB18030 81 30 A0 31 - 81 30 A0 31 (offset 0137 - 0137)
0x8001, // U+01DA - U+01DA ( 1 chars) use CP 936 conversion.
0x0001, // U+01DB - U+01DB ( 1 chars) are GB18030 81 30 A0 32 - 81 30 A0 32 (offset 0138 - 0138)
0x8001, // U+01DC - U+01DC ( 1 chars) use CP 936 conversion.
0x001C, // U+01DD - U+01F8 ( 28 chars) are GB18030 81 30 A0 33 - 81 30 A3 30 (offset 0139 - 0154)
0xA8BF, // U+01F9 is non-936 GB18030 value A8 BF.
0x0057, // U+01FA - U+0250 ( 87 chars) are GB18030 81 30 A3 31 - 81 30 AB 37 (offset 0155 - 01AB)
0x8001, // U+0251 - U+0251 ( 1 chars) use CP 936 conversion.
0x000F, // U+0252 - U+0260 ( 15 chars) are GB18030 81 30 AB 38 - 81 30 AD 32 (offset 01AC - 01BA)
0x8001, // U+0261 - U+0261 ( 1 chars) use CP 936 conversion.
0x0065, // U+0262 - U+02C6 ( 101 chars) are GB18030 81 30 AD 33 - 81 30 B7 33 (offset 01BB - 021F)
0x8001, // U+02C7 - U+02C7 ( 1 chars) use CP 936 conversion.
0x0001, // U+02C8 - U+02C8 ( 1 chars) are GB18030 81 30 B7 34 - 81 30 B7 34 (offset 0220 - 0220)
0x8003, // U+02C9 - U+02CB ( 3 chars) use CP 936 conversion.
0x000D, // U+02CC - U+02D8 ( 13 chars) are GB18030 81 30 B7 35 - 81 30 B8 37 (offset 0221 - 022D)
0x8001, // U+02D9 - U+02D9 ( 1 chars) use CP 936 conversion.
0x00B7, // U+02DA - U+0390 ( 183 chars) are GB18030 81 30 B8 38 - 81 30 CB 30 (offset 022E - 02E4)
0x8011, // U+0391 - U+03A1 ( 17 chars) use CP 936 conversion.
0x0001, // U+03A2 - U+03A2 ( 1 chars) are GB18030 81 30 CB 31 - 81 30 CB 31 (offset 02E5 - 02E5)
0x8007, // U+03A3 - U+03A9 ( 7 chars) use CP 936 conversion.
0x0007, // U+03AA - U+03B0 ( 7 chars) are GB18030 81 30 CB 32 - 81 30 CB 38 (offset 02E6 - 02EC)
0x8011, // U+03B1 - U+03C1 ( 17 chars) use CP 936 conversion.
0x0001, // U+03C2 - U+03C2 ( 1 chars) are GB18030 81 30 CB 39 - 81 30 CB 39 (offset 02ED - 02ED)
0x8007, // U+03C3 - U+03C9 ( 7 chars) use CP 936 conversion.
0x0037, // U+03CA - U+0400 ( 55 chars) are GB18030 81 30 CC 30 - 81 30 D1 34 (offset 02EE - 0324)
0x8001, // U+0401 - U+0401 ( 1 chars) use CP 936 conversion.
0x000E, // U+0402 - U+040F ( 14 chars) are GB18030 81 30 D1 35 - 81 30 D2 38 (offset 0325 - 0332)
0x8040, // U+0410 - U+044F ( 64 chars) use CP 936 conversion.
0x0001, // U+0450 - U+0450 ( 1 chars) are GB18030 81 30 D2 39 - 81 30 D2 39 (offset 0333 - 0333)
0x8001, // U+0451 - U+0451 ( 1 chars) use CP 936 conversion.
0x1BBE, // U+0452 - U+200F ( 7102 chars) are GB18030 81 30 D3 30 - 81 36 A5 31 (offset 0334 - 1EF1)
0x8001, // U+2010 - U+2010 ( 1 chars) use CP 936 conversion.
0x0002, // U+2011 - U+2012 ( 2 chars) are GB18030 81 36 A5 32 - 81 36 A5 33 (offset 1EF2 - 1EF3)
0x8004, // U+2013 - U+2016 ( 4 chars) use CP 936 conversion.
0x0001, // U+2017 - U+2017 ( 1 chars) are GB18030 81 36 A5 34 - 81 36 A5 34 (offset 1EF4 - 1EF4)
0x8002, // U+2018 - U+2019 ( 2 chars) use CP 936 conversion.
0x0002, // U+201A - U+201B ( 2 chars) are GB18030 81 36 A5 35 - 81 36 A5 36 (offset 1EF5 - 1EF6)
0x8002, // U+201C - U+201D ( 2 chars) use CP 936 conversion.
0x0007, // U+201E - U+2024 ( 7 chars) are GB18030 81 36 A5 37 - 81 36 A6 33 (offset 1EF7 - 1EFD)
0x8002, // U+2025 - U+2026 ( 2 chars) use CP 936 conversion.
0x0009, // U+2027 - U+202F ( 9 chars) are GB18030 81 36 A6 34 - 81 36 A7 32 (offset 1EFE - 1F06)
0x8001, // U+2030 - U+2030 ( 1 chars) use CP 936 conversion.
0x0001, // U+2031 - U+2031 ( 1 chars) are GB18030 81 36 A7 33 - 81 36 A7 33 (offset 1F07 - 1F07)
0x8002, // U+2032 - U+2033 ( 2 chars) use CP 936 conversion.
0x0001, // U+2034 - U+2034 ( 1 chars) are GB18030 81 36 A7 34 - 81 36 A7 34 (offset 1F08 - 1F08)
0x8001, // U+2035 - U+2035 ( 1 chars) use CP 936 conversion.
0x0005, // U+2036 - U+203A ( 5 chars) are GB18030 81 36 A7 35 - 81 36 A7 39 (offset 1F09 - 1F0D)
0x8001, // U+203B - U+203B ( 1 chars) use CP 936 conversion.
0x0070, // U+203C - U+20AB ( 112 chars) are GB18030 81 36 A8 30 - 81 36 B3 31 (offset 1F0E - 1F7D)
0xA2E3, // U+20AC is non-936 GB18030 value A2 E3.
0x0056, // U+20AD - U+2102 ( 86 chars) are GB18030 81 36 B3 32 - 81 36 BB 37 (offset 1F7E - 1FD3)
0x8001, // U+2103 - U+2103 ( 1 chars) use CP 936 conversion.
0x0001, // U+2104 - U+2104 ( 1 chars) are GB18030 81 36 BB 38 - 81 36 BB 38 (offset 1FD4 - 1FD4)
0x8001, // U+2105 - U+2105 ( 1 chars) use CP 936 conversion.
0x0003, // U+2106 - U+2108 ( 3 chars) are GB18030 81 36 BB 39 - 81 36 BC 31 (offset 1FD5 - 1FD7)
0x8001, // U+2109 - U+2109 ( 1 chars) use CP 936 conversion.
0x000C, // U+210A - U+2115 ( 12 chars) are GB18030 81 36 BC 32 - 81 36 BD 33 (offset 1FD8 - 1FE3)
0x8001, // U+2116 - U+2116 ( 1 chars) use CP 936 conversion.
0x000A, // U+2117 - U+2120 ( 10 chars) are GB18030 81 36 BD 34 - 81 36 BE 33 (offset 1FE4 - 1FED)
0x8001, // U+2121 - U+2121 ( 1 chars) use CP 936 conversion.
0x003E, // U+2122 - U+215F ( 62 chars) are GB18030 81 36 BE 34 - 81 36 C4 35 (offset 1FEE - 202B)
0x800C, // U+2160 - U+216B ( 12 chars) use CP 936 conversion.
0x0004, // U+216C - U+216F ( 4 chars) are GB18030 81 36 C4 36 - 81 36 C4 39 (offset 202C - 202F)
0x800A, // U+2170 - U+2179 ( 10 chars) use CP 936 conversion.
0x0016, // U+217A - U+218F ( 22 chars) are GB18030 81 36 C5 30 - 81 36 C7 31 (offset 2030 - 2045)
0x8004, // U+2190 - U+2193 ( 4 chars) use CP 936 conversion.
0x0002, // U+2194 - U+2195 ( 2 chars) are GB18030 81 36 C7 32 - 81 36 C7 33 (offset 2046 - 2047)
0x8004, // U+2196 - U+2199 ( 4 chars) use CP 936 conversion.
0x006E, // U+219A - U+2207 ( 110 chars) are GB18030 81 36 C7 34 - 81 36 D2 33 (offset 2048 - 20B5)
0x8001, // U+2208 - U+2208 ( 1 chars) use CP 936 conversion.
0x0006, // U+2209 - U+220E ( 6 chars) are GB18030 81 36 D2 34 - 81 36 D2 39 (offset 20B6 - 20BB)
0x8001, // U+220F - U+220F ( 1 chars) use CP 936 conversion.
0x0001, // U+2210 - U+2210 ( 1 chars) are GB18030 81 36 D3 30 - 81 36 D3 30 (offset 20BC - 20BC)
0x8001, // U+2211 - U+2211 ( 1 chars) use CP 936 conversion.
0x0003, // U+2212 - U+2214 ( 3 chars) are GB18030 81 36 D3 31 - 81 36 D3 33 (offset 20BD - 20BF)
0x8001, // U+2215 - U+2215 ( 1 chars) use CP 936 conversion.
0x0004, // U+2216 - U+2219 ( 4 chars) are GB18030 81 36 D3 34 - 81 36 D3 37 (offset 20C0 - 20C3)
0x8001, // U+221A - U+221A ( 1 chars) use CP 936 conversion.
0x0002, // U+221B - U+221C ( 2 chars) are GB18030 81 36 D3 38 - 81 36 D3 39 (offset 20C4 - 20C5)
0x8004, // U+221D - U+2220 ( 4 chars) use CP 936 conversion.
0x0002, // U+2221 - U+2222 ( 2 chars) are GB18030 81 36 D4 30 - 81 36 D4 31 (offset 20C6 - 20C7)
0x8001, // U+2223 - U+2223 ( 1 chars) use CP 936 conversion.
0x0001, // U+2224 - U+2224 ( 1 chars) are GB18030 81 36 D4 32 - 81 36 D4 32 (offset 20C8 - 20C8)
0x8001, // U+2225 - U+2225 ( 1 chars) use CP 936 conversion.
0x0001, // U+2226 - U+2226 ( 1 chars) are GB18030 81 36 D4 33 - 81 36 D4 33 (offset 20C9 - 20C9)
0x8005, // U+2227 - U+222B ( 5 chars) use CP 936 conversion.
0x0002, // U+222C - U+222D ( 2 chars) are GB18030 81 36 D4 34 - 81 36 D4 35 (offset 20CA - 20CB)
0x8001, // U+222E - U+222E ( 1 chars) use CP 936 conversion.
0x0005, // U+222F - U+2233 ( 5 chars) are GB18030 81 36 D4 36 - 81 36 D5 30 (offset 20CC - 20D0)
0x8004, // U+2234 - U+2237 ( 4 chars) use CP 936 conversion.
0x0005, // U+2238 - U+223C ( 5 chars) are GB18030 81 36 D5 31 - 81 36 D5 35 (offset 20D1 - 20D5)
0x8001, // U+223D - U+223D ( 1 chars) use CP 936 conversion.
0x000A, // U+223E - U+2247 ( 10 chars) are GB18030 81 36 D5 36 - 81 36 D6 35 (offset 20D6 - 20DF)
0x8001, // U+2248 - U+2248 ( 1 chars) use CP 936 conversion.
0x0003, // U+2249 - U+224B ( 3 chars) are GB18030 81 36 D6 36 - 81 36 D6 38 (offset 20E0 - 20E2)
0x8001, // U+224C - U+224C ( 1 chars) use CP 936 conversion.
0x0005, // U+224D - U+2251 ( 5 chars) are GB18030 81 36 D6 39 - 81 36 D7 33 (offset 20E3 - 20E7)
0x8001, // U+2252 - U+2252 ( 1 chars) use CP 936 conversion.
0x000D, // U+2253 - U+225F ( 13 chars) are GB18030 81 36 D7 34 - 81 36 D8 36 (offset 20E8 - 20F4)
0x8002, // U+2260 - U+2261 ( 2 chars) use CP 936 conversion.
0x0002, // U+2262 - U+2263 ( 2 chars) are GB18030 81 36 D8 37 - 81 36 D8 38 (offset 20F5 - 20F6)
0x8004, // U+2264 - U+2267 ( 4 chars) use CP 936 conversion.
0x0006, // U+2268 - U+226D ( 6 chars) are GB18030 81 36 D8 39 - 81 36 D9 34 (offset 20F7 - 20FC)
0x8002, // U+226E - U+226F ( 2 chars) use CP 936 conversion.
0x0025, // U+2270 - U+2294 ( 37 chars) are GB18030 81 36 D9 35 - 81 36 DD 31 (offset 20FD - 2121)
0x8001, // U+2295 - U+2295 ( 1 chars) use CP 936 conversion.
0x0003, // U+2296 - U+2298 ( 3 chars) are GB18030 81 36 DD 32 - 81 36 DD 34 (offset 2122 - 2124)
0x8001, // U+2299 - U+2299 ( 1 chars) use CP 936 conversion.
0x000B, // U+229A - U+22A4 ( 11 chars) are GB18030 81 36 DD 35 - 81 36 DE 35 (offset 2125 - 212F)
0x8001, // U+22A5 - U+22A5 ( 1 chars) use CP 936 conversion.
0x0019, // U+22A6 - U+22BE ( 25 chars) are GB18030 81 36 DE 36 - 81 36 E1 30 (offset 2130 - 2148)
0x8001, // U+22BF - U+22BF ( 1 chars) use CP 936 conversion.
0x0052, // U+22C0 - U+2311 ( 82 chars) are GB18030 81 36 E1 31 - 81 36 E9 32 (offset 2149 - 219A)
0x8001, // U+2312 - U+2312 ( 1 chars) use CP 936 conversion.
0x014D, // U+2313 - U+245F ( 333 chars) are GB18030 81 36 E9 33 - 81 37 8C 35 (offset 219B - 22E7)
0x800A, // U+2460 - U+2469 ( 10 chars) use CP 936 conversion.
0x000A, // U+246A - U+2473 ( 10 chars) are GB18030 81 37 8C 36 - 81 37 8D 35 (offset 22E8 - 22F1)
0x8028, // U+2474 - U+249B ( 40 chars) use CP 936 conversion.
0x0064, // U+249C - U+24FF ( 100 chars) are GB18030 81 37 8D 36 - 81 37 97 35 (offset 22F2 - 2355)
0x804C, // U+2500 - U+254B ( 76 chars) use CP 936 conversion.
0x0004, // U+254C - U+254F ( 4 chars) are GB18030 81 37 97 36 - 81 37 97 39 (offset 2356 - 2359)
0x8024, // U+2550 - U+2573 ( 36 chars) use CP 936 conversion.
0x000D, // U+2574 - U+2580 ( 13 chars) are GB18030 81 37 98 30 - 81 37 99 32 (offset 235A - 2366)
0x800F, // U+2581 - U+258F ( 15 chars) use CP 936 conversion.
0x0003, // U+2590 - U+2592 ( 3 chars) are GB18030 81 37 99 33 - 81 37 99 35 (offset 2367 - 2369)
0x8003, // U+2593 - U+2595 ( 3 chars) use CP 936 conversion.
0x000A, // U+2596 - U+259F ( 10 chars) are GB18030 81 37 99 36 - 81 37 9A 35 (offset 236A - 2373)
0x8002, // U+25A0 - U+25A1 ( 2 chars) use CP 936 conversion.
0x0010, // U+25A2 - U+25B1 ( 16 chars) are GB18030 81 37 9A 36 - 81 37 9C 31 (offset 2374 - 2383)
0x8002, // U+25B2 - U+25B3 ( 2 chars) use CP 936 conversion.
0x0008, // U+25B4 - U+25BB ( 8 chars) are GB18030 81 37 9C 32 - 81 37 9C 39 (offset 2384 - 238B)
0x8002, // U+25BC - U+25BD ( 2 chars) use CP 936 conversion.
0x0008, // U+25BE - U+25C5 ( 8 chars) are GB18030 81 37 9D 30 - 81 37 9D 37 (offset 238C - 2393)
0x8002, // U+25C6 - U+25C7 ( 2 chars) use CP 936 conversion.
0x0003, // U+25C8 - U+25CA ( 3 chars) are GB18030 81 37 9D 38 - 81 37 9E 30 (offset 2394 - 2396)
0x8001, // U+25CB - U+25CB ( 1 chars) use CP 936 conversion.
0x0002, // U+25CC - U+25CD ( 2 chars) are GB18030 81 37 9E 31 - 81 37 9E 32 (offset 2397 - 2398)
0x8002, // U+25CE - U+25CF ( 2 chars) use CP 936 conversion.
0x0012, // U+25D0 - U+25E1 ( 18 chars) are GB18030 81 37 9E 33 - 81 37 A0 30 (offset 2399 - 23AA)
0x8004, // U+25E2 - U+25E5 ( 4 chars) use CP 936 conversion.
0x001F, // U+25E6 - U+2604 ( 31 chars) are GB18030 81 37 A0 31 - 81 37 A3 31 (offset 23AB - 23C9)
0x8002, // U+2605 - U+2606 ( 2 chars) use CP 936 conversion.
0x0002, // U+2607 - U+2608 ( 2 chars) are GB18030 81 37 A3 32 - 81 37 A3 33 (offset 23CA - 23CB)
0x8001, // U+2609 - U+2609 ( 1 chars) use CP 936 conversion.
0x0036, // U+260A - U+263F ( 54 chars) are GB18030 81 37 A3 34 - 81 37 A8 37 (offset 23CC - 2401)
0x8001, // U+2640 - U+2640 ( 1 chars) use CP 936 conversion.
0x0001, // U+2641 - U+2641 ( 1 chars) are GB18030 81 37 A8 38 - 81 37 A8 38 (offset 2402 - 2402)
0x8001, // U+2642 - U+2642 ( 1 chars) use CP 936 conversion.
0x083E, // U+2643 - U+2E80 ( 2110 chars) are GB18030 81 37 A8 39 - 81 38 FD 38 (offset 2403 - 2C40)
0xFE50, // U+2E81 is non-936 GB18030 value FE 50.
0x0002, // U+2E82 - U+2E83 ( 2 chars) are GB18030 81 38 FD 39 - 81 38 FE 30 (offset 2C41 - 2C42)
0xFE54, // U+2E84 is non-936 GB18030 value FE 54.
0x0003, // U+2E85 - U+2E87 ( 3 chars) are GB18030 81 38 FE 31 - 81 38 FE 33 (offset 2C43 - 2C45)
0xFE57, // U+2E88 is non-936 GB18030 value FE 57.
0x0002, // U+2E89 - U+2E8A ( 2 chars) are GB18030 81 38 FE 34 - 81 38 FE 35 (offset 2C46 - 2C47)
0xFE58, // U+2E8B is non-936 GB18030 value FE 58.
0xFE5D, // U+2E8C is non-936 GB18030 value FE 5D.
0x000A, // U+2E8D - U+2E96 ( 10 chars) are GB18030 81 38 FE 36 - 81 39 81 35 (offset 2C48 - 2C51)
0xFE5E, // U+2E97 is non-936 GB18030 value FE 5E.
0x000F, // U+2E98 - U+2EA6 ( 15 chars) are GB18030 81 39 81 36 - 81 39 83 30 (offset 2C52 - 2C60)
0xFE6B, // U+2EA7 is non-936 GB18030 value FE 6B.
0x0002, // U+2EA8 - U+2EA9 ( 2 chars) are GB18030 81 39 83 31 - 81 39 83 32 (offset 2C61 - 2C62)
0xFE6E, // U+2EAA is non-936 GB18030 value FE 6E.
0x0003, // U+2EAB - U+2EAD ( 3 chars) are GB18030 81 39 83 33 - 81 39 83 35 (offset 2C63 - 2C65)
0xFE71, // U+2EAE is non-936 GB18030 value FE 71.
0x0004, // U+2EAF - U+2EB2 ( 4 chars) are GB18030 81 39 83 36 - 81 39 83 39 (offset 2C66 - 2C69)
0xFE73, // U+2EB3 is non-936 GB18030 value FE 73.
0x0002, // U+2EB4 - U+2EB5 ( 2 chars) are GB18030 81 39 84 30 - 81 39 84 31 (offset 2C6A - 2C6B)
0xFE74, // U+2EB6 is non-936 GB18030 value FE 74.
0xFE75, // U+2EB7 is non-936 GB18030 value FE 75.
0x0003, // U+2EB8 - U+2EBA ( 3 chars) are GB18030 81 39 84 32 - 81 39 84 34 (offset 2C6C - 2C6E)
0xFE79, // U+2EBB is non-936 GB18030 value FE 79.
0x000E, // U+2EBC - U+2EC9 ( 14 chars) are GB18030 81 39 84 35 - 81 39 85 38 (offset 2C6F - 2C7C)
0xFE84, // U+2ECA is non-936 GB18030 value FE 84.
0x0125, // U+2ECB - U+2FEF ( 293 chars) are GB18030 81 39 85 39 - 81 39 A3 31 (offset 2C7D - 2DA1)
0xA98A, // U+2FF0 is non-936 GB18030 value A9 8A.
0xA98B, // U+2FF1 is non-936 GB18030 value A9 8B.
0xA98C, // U+2FF2 is non-936 GB18030 value A9 8C.
0xA98D, // U+2FF3 is non-936 GB18030 value A9 8D.
0xA98E, // U+2FF4 is non-936 GB18030 value A9 8E.
0xA98F, // U+2FF5 is non-936 GB18030 value A9 8F.
0xA990, // U+2FF6 is non-936 GB18030 value A9 90.
0xA991, // U+2FF7 is non-936 GB18030 value A9 91.
0xA992, // U+2FF8 is non-936 GB18030 value A9 92.
0xA993, // U+2FF9 is non-936 GB18030 value A9 93.
0xA994, // U+2FFA is non-936 GB18030 value A9 94.
0xA995, // U+2FFB is non-936 GB18030 value A9 95.
0x0004, // U+2FFC - U+2FFF ( 4 chars) are GB18030 81 39 A3 32 - 81 39 A3 35 (offset 2DA2 - 2DA5)
0x8004, // U+3000 - U+3003 ( 4 chars) use CP 936 conversion.
0x0001, // U+3004 - U+3004 ( 1 chars) are GB18030 81 39 A3 36 - 81 39 A3 36 (offset 2DA6 - 2DA6)
0x8013, // U+3005 - U+3017 ( 19 chars) use CP 936 conversion.
0x0005, // U+3018 - U+301C ( 5 chars) are GB18030 81 39 A3 37 - 81 39 A4 31 (offset 2DA7 - 2DAB)
0x8002, // U+301D - U+301E ( 2 chars) use CP 936 conversion.
0x0002, // U+301F - U+3020 ( 2 chars) are GB18030 81 39 A4 32 - 81 39 A4 33 (offset 2DAC - 2DAD)
0x8009, // U+3021 - U+3029 ( 9 chars) use CP 936 conversion.
0x0014, // U+302A - U+303D ( 20 chars) are GB18030 81 39 A4 34 - 81 39 A6 33 (offset 2DAE - 2DC1)
0xA989, // U+303E is non-936 GB18030 value A9 89.
0x0002, // U+303F - U+3040 ( 2 chars) are GB18030 81 39 A6 34 - 81 39 A6 35 (offset 2DC2 - 2DC3)
0x8053, // U+3041 - U+3093 ( 83 chars) use CP 936 conversion.
0x0007, // U+3094 - U+309A ( 7 chars) are GB18030 81 39 A6 36 - 81 39 A7 32 (offset 2DC4 - 2DCA)
0x8004, // U+309B - U+309E ( 4 chars) use CP 936 conversion.
0x0002, // U+309F - U+30A0 ( 2 chars) are GB18030 81 39 A7 33 - 81 39 A7 34 (offset 2DCB - 2DCC)
0x8056, // U+30A1 - U+30F6 ( 86 chars) use CP 936 conversion.
0x0005, // U+30F7 - U+30FB ( 5 chars) are GB18030 81 39 A7 35 - 81 39 A7 39 (offset 2DCD - 2DD1)
0x8003, // U+30FC - U+30FE ( 3 chars) use CP 936 conversion.
0x0006, // U+30FF - U+3104 ( 6 chars) are GB18030 81 39 A8 30 - 81 39 A8 35 (offset 2DD2 - 2DD7)
0x8025, // U+3105 - U+3129 ( 37 chars) use CP 936 conversion.
0x00F6, // U+312A - U+321F ( 246 chars) are GB18030 81 39 A8 36 - 81 39 C1 31 (offset 2DD8 - 2ECD)
0x800A, // U+3220 - U+3229 ( 10 chars) use CP 936 conversion.
0x0007, // U+322A - U+3230 ( 7 chars) are GB18030 81 39 C1 32 - 81 39 C1 38 (offset 2ECE - 2ED4)
0x8001, // U+3231 - U+3231 ( 1 chars) use CP 936 conversion.
0x0071, // U+3232 - U+32A2 ( 113 chars) are GB18030 81 39 C1 39 - 81 39 CD 31 (offset 2ED5 - 2F45)
0x8001, // U+32A3 - U+32A3 ( 1 chars) use CP 936 conversion.
0x00EA, // U+32A4 - U+338D ( 234 chars) are GB18030 81 39 CD 32 - 81 39 E4 35 (offset 2F46 - 302F)
0x8002, // U+338E - U+338F ( 2 chars) use CP 936 conversion.
0x000C, // U+3390 - U+339B ( 12 chars) are GB18030 81 39 E4 36 - 81 39 E5 37 (offset 3030 - 303B)
0x8003, // U+339C - U+339E ( 3 chars) use CP 936 conversion.
0x0002, // U+339F - U+33A0 ( 2 chars) are GB18030 81 39 E5 38 - 81 39 E5 39 (offset 303C - 303D)
0x8001, // U+33A1 - U+33A1 ( 1 chars) use CP 936 conversion.
0x0022, // U+33A2 - U+33C3 ( 34 chars) are GB18030 81 39 E6 30 - 81 39 E9 33 (offset 303E - 305F)
0x8001, // U+33C4 - U+33C4 ( 1 chars) use CP 936 conversion.
0x0009, // U+33C5 - U+33CD ( 9 chars) are GB18030 81 39 E9 34 - 81 39 EA 32 (offset 3060 - 3068)
0x8001, // U+33CE - U+33CE ( 1 chars) use CP 936 conversion.
0x0002, // U+33CF - U+33D0 ( 2 chars) are GB18030 81 39 EA 33 - 81 39 EA 34 (offset 3069 - 306A)
0x8002, // U+33D1 - U+33D2 ( 2 chars) use CP 936 conversion.
0x0002, // U+33D3 - U+33D4 ( 2 chars) are GB18030 81 39 EA 35 - 81 39 EA 36 (offset 306B - 306C)
0x8001, // U+33D5 - U+33D5 ( 1 chars) use CP 936 conversion.
0x0071, // U+33D6 - U+3446 ( 113 chars) are GB18030 81 39 EA 37 - 81 39 F5 39 (offset 306D - 30DD)
0xFE56, // U+3447 is non-936 GB18030 value FE 56.
0x002B, // U+3448 - U+3472 ( 43 chars) are GB18030 81 39 F6 30 - 81 39 FA 32 (offset 30DE - 3108)
0xFE55, // U+3473 is non-936 GB18030 value FE 55.
0x012A, // U+3474 - U+359D ( 298 chars) are GB18030 81 39 FA 33 - 82 30 9A 30 (offset 3109 - 3232)
0xFE5A, // U+359E is non-936 GB18030 value FE 5A.
0x006F, // U+359F - U+360D ( 111 chars) are GB18030 82 30 9A 31 - 82 30 A5 31 (offset 3233 - 32A1)
0xFE5C, // U+360E is non-936 GB18030 value FE 5C.
0x000B, // U+360F - U+3619 ( 11 chars) are GB18030 82 30 A5 32 - 82 30 A6 32 (offset 32A2 - 32AC)
0xFE5B, // U+361A is non-936 GB18030 value FE 5B.
0x02FD, // U+361B - U+3917 ( 765 chars) are GB18030 82 30 A6 33 - 82 30 F2 37 (offset 32AD - 35A9)
0xFE60, // U+3918 is non-936 GB18030 value FE 60.
0x0055, // U+3919 - U+396D ( 85 chars) are GB18030 82 30 F2 38 - 82 30 FB 32 (offset 35AA - 35FE)
0xFE5F, // U+396E is non-936 GB18030 value FE 5F.
0x0060, // U+396F - U+39CE ( 96 chars) are GB18030 82 30 FB 33 - 82 31 86 38 (offset 35FF - 365E)
0xFE62, // U+39CF is non-936 GB18030 value FE 62.
0xFE65, // U+39D0 is non-936 GB18030 value FE 65.
0x000E, // U+39D1 - U+39DE ( 14 chars) are GB18030 82 31 86 39 - 82 31 88 32 (offset 365F - 366C)
0xFE63, // U+39DF is non-936 GB18030 value FE 63.
0x0093, // U+39E0 - U+3A72 ( 147 chars) are GB18030 82 31 88 33 - 82 31 96 39 (offset 366D - 36FF)
0xFE64, // U+3A73 is non-936 GB18030 value FE 64.
0x00DA, // U+3A74 - U+3B4D ( 218 chars) are GB18030 82 31 97 30 - 82 31 AC 37 (offset 3700 - 37D9)
0xFE68, // U+3B4E is non-936 GB18030 value FE 68.
0x011F, // U+3B4F - U+3C6D ( 287 chars) are GB18030 82 31 AC 38 - 82 31 C9 34 (offset 37DA - 38F8)
0xFE69, // U+3C6E is non-936 GB18030 value FE 69.
0x0071, // U+3C6F - U+3CDF ( 113 chars) are GB18030 82 31 C9 35 - 82 31 D4 37 (offset 38F9 - 3969)
0xFE6A, // U+3CE0 is non-936 GB18030 value FE 6A.
0x0375, // U+3CE1 - U+4055 ( 885 chars) are GB18030 82 31 D4 38 - 82 32 AF 32 (offset 396A - 3CDE)
0xFE6F, // U+4056 is non-936 GB18030 value FE 6F.
0x0108, // U+4057 - U+415E ( 264 chars) are GB18030 82 32 AF 33 - 82 32 C9 36 (offset 3CDF - 3DE6)
0xFE70, // U+415F is non-936 GB18030 value FE 70.
0x01D7, // U+4160 - U+4336 ( 471 chars) are GB18030 82 32 C9 37 - 82 32 F8 37 (offset 3DE7 - 3FBD)
0xFE72, // U+4337 is non-936 GB18030 value FE 72.
0x0074, // U+4338 - U+43AB ( 116 chars) are GB18030 82 32 F8 38 - 82 33 86 33 (offset 3FBE - 4031)
0xFE78, // U+43AC is non-936 GB18030 value FE 78.
0x0004, // U+43AD - U+43B0 ( 4 chars) are GB18030 82 33 86 34 - 82 33 86 37 (offset 4032 - 4035)
0xFE77, // U+43B1 is non-936 GB18030 value FE 77.
0x002B, // U+43B2 - U+43DC ( 43 chars) are GB18030 82 33 86 38 - 82 33 8B 30 (offset 4036 - 4060)
0xFE7A, // U+43DD is non-936 GB18030 value FE 7A.
0x00F8, // U+43DE - U+44D5 ( 248 chars) are GB18030 82 33 8B 31 - 82 33 A3 38 (offset 4061 - 4158)
0xFE7B, // U+44D6 is non-936 GB18030 value FE 7B.
0x0175, // U+44D7 - U+464B ( 373 chars) are GB18030 82 33 A3 39 - 82 33 C9 31 (offset 4159 - 42CD)
0xFE7D, // U+464C is non-936 GB18030 value FE 7D.
0x0014, // U+464D - U+4660 ( 20 chars) are GB18030 82 33 C9 32 - 82 33 CB 31 (offset 42CE - 42E1)
0xFE7C, // U+4661 is non-936 GB18030 value FE 7C.
0x00C1, // U+4662 - U+4722 ( 193 chars) are GB18030 82 33 CB 32 - 82 33 DE 34 (offset 42E2 - 43A2)
0xFE80, // U+4723 is non-936 GB18030 value FE 80.
0x0005, // U+4724 - U+4728 ( 5 chars) are GB18030 82 33 DE 35 - 82 33 DE 39 (offset 43A3 - 43A7)
0xFE81, // U+4729 is non-936 GB18030 value FE 81.
0x0052, // U+472A - U+477B ( 82 chars) are GB18030 82 33 DF 30 - 82 33 E7 31 (offset 43A8 - 43F9)
0xFE82, // U+477C is non-936 GB18030 value FE 82.
0x0010, // U+477D - U+478C ( 16 chars) are GB18030 82 33 E7 32 - 82 33 E8 37 (offset 43FA - 4409)
0xFE83, // U+478D is non-936 GB18030 value FE 83.
0x01B9, // U+478E - U+4946 ( 441 chars) are GB18030 82 33 E8 38 - 82 34 96 38 (offset 440A - 45C2)
0xFE85, // U+4947 is non-936 GB18030 value FE 85.
0x0032, // U+4948 - U+4979 ( 50 chars) are GB18030 82 34 96 39 - 82 34 9B 38 (offset 45C3 - 45F4)
0xFE86, // U+497A is non-936 GB18030 value FE 86.
0x0002, // U+497B - U+497C ( 2 chars) are GB18030 82 34 9B 39 - 82 34 9C 30 (offset 45F5 - 45F6)
0xFE87, // U+497D is non-936 GB18030 value FE 87.
0x0004, // U+497E - U+4981 ( 4 chars) are GB18030 82 34 9C 31 - 82 34 9C 34 (offset 45F7 - 45FA)
0xFE88, // U+4982 is non-936 GB18030 value FE 88.
0xFE89, // U+4983 is non-936 GB18030 value FE 89.
0x0001, // U+4984 - U+4984 ( 1 chars) are GB18030 82 34 9C 35 - 82 34 9C 35 (offset 45FB - 45FB)
0xFE8A, // U+4985 is non-936 GB18030 value FE 8A.
0xFE8B, // U+4986 is non-936 GB18030 value FE 8B.
0x0014, // U+4987 - U+499A ( 20 chars) are GB18030 82 34 9C 36 - 82 34 9E 35 (offset 45FC - 460F)
0xFE8D, // U+499B is non-936 GB18030 value FE 8D.
0x0003, // U+499C - U+499E ( 3 chars) are GB18030 82 34 9E 36 - 82 34 9E 38 (offset 4610 - 4612)
0xFE8C, // U+499F is non-936 GB18030 value FE 8C.
0x0016, // U+49A0 - U+49B5 ( 22 chars) are GB18030 82 34 9E 39 - 82 34 A1 30 (offset 4613 - 4628)
0xFE8F, // U+49B6 is non-936 GB18030 value FE 8F.
0xFE8E, // U+49B7 is non-936 GB18030 value FE 8E.
0x02BF, // U+49B8 - U+4C76 ( 703 chars) are GB18030 82 34 A1 31 - 82 34 E7 33 (offset 4629 - 48E7)
0xFE96, // U+4C77 is non-936 GB18030 value FE 96.
0x0027, // U+4C78 - U+4C9E ( 39 chars) are GB18030 82 34 E7 34 - 82 34 EB 32 (offset 48E8 - 490E)
0xFE93, // U+4C9F is non-936 GB18030 value FE 93.
0xFE94, // U+4CA0 is non-936 GB18030 value FE 94.
0xFE95, // U+4CA1 is non-936 GB18030 value FE 95.
0xFE97, // U+4CA2 is non-936 GB18030 value FE 97.
0xFE92, // U+4CA3 is non-936 GB18030 value FE 92.
0x006F, // U+4CA4 - U+4D12 ( 111 chars) are GB18030 82 34 EB 33 - 82 34 F6 33 (offset 490F - 497D)
0xFE98, // U+4D13 is non-936 GB18030 value FE 98.
0xFE99, // U+4D14 is non-936 GB18030 value FE 99.
0xFE9A, // U+4D15 is non-936 GB18030 value FE 9A.
0xFE9B, // U+4D16 is non-936 GB18030 value FE 9B.
0xFE9C, // U+4D17 is non-936 GB18030 value FE 9C.
0xFE9D, // U+4D18 is non-936 GB18030 value FE 9D.
0xFE9E, // U+4D19 is non-936 GB18030 value FE 9E.
0x0094, // U+4D1A - U+4DAD ( 148 chars) are GB18030 82 34 F6 34 - 82 35 87 31 (offset 497E - 4A11)
0xFE9F, // U+4DAE is non-936 GB18030 value FE 9F.
0x0051, // U+4DAF - U+4DFF ( 81 chars) are GB18030 82 35 87 32 - 82 35 8F 32 (offset 4A12 - 4A62)
0xD1A6, // U+4E00 - U+9FA5 (20902 chars) use CP 936 conversion.
0x385A, // U+9FA6 - U+D7FF (14426 chars) are GB18030 82 35 8F 33 - 83 36 C7 38 (offset 4A63 - 82BC)
0x8F6C, // U+D800 - U+E76B ( 3948 chars) use CP 936 conversion.
0x0001, // U+E76C - U+E76C ( 1 chars) are GB18030 83 36 C7 39 - 83 36 C7 39 (offset 82BD - 82BD)
0x805B, // U+E76D - U+E7C7 ( 91 chars) use CP 936 conversion.
0x0001, // U+E7C8 - U+E7C8 ( 1 chars) are GB18030 83 36 C8 30 - 83 36 C8 30 (offset 82BE - 82BE)
0x801E, // U+E7C9 - U+E7E6 ( 30 chars) use CP 936 conversion.
0x000D, // U+E7E7 - U+E7F3 ( 13 chars) are GB18030 83 36 C8 31 - 83 36 C9 33 (offset 82BF - 82CB)
0x8021, // U+E7F4 - U+E814 ( 33 chars) use CP 936 conversion.
0x0001, // U+E815 - U+E815 ( 1 chars) are GB18030 83 36 C9 34 - 83 36 C9 34 (offset 82CC - 82CC)
0x8003, // U+E816 - U+E818 ( 3 chars) use CP 936 conversion.
0x0005, // U+E819 - U+E81D ( 5 chars) are GB18030 83 36 C9 35 - 83 36 C9 39 (offset 82CD - 82D1)
0x8001, // U+E81E - U+E81E ( 1 chars) use CP 936 conversion.
0x0007, // U+E81F - U+E825 ( 7 chars) are GB18030 83 36 CA 30 - 83 36 CA 36 (offset 82D2 - 82D8)
0x8001, // U+E826 - U+E826 ( 1 chars) use CP 936 conversion.
0x0004, // U+E827 - U+E82A ( 4 chars) are GB18030 83 36 CA 37 - 83 36 CB 30 (offset 82D9 - 82DC)
0x8002, // U+E82B - U+E82C ( 2 chars) use CP 936 conversion.
0x0004, // U+E82D - U+E830 ( 4 chars) are GB18030 83 36 CB 31 - 83 36 CB 34 (offset 82DD - 82E0)
0x8002, // U+E831 - U+E832 ( 2 chars) use CP 936 conversion.
0x0008, // U+E833 - U+E83A ( 8 chars) are GB18030 83 36 CB 35 - 83 36 CC 32 (offset 82E1 - 82E8)
0x8001, // U+E83B - U+E83B ( 1 chars) use CP 936 conversion.
0x0007, // U+E83C - U+E842 ( 7 chars) are GB18030 83 36 CC 33 - 83 36 CC 39 (offset 82E9 - 82EF)
0x8001, // U+E843 - U+E843 ( 1 chars) use CP 936 conversion.
0x0010, // U+E844 - U+E853 ( 16 chars) are GB18030 83 36 CD 30 - 83 36 CE 35 (offset 82F0 - 82FF)
0x8002, // U+E854 - U+E855 ( 2 chars) use CP 936 conversion.
0x000E, // U+E856 - U+E863 ( 14 chars) are GB18030 83 36 CE 36 - 83 36 CF 39 (offset 8300 - 830D)
0x8001, // U+E864 - U+E864 ( 1 chars) use CP 936 conversion.
0x10C7, // U+E865 - U+F92B ( 4295 chars) are GB18030 83 36 D0 30 - 84 30 85 34 (offset 830E - 93D4)
0x8001, // U+F92C - U+F92C ( 1 chars) use CP 936 conversion.
0x004C, // U+F92D - U+F978 ( 76 chars) are GB18030 84 30 85 35 - 84 30 8D 30 (offset 93D5 - 9420)
0x8001, // U+F979 - U+F979 ( 1 chars) use CP 936 conversion.
0x001B, // U+F97A - U+F994 ( 27 chars) are GB18030 84 30 8D 31 - 84 30 8F 37 (offset 9421 - 943B)
0x8001, // U+F995 - U+F995 ( 1 chars) use CP 936 conversion.
0x0051, // U+F996 - U+F9E6 ( 81 chars) are GB18030 84 30 8F 38 - 84 30 97 38 (offset 943C - 948C)
0x8001, // U+F9E7 - U+F9E7 ( 1 chars) use CP 936 conversion.
0x0009, // U+F9E8 - U+F9F0 ( 9 chars) are GB18030 84 30 97 39 - 84 30 98 37 (offset 948D - 9495)
0x8001, // U+F9F1 - U+F9F1 ( 1 chars) use CP 936 conversion.
0x001A, // U+F9F2 - U+FA0B ( 26 chars) are GB18030 84 30 98 38 - 84 30 9B 33 (offset 9496 - 94AF)
0x8004, // U+FA0C - U+FA0F ( 4 chars) use CP 936 conversion.
0x0001, // U+FA10 - U+FA10 ( 1 chars) are GB18030 84 30 9B 34 - 84 30 9B 34 (offset 94B0 - 94B0)
0x8001, // U+FA11 - U+FA11 ( 1 chars) use CP 936 conversion.
0x0001, // U+FA12 - U+FA12 ( 1 chars) are GB18030 84 30 9B 35 - 84 30 9B 35 (offset 94B1 - 94B1)
0x8002, // U+FA13 - U+FA14 ( 2 chars) use CP 936 conversion.
0x0003, // U+FA15 - U+FA17 ( 3 chars) are GB18030 84 30 9B 36 - 84 30 9B 38 (offset 94B2 - 94B4)
0x8001, // U+FA18 - U+FA18 ( 1 chars) use CP 936 conversion.
0x0006, // U+FA19 - U+FA1E ( 6 chars) are GB18030 84 30 9B 39 - 84 30 9C 34 (offset 94B5 - 94BA)
0x8003, // U+FA1F - U+FA21 ( 3 chars) use CP 936 conversion.
0x0001, // U+FA22 - U+FA22 ( 1 chars) are GB18030 84 30 9C 35 - 84 30 9C 35 (offset 94BB - 94BB)
0x8002, // U+FA23 - U+FA24 ( 2 chars) use CP 936 conversion.
0x0002, // U+FA25 - U+FA26 ( 2 chars) are GB18030 84 30 9C 36 - 84 30 9C 37 (offset 94BC - 94BD)
0x8003, // U+FA27 - U+FA29 ( 3 chars) use CP 936 conversion.
0x0406, // U+FA2A - U+FE2F ( 1030 chars) are GB18030 84 30 9C 38 - 84 31 85 37 (offset 94BE - 98C3)
0x8002, // U+FE30 - U+FE31 ( 2 chars) use CP 936 conversion.
0x0001, // U+FE32 - U+FE32 ( 1 chars) are GB18030 84 31 85 38 - 84 31 85 38 (offset 98C4 - 98C4)
0x8012, // U+FE33 - U+FE44 ( 18 chars) use CP 936 conversion.
0x0004, // U+FE45 - U+FE48 ( 4 chars) are GB18030 84 31 85 39 - 84 31 86 32 (offset 98C5 - 98C8)
0x800A, // U+FE49 - U+FE52 ( 10 chars) use CP 936 conversion.
0x0001, // U+FE53 - U+FE53 ( 1 chars) are GB18030 84 31 86 33 - 84 31 86 33 (offset 98C9 - 98C9)
0x8004, // U+FE54 - U+FE57 ( 4 chars) use CP 936 conversion.
0x0001, // U+FE58 - U+FE58 ( 1 chars) are GB18030 84 31 86 34 - 84 31 86 34 (offset 98CA - 98CA)
0x800E, // U+FE59 - U+FE66 ( 14 chars) use CP 936 conversion.
0x0001, // U+FE67 - U+FE67 ( 1 chars) are GB18030 84 31 86 35 - 84 31 86 35 (offset 98CB - 98CB)
0x8004, // U+FE68 - U+FE6B ( 4 chars) use CP 936 conversion.
0x0095, // U+FE6C - U+FF00 ( 149 chars) are GB18030 84 31 86 36 - 84 31 95 34 (offset 98CC - 9960)
0x805E, // U+FF01 - U+FF5E ( 94 chars) use CP 936 conversion.
0x0081, // U+FF5F - U+FFDF ( 129 chars) are GB18030 84 31 95 35 - 84 31 A2 33 (offset 9961 - 99E1)
0x8006, // U+FFE0 - U+FFE5 ( 6 chars) use CP 936 conversion.
0x001A, // U+FFE6 - U+FFFF ( 26 chars) are GB18030 84 31 A2 34 - 84 31 A4 39 (offset 99E2 - 99FB)
};
}
}
|