| private Fallback ( byte fallbackByte ) : bool | ||
| fallbackByte | byte | |
| return | bool | |
[System.Security.SecurityCritical] // auto-generated
internal override unsafe int GetChars(byte* bytes, int byteCount,
char* chars, int charCount, DecoderNLS baseDecoder)
{
Contract.Assert(byteCount >=0, "[UTF7Encoding.GetChars]byteCount >=0");
Contract.Assert(bytes!=null, "[UTF7Encoding.GetChars]bytes!=null");
Contract.Assert(charCount >=0, "[UTF7Encoding.GetChars]charCount >=0");
// Might use a decoder
UTF7Encoding.Decoder decoder = (UTF7Encoding.Decoder) baseDecoder;
// Get our output buffer info.
Encoding.EncodingCharBuffer buffer = new Encoding.EncodingCharBuffer(
this, decoder, chars, charCount, bytes, byteCount);
// Get decoder info
int bits = 0;
int bitCount = -1;
bool firstByte = false;
if (decoder != null)
{
bits = decoder.bits;
bitCount = decoder.bitCount;
firstByte = decoder.firstByte;
Contract.Assert(firstByte == false || decoder.bitCount <= 0,
"[UTF7Encoding.GetChars]If remembered bits, then first byte flag shouldn't be set");
}
// We may have had bits in the decoder that we couldn't output last time, so do so now
if (bitCount >= 16)
{
// Check our decoder buffer
if (!buffer.AddChar((char)((bits >> (bitCount - 16)) & 0xFFFF)))
ThrowCharsOverflow(decoder, true); // Always throw, they need at least 1 char even in Convert
// Used this one, clean up extra bits
bitCount -= 16;
}
// Loop through the input
while (buffer.MoreData)
{
byte currentByte = buffer.GetNextByte();
int c;
if (bitCount >= 0)
{
//
// Modified base 64 encoding.
//
sbyte v;
if (currentByte < 0x80 && ((v = base64Values[currentByte]) >=0))
{
firstByte = false;
bits = (bits << 6) | ((byte)v);
bitCount += 6;
if (bitCount >= 16)
{
c = (bits >> (bitCount - 16)) & 0xFFFF;
bitCount -= 16;
}
// If not enough bits just continue
else continue;
}
else
{
// If it wasn't a base 64 byte, everything's going to turn off base 64 mode
bitCount = -1;
if (currentByte != '-')
{
// >= 0x80 (because of 1st if statemtn)
// We need this check since the base64Values[b] check below need b <= 0x7f.
// This is not a valid base 64 byte. Terminate the shifted-sequence and
// emit this byte.
// not in base 64 table
// According to the RFC 1642 and the example code of UTF-7
// in Unicode 2.0, we should just zero-extend the invalid UTF7 byte
// Chars won't be updated unless this works, try to fallback
if (!buffer.Fallback(currentByte))
break; // Stop here, didn't throw
// Used that byte, we're done with it
continue;
}
//
// The encoding for '+' is "+-".
//
if (firstByte) c = '+';
// We just turn it off if not emitting a +, so we're done.
else continue;
}
//
// End of modified base 64 encoding block.
//
}
else if (currentByte == '+')
{
//
// Found the start of a modified base 64 encoding block or a plus sign.
//
bitCount = 0;
firstByte = true;
continue;
}
else
{
// Normal character
if (currentByte >= 0x80)
{
// Try to fallback
if (!buffer.Fallback(currentByte))
break; // Stop here, didn't throw
// Done falling back
continue;
}
// Use the normal character
c = currentByte;
}
if (c >= 0)
{
// Check our buffer
if (!buffer.AddChar((char)c))
{
// No room. If it was a plain char we'll try again later.
// Note, we'll consume this byte and stick it in decoder, even if we can't output it
if (bitCount >= 0) // Can we rememmber this byte (char)
{
buffer.AdjustBytes(+1); // Need to readd the byte that AddChar subtracted when it failed
bitCount += 16; // We'll still need that char we have in our bits
}
break; // didn't throw, stop
}
}
}
// Stick stuff in the decoder if we can (chars == null if counting, so don't store decoder)
if (chars != null && decoder != null)
{
// MustFlush? (Could've been cleared by ThrowCharsOverflow if Convert & didn't reach end of buffer)
if (decoder.MustFlush)
{
// RFC doesn't specify what would happen if we have non-0 leftover bits, we just drop them
decoder.bits = 0;
decoder.bitCount = -1;
decoder.firstByte = false;
}
else
{
decoder.bits = bits;
decoder.bitCount = bitCount;
decoder.firstByte = firstByte;
}
decoder.m_bytesUsed = buffer.BytesUsed;
}
// else ignore any hanging bits.
// Return our count
return buffer.Count;
}
// For decoding, the following interesting rules apply:
// Virama followed by another Virama or Nukta becomes Virama + ZWNJ or Virama + ZWJ
// ATR is followed by a byte to switch code pages ("fonts")
// Devenagari F0, B8 -> \u0952
// Devenagari F0, BF -> \u0970
// Some characters followed by E9 become a different character instead.
internal 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
// Allow null chars for counting
BCLDebug.Assert(bytes != null, "[ISCIIEncoding.GetChars]bytes is null");
BCLDebug.Assert(byteCount >= 0, "[ISCIIEncoding.GetChars]byteCount is negative");
// BCLDebug.Assert(chars != null, "[ISCIIEncoding.GetChars]chars is null");
BCLDebug.Assert(charCount >= 0, "[ISCIIEncoding.GetChars]charCount is negative");
// Need the ISCII Decoder
ISCIIDecoder decoder = (ISCIIDecoder) baseDecoder;
// Get our info.
Encoding.EncodingCharBuffer buffer = new Encoding.EncodingCharBuffer(
this, decoder, chars, charCount, bytes, byteCount);
int currentCodePage = this.defaultCodePage;
bool bLastATR = false;
bool bLastVirama = false;
bool bLastDevenagariStressAbbr = false;
char cLastCharForNextNukta = '\0';
char cLastCharForNoNextNukta = '\0';
// See if there's anything in our decoder
if (decoder != null)
{
currentCodePage = decoder.currentCodePage;
bLastATR = decoder.bLastATR;
bLastVirama = decoder.bLastVirama;
bLastDevenagariStressAbbr = decoder.bLastDevenagariStressAbbr;
cLastCharForNextNukta = decoder.cLastCharForNextNukta;
cLastCharForNoNextNukta = decoder.cLastCharForNoNextNukta;
}
bool bLastSpecial = bLastVirama | bLastATR | bLastDevenagariStressAbbr |
(cLastCharForNextNukta != '\0');
// Get our current code page index (some code pages are dups)
int currentCodePageIndex = -1;
BCLDebug.Assert(currentCodePage >= CodeDevanagari && currentCodePage <= CodePunjabi,
"[ISCIIEncoding.GetChars]Decoder code page must be >= Devanagari and <= Punjabi, not " + currentCodePage);
if (currentCodePage >= CodeDevanagari && currentCodePage <= CodePunjabi)
{
currentCodePageIndex = IndicMappingIndex[currentCodePage];
}
// Loop through our input
while (buffer.MoreData)
{
byte b = buffer.GetNextByte();
// See if last one was special
if (bLastSpecial)
{
// Now it won't be
bLastSpecial = false;
// One and only one of our flags should be set
BCLDebug.Assert(((bLastVirama ? 1 : 0) + (bLastATR ? 1 : 0) +
(bLastDevenagariStressAbbr ? 1 : 0) +
((cLastCharForNextNukta > 0) ? 1 : 0)) == 1,
String.Format(CultureInfo.InvariantCulture,
"[ISCIIEncoding.GetChars]Special cases require 1 and only 1 special case flag: LastATR {0} Dev. {1} Nukta {2}",
bLastATR, bLastDevenagariStressAbbr, cLastCharForNextNukta));
// If the last one was an ATR, then we'll have to do ATR stuff
if (bLastATR)
{
// No longer last ATR, we know it wasn't bLastVirama
bLastATR = false;
// We only support Devanagari - Punjabi
if (b >= (0x40 | CodeDevanagari) && b <= (0x40 | CodePunjabi))
{
// Remember the code page
currentCodePage = b & 0xf;
currentCodePageIndex = IndicMappingIndex[currentCodePage];
continue;
}
// Change back to default?
if (b == 0x40)
{
currentCodePage = this.defaultCodePage;
currentCodePageIndex = -1;
if (currentCodePage >= CodeDevanagari && currentCodePage <= CodePunjabi)
{
currentCodePageIndex = IndicMappingIndex[currentCodePage];
}
continue;
}
// We don't support Roman
if (b == 0x41)
{
currentCodePage = this.defaultCodePage;
currentCodePageIndex = -1;
if (currentCodePage >= CodeDevanagari && currentCodePage <= CodePunjabi)
{
currentCodePageIndex = IndicMappingIndex[currentCodePage];
}
// Even though we don't know how to support Roman, windows didn't add a ? so we don't either.
continue;
}
// Other code pages & ATR codes not supported, fallback the ATR
buffer.Fallback(ControlATR);
// turn off things
bLastVirama = false;
bLastATR = false;
bLastDevenagariStressAbbr = false;
cLastCharForNextNukta = (char)0;
cLastCharForNoNextNukta = (char)0;
// Keep processing this byte
}
else if (bLastVirama)
{
// If last was Virama, then we might need ZWNJ or ZWJ instead
if (b == Virama)
{
// If no room, then stop
if (!buffer.AddChar(ZWNJ))
break;
bLastVirama = false;
continue;
}
if (b == Nukta)
{
// If no room, then stop
if (!buffer.AddChar(ZWJ))
break;
bLastVirama = false;
continue;
}
bLastVirama = false;
}
else if (bLastDevenagariStressAbbr)
{
// Last byte was an f0 (ext).
// If current is b8 or bf, then we have 952 or 970. Otherwise fallback
if (b == 0xb8)
{
// It was a b8
if (!buffer.AddChar('\x0952')) // Devanagari stress sign anudatta
break;
bLastDevenagariStressAbbr = false;
continue;
}
if (b == 0xbf)
{
// It was a bf
if (!buffer.AddChar('\x0970')) // Devanagari abbr. sign
break;
bLastDevenagariStressAbbr = false;
continue;
}
// Wasn't an expected pattern, do fallback for f0 (ext) and
bLastDevenagariStressAbbr = false;
buffer.Fallback(DevenagariExt);
// Keep processing this byte
}
else
{
// We were checking for next char being a nukta
BCLDebug.Assert(cLastCharForNextNukta > 0 && cLastCharForNoNextNukta > 0,
"[ISCIIEncoding.GetChars]No other special case found, but cLastCharFor(No)NextNukta variable(s) aren't set.");
// We'll either add combined char or last char
if (b == Nukta)
{
// We combine nukta with previous char
if (!buffer.AddChar(cLastCharForNextNukta))
break;
// Done already
cLastCharForNextNukta = cLastCharForNoNextNukta = '\0';
continue;
}
// No Nukta, just add last character and keep processing current byte
if (!buffer.AddChar(cLastCharForNoNextNukta))
break;
cLastCharForNextNukta = cLastCharForNoNextNukta = '\0';
// Keep processing this byte
}
}
// Now bLastSpecial should be false and all flags false.
BCLDebug.Assert (!bLastSpecial && !bLastDevenagariStressAbbr && !bLastVirama && !bLastATR &&
cLastCharForNextNukta == '\0',
"[ISCIIEncoding.GetChars]No special state for last code point should exist at this point.");
// If its a simple byte, just add it
if (b < MultiByteBegin)
{
if (!buffer.AddChar((char)b))
break;
continue;
}
// See if its an ATR marker
if (b == ControlATR)
{
bLastATR = bLastSpecial = true;
continue;
}
BCLDebug.Assert (currentCodePageIndex != -1, "[ISCIIEncoding.GetChars]Expected valid currentCodePageIndex != -1");
char ch = IndicMapping[currentCodePageIndex, 0, b - MultiByteBegin];
char cAlt = IndicMapping[currentCodePageIndex, 1, b - MultiByteBegin];
// If no 2nd char, just add it, also lonely Nuktas get added as well.
if (cAlt == 0 || b == Nukta)
{
// If it was an unknown character do fallback
// ? if not known.
if (ch == 0)
{
if (!buffer.Fallback(b))
break;
}
else
{
if (!buffer.AddChar(ch))
break;
}
continue;
}
// if b == Virama set last Virama so we can do ZWJ or ZWNJ next time if needed.
if (b == Virama)
{
if (!buffer.AddChar(ch))
break;
bLastVirama = bLastSpecial = true;
continue;
}
// See if its one that changes with a Nukta
if ((cAlt & 0xF000) == 0)
{
// It could change if next char is a nukta
bLastSpecial = true;
cLastCharForNextNukta = cAlt;
cLastCharForNoNextNukta = ch;
continue;
}
// We must be the Devenagari special case for F0, B8 & F0, BF
BCLDebug.Assert(currentCodePage == CodeDevanagari && b == DevenagariExt,
String.Format(CultureInfo.InvariantCulture,
"[ISCIIEncoding.GetChars] Devenagari special case must {0} not {1} or in Devanagari code page {2} not {3}.",
DevenagariExt, b, CodeDevanagari, currentCodePage));
bLastDevenagariStressAbbr = bLastSpecial = true;
}
// If we don't have a decoder, or if we had to flush, then we need to get rid
// of last ATR, LastNoNextNukta and LastDevenagariExt.
if (decoder == null || decoder.MustFlush)
{
// If these fail (because of Convert with insufficient buffer), then they'll turn off MustFlush as well.
if (bLastATR)
{
// Have to add ATR fallback
if (buffer.Fallback(ControlATR))
bLastATR = false;
else
// If not successful, convert will maintain state for next time, also
// AddChar will have decremented our byte count, however we need it to remain the same
buffer.GetNextByte();
}
else if (bLastDevenagariStressAbbr)
{
// Have to do fallback for DevenagariExt
if (buffer.Fallback(DevenagariExt))
bLastDevenagariStressAbbr = false;
else
// If not successful, convert will maintain state for next time, also
// AddChar will have decremented our byte count, however we need it to remain the same
buffer.GetNextByte();
}
else if (cLastCharForNoNextNukta != '\0')
{
// Have to add our last char because there was no next nukta
if (buffer.AddChar(cLastCharForNoNextNukta))
cLastCharForNoNextNukta = cLastCharForNextNukta = '\0';
else
// If not successful, convert will maintain state for next time, also
// AddChar will have decremented our byte count, however we need it to remain the same
buffer.GetNextByte();
}
// LastVirama is unimportant for flushing decoder.
}
// Remember any left over stuff
// (only remember if we aren't counting)
if (decoder != null && chars != null)
{
// If not flushing or have state (from convert) then need to remember state
if (!decoder.MustFlush ||
cLastCharForNoNextNukta != '\0' || bLastATR || bLastDevenagariStressAbbr)
{
// Either not flushing or had state (from convert)
BCLDebug.Assert(!decoder.MustFlush || !decoder.m_throwOnOverflow,
"[ISCIIEncoding.GetChars]Expected no state or not converting or not flushing");
decoder.currentCodePage = currentCodePage;
decoder.bLastVirama = bLastVirama;
decoder.bLastATR = bLastATR;
decoder.bLastDevenagariStressAbbr = bLastDevenagariStressAbbr;
decoder.cLastCharForNextNukta = cLastCharForNextNukta;
decoder.cLastCharForNoNextNukta = cLastCharForNoNextNukta;
}
else
{
decoder.currentCodePage = this.defaultCodePage;
decoder.bLastVirama = false;
decoder.bLastATR = false;
decoder.bLastDevenagariStressAbbr = false;
decoder.cLastCharForNextNukta = '\0';
decoder.cLastCharForNoNextNukta = '\0';
}
decoder.m_bytesUsed = buffer.BytesUsed;
}
// Otherwise we already did fallback and added extra things
// Return the # of characters we found
return buffer.Count;
}
[System.Security.SecurityCritical] // auto-generated
private unsafe int GetCharsCP52936(byte* bytes, int byteCount,
char* chars, int charCount, ISO2022Decoder decoder)
{
Contract.Assert(byteCount >=0, "[ISO2022Encoding.GetCharsCP52936]count >=0");
Contract.Assert(bytes!=null, "[ISO2022Encoding.GetCharsCP52936]bytes!=null");
// Get our info.
Encoding.EncodingCharBuffer buffer = new Encoding.EncodingCharBuffer(
this, decoder, chars, charCount, bytes, byteCount);
// No mode information yet
ISO2022Modes currentMode = ISO2022Modes.ModeASCII;
int byteLeftOver = -1;
bool bUsedDecoder = false;
if (decoder != null)
{
currentMode = decoder.currentMode;
// See if we have leftover decoder buffer to use
// Don't want to mess up decoder if we're counting or throw an exception
if (decoder.bytesLeftOverCount != 0 )
{
// Load our bytesLeftOver
byteLeftOver = decoder.bytesLeftOver[0];
}
}
// Do this until the end, just do '?' replacement because we don't have fallbacks for decodings.
while (buffer.MoreData || byteLeftOver >= 0)
{
byte ch;
// May have a left over byte
if (byteLeftOver >= 0)
{
ch = (byte)byteLeftOver;
byteLeftOver = -1;
}
else
{
ch = buffer.GetNextByte();
}
// We're in escape mode
if (ch == '~')
{
// Next char is type of switch
if (!buffer.MoreData)
{
// We don't have anything left, it'll be in decoder or a ?
// don't fail if we are allowing overflows
if (decoder == null || decoder.MustFlush)
{
// We'll be a '?'
buffer.Fallback(ch);
// break if we fail & break if we don't (because !MoreData)
// Add succeeded, continue
break;
}
// Stick it in decoder
if (decoder != null)
decoder.ClearMustFlush();
if (chars != null)
{
decoder.bytesLeftOverCount = 1;
decoder.bytesLeftOver[0] = (byte)'~';
bUsedDecoder = true;
}
break;
}
// What type is it?, get 2nd byte
ch = buffer.GetNextByte();
if (ch == '~' && currentMode == ISO2022Modes.ModeASCII)
{
// Its just a ~~ replacement for ~, add it
if (!buffer.AddChar((char)ch, 2))
// Add failed, break for converting
break;
// Add succeeded, continue
continue;
}
else if (ch == '{')
{
// Switching to Double Byte mode
currentMode = ISO2022Modes.ModeHZ;
continue;
}
else if (ch == '}')
{
// Switching to ASCII mode
currentMode = ISO2022Modes.ModeASCII;
continue;
}
else if (ch == '\n')
{
// Ignore ~\n sequence
continue;
}
else
{
// Unknown escape, back up and try the '~' as a "normal" byte or lead byte
buffer.AdjustBytes(-1);
ch = (byte)'~';
}
}
// go ahead and add our data
if (currentMode != ISO2022Modes.ModeASCII)
{
// Should be ModeHZ
Contract.Assert(currentMode == ISO2022Modes.ModeHZ, "[ISO2022Encoding.GetCharsCP52936]Expected ModeHZ");
char cm;
// Everett allowed characters < 0x20 to be passed as if they were ASCII
if (ch < 0x20)
{
// Emit it as ASCII
goto STOREASCII;
}
// Its multibyte, should have another byte
if (!buffer.MoreData)
{
// No bytes left
// don't fail if we are allowing overflows
if (decoder == null || decoder.MustFlush)
{
// Not enough bytes, fallback lead byte
buffer.Fallback(ch);
// Break if we fail & break because !MoreData
break;
}
if (decoder != null)
decoder.ClearMustFlush();
// Stick it in decoder
if (chars != null)
{
decoder.bytesLeftOverCount = 1;
decoder.bytesLeftOver[0] = ch;
bUsedDecoder = true;
}
break;
}
// Everett uses space as an escape character for single SBCS bytes
byte ch2 = buffer.GetNextByte();
ushort iBytes = (ushort)(ch << 8 | ch2);
if (ch == ' ' && ch2 != 0)
{
// Get next char and treat it like ASCII (Everett treated space like an escape
// allowing the next char to be just ascii)
cm = (char)ch2;
goto STOREMULTIBYTE;
}
// Bytes should be in range: lead byte 0x21-0x77, trail byte: 0x21 - 0x7e
if ((ch < 0x21 || ch > 0x77 || ch2 < 0x21 || ch2 > 0x7e) &&
// Everett allowed high bit mappings for same characters (but only if both bits set)
(ch < 0xa1 || ch > 0xf7 || ch2 < 0xa1 || ch2 > 0xfe))
{
// For some reason Everett allowed XX20 to become unicode 3000... (ideo sp)
if (ch2 == 0x20 && 0x21 <= ch && ch <= 0x7d)
{
iBytes = 0x2121;
goto MULTIBYTE;
}
// Illegal char, use fallback. If lead byte is 0 have to do it special and do it first
if (!buffer.Fallback((byte)(iBytes>>8), (byte)(iBytes)))
break;
continue;
}
MULTIBYTE:
iBytes |= 0x8080;
// Look up the multibyte char to stick it in our data
// We have a iBytes to try to convert.
cm = mapBytesToUnicode[iBytes];
STOREMULTIBYTE:
// See if it was unknown
if (cm == UNKNOWN_CHAR_FLAG && iBytes != 0)
{
// Fall back the unknown stuff
if (!buffer.Fallback((byte)(iBytes>>8), (byte)(iBytes)))
break;
continue;
}
if (!buffer.AddChar(cm, 2))
break; // convert ran out of buffer, stop
continue;
}
// Just ASCII
// We allow some chars > 7f because everett did, so we have to look them up.
STOREASCII:
char c = mapBytesToUnicode[ch];
// Check if it was unknown
if ((c == UNKNOWN_CHAR_FLAG || c == 0) && (ch != 0))
{
// fallback the unkown bytes
if (!buffer.Fallback((byte)ch))
break;
continue;
}
// Go ahead and add our ASCII character
if (!buffer.AddChar(c))
break; // convert ran out of buffer, stop
}
// Need to remember our state, IF we're not counting
if (chars != null && decoder != null)
{
if (!bUsedDecoder)
{
// If we didn't use it, clear the byte left over
decoder.bytesLeftOverCount = 0;
}
if (decoder.MustFlush && decoder.bytesLeftOverCount == 0)
{
decoder.currentMode = ISO2022Modes.ModeASCII;
}
else
{
// Either not flushing or had state (from convert)
Contract.Assert(!decoder.MustFlush || !decoder.m_throwOnOverflow,
"[ISO2022Encoding.GetCharsCP52936]Expected no state or not converting or not flushing");
decoder.currentMode = currentMode;
}
decoder.m_bytesUsed = buffer.BytesUsed;
}
// Return # of characters we found
return buffer.Count;
}
[System.Security.SecurityCritical] // auto-generated
private unsafe int GetCharsCP5022xJP(byte* bytes, int byteCount,
char* chars, int charCount, ISO2022Decoder decoder)
{
// Get our info.
Encoding.EncodingCharBuffer buffer = new Encoding.EncodingCharBuffer(
this, decoder, chars, charCount, bytes, byteCount);
// No mode information yet
ISO2022Modes currentMode = ISO2022Modes.ModeASCII; // Our current Mode
ISO2022Modes shiftInMode = ISO2022Modes.ModeASCII; // Mode that we'll shift in to
byte[] escapeBytes = new byte[4];
int escapeCount = 0;
if (decoder != null)
{
currentMode = decoder.currentMode;
shiftInMode = decoder.shiftInOutMode;
// See if we have leftover decoder buffer to use
// Load our bytesLeftOver
escapeCount = decoder.bytesLeftOverCount;
// Don't want to mess up decoder if we're counting or throw an exception
for (int i = 0; i < escapeCount; i++)
escapeBytes[i] = decoder.bytesLeftOver[i];
}
// Do this until the end
while (buffer.MoreData || escapeCount > 0)
{
byte ch;
if (escapeCount > 0)
{
// Get more escape sequences if necessary
if (escapeBytes[0] == ESCAPE)
{
// Stop if no more input
if (!buffer.MoreData)
{
if (decoder != null && !decoder.MustFlush)
break;
}
else
{
// Add it to the sequence we can check
escapeBytes[escapeCount++] = buffer.GetNextByte();
// We have an escape sequence
ISO2022Modes modeReturn =
CheckEscapeSequenceJP(escapeBytes, escapeCount);
if (modeReturn != ISO2022Modes.ModeInvalidEscape)
{
if (modeReturn != ISO2022Modes.ModeIncompleteEscape)
{
// Processed escape correctly
escapeCount = 0;
// We're now this mode
currentMode = shiftInMode = modeReturn;
}
// Either way, continue to get next escape or real byte
continue;
}
}
// If ModeInvalidEscape, or no input & must flush, then fall through to add escape.
}
// Read next escape byte and move them down one.
ch = DecrementEscapeBytes(ref escapeBytes, ref escapeCount);
}
else
{
// Get our next byte
ch = buffer.GetNextByte();
if (ch == ESCAPE)
{
// We'll have an escape sequence, use it if we don't have one buffered already
if (escapeCount == 0)
{
// Start this new escape sequence
escapeBytes[0] = ch;
escapeCount = 1;
continue;
}
// Flush the previous escape sequence, then reuse this escape byte
buffer.AdjustBytes(-1);
}
}
if (ch == SHIFT_OUT)
{
shiftInMode = currentMode;
currentMode = ISO2022Modes.ModeHalfwidthKatakana;
continue;
}
else if (ch == SHIFT_IN)
{
currentMode = shiftInMode;
continue;
}
// Get our full character
ushort iBytes = ch;
bool b2Bytes = false;
if (currentMode == ISO2022Modes.ModeJIS0208)
{
//
// To handle errors, we need to check:
// 1. if trailbyte is there
// 2. if code is valid
//
if (escapeCount > 0)
{
// Let another escape fall through
if (escapeBytes[0] != ESCAPE)
{
// Move them down one & get the next data
iBytes <<= 8;
iBytes |= DecrementEscapeBytes(ref escapeBytes, ref escapeCount);
b2Bytes = true;
}
}
else if (buffer.MoreData)
{
iBytes <<= 8;
iBytes |= buffer.GetNextByte();
b2Bytes = true;
}
else
{
// Not enough input, use decoder if possible
if (decoder == null || decoder.MustFlush)
{
// No decoder, do fallback for this byte
buffer.Fallback(ch);
break;
}
// Stick it in the decoder if we're not counting
if (chars != null)
{
escapeBytes[0] = ch;
escapeCount = 1;
}
break;
}
// MLang treated JIS 0208 '*' lead byte like a single halfwidth katakana
// escape, so use 0x8e00 as katakana lead byte and keep same trail byte.
// 0x2a lead byte range is normally unused in JIS 0208, so shouldn't have
// any wierd compatibility issues.
if ((b2Bytes == true) && ((iBytes & 0xff00) == 0x2a00))
{
iBytes = (ushort)(iBytes & 0xff);
iBytes |= (LEADBYTE_HALFWIDTH << 8); // Put us in the halfwidth katakana range
}
}
else if (iBytes >= 0xA1 && iBytes <= 0xDF)
{
// Everett accidentally mapped Katakana like shift-jis (932),
// even though this is a 7 bit code page. We keep that mapping
iBytes |= (LEADBYTE_HALFWIDTH << 8); // Map to halfwidth katakana range
iBytes &= 0xff7f; // remove extra 0x80
}
else if (currentMode == ISO2022Modes.ModeHalfwidthKatakana )
{
// Add 0x10 lead byte that our encoding expects for Katakana:
iBytes |= (LEADBYTE_HALFWIDTH << 8);
}
// We have an iBytes to try to convert.
char c = mapBytesToUnicode[iBytes];
// See if it was unknown
if (c == UNKNOWN_CHAR_FLAG && iBytes != 0)
{
// Have to do fallback
if (b2Bytes)
{
if (!buffer.Fallback((byte)(iBytes >> 8), (byte)iBytes))
break;
}
else
{
if (!buffer.Fallback(ch))
break;
}
}
else
{
// If we were JIS 0208, then we consumed an extra byte
if (!buffer.AddChar(c, b2Bytes ? 2:1))
break;
}
}
// Make sure our decoder state matches our mode, if not counting
if (chars != null && decoder != null)
{
// Remember it if we don't flush
if (!decoder.MustFlush || escapeCount != 0)
{
// Either not flushing or had state (from convert)
Contract.Assert(!decoder.MustFlush || !decoder.m_throwOnOverflow,
"[ISO2022Encoding.GetCharsCP5022xJP]Expected no state or not converting or not flushing");
decoder.currentMode = currentMode;
decoder.shiftInOutMode = shiftInMode;
// Remember escape buffer
decoder.bytesLeftOverCount = escapeCount;
decoder.bytesLeftOver = escapeBytes;
}
else
{
// We flush, clear buffer
decoder.currentMode = ISO2022Modes.ModeASCII;
decoder.shiftInOutMode = ISO2022Modes.ModeASCII;
decoder.bytesLeftOverCount = 0;
// Slightly different if counting/not counting
}
decoder.m_bytesUsed = buffer.BytesUsed;
}
// Return # of characters we found
return buffer.Count;
}
internal override unsafe int GetChars(byte* bytes, int byteCount, char* chars, int charCount, DecoderNLS baseDecoder)
{
ISCIIDecoder decoder = (ISCIIDecoder) baseDecoder;
Encoding.EncodingCharBuffer buffer = new Encoding.EncodingCharBuffer(this, decoder, chars, charCount, bytes, byteCount);
int defaultCodePage = this.defaultCodePage;
bool bLastATR = false;
bool bLastVirama = false;
bool bLastDevenagariStressAbbr = false;
char cLastCharForNextNukta = '\0';
char cLastCharForNoNextNukta = '\0';
if (decoder != null)
{
defaultCodePage = decoder.currentCodePage;
bLastATR = decoder.bLastATR;
bLastVirama = decoder.bLastVirama;
bLastDevenagariStressAbbr = decoder.bLastDevenagariStressAbbr;
cLastCharForNextNukta = decoder.cLastCharForNextNukta;
cLastCharForNoNextNukta = decoder.cLastCharForNoNextNukta;
}
bool flag4 = ((bLastVirama | bLastATR) | bLastDevenagariStressAbbr) | (cLastCharForNextNukta != '\0');
int num2 = -1;
if ((defaultCodePage >= 2) && (defaultCodePage <= 11))
{
num2 = IndicMappingIndex[defaultCodePage];
}
while (buffer.MoreData)
{
byte nextByte = buffer.GetNextByte();
if (flag4)
{
flag4 = false;
if (bLastATR)
{
if ((nextByte >= 0x42) && (nextByte <= 0x4b))
{
defaultCodePage = nextByte & 15;
num2 = IndicMappingIndex[defaultCodePage];
bLastATR = false;
continue;
}
if (nextByte == 0x40)
{
defaultCodePage = this.defaultCodePage;
num2 = -1;
if ((defaultCodePage >= 2) && (defaultCodePage <= 11))
{
num2 = IndicMappingIndex[defaultCodePage];
}
bLastATR = false;
continue;
}
if (nextByte == 0x41)
{
defaultCodePage = this.defaultCodePage;
num2 = -1;
if ((defaultCodePage >= 2) && (defaultCodePage <= 11))
{
num2 = IndicMappingIndex[defaultCodePage];
}
bLastATR = false;
continue;
}
if (!buffer.Fallback((byte) 0xef))
{
break;
}
bLastATR = false;
}
else if (bLastVirama)
{
if (nextByte == 0xe8)
{
if (!buffer.AddChar(''))
{
break;
}
bLastVirama = false;
continue;
}
if (nextByte == 0xe9)
{
if (!buffer.AddChar(''))
{
break;
}
bLastVirama = false;
continue;
}
bLastVirama = false;
}
else if (bLastDevenagariStressAbbr)
{
if (nextByte == 0xb8)
{
if (!buffer.AddChar('॒'))
{
break;
}
bLastDevenagariStressAbbr = false;
continue;
}
if (nextByte == 0xbf)
{
if (!buffer.AddChar('॰'))
{
break;
}
bLastDevenagariStressAbbr = false;
continue;
}
if (!buffer.Fallback((byte) 240))
{
break;
}
bLastDevenagariStressAbbr = false;
}
else
{
if (nextByte == 0xe9)
{
if (!buffer.AddChar(cLastCharForNextNukta))
{
break;
}
cLastCharForNextNukta = cLastCharForNoNextNukta = '\0';
continue;
}
if (!buffer.AddChar(cLastCharForNoNextNukta))
{
break;
}
cLastCharForNextNukta = cLastCharForNoNextNukta = '\0';
}
}
if (nextByte < 160)
{
if (buffer.AddChar((char) nextByte))
{
continue;
}
break;
}
if (nextByte == 0xef)
{
bLastATR = flag4 = true;
}
else
{
char ch = IndicMapping[num2, 0, nextByte - 160];
char ch4 = IndicMapping[num2, 1, nextByte - 160];
if ((ch4 == '\0') || (nextByte == 0xe9))
{
if (ch == '\0')
{
if (buffer.Fallback(nextByte))
{
continue;
}
}
else if (buffer.AddChar(ch))
{
continue;
}
break;
}
if (nextByte == 0xe8)
{
if (!buffer.AddChar(ch))
{
break;
}
bLastVirama = flag4 = true;
}
else
{
if ((ch4 & 0xf000) == 0)
{
flag4 = true;
cLastCharForNextNukta = ch4;
cLastCharForNoNextNukta = ch;
continue;
}
bLastDevenagariStressAbbr = flag4 = true;
}
}
}
if ((decoder == null) || decoder.MustFlush)
{
if (bLastATR)
{
if (buffer.Fallback((byte) 0xef))
{
bLastATR = false;
}
else
{
buffer.GetNextByte();
}
}
else if (bLastDevenagariStressAbbr)
{
if (buffer.Fallback((byte) 240))
{
bLastDevenagariStressAbbr = false;
}
else
{
buffer.GetNextByte();
}
}
else if (cLastCharForNoNextNukta != '\0')
{
if (buffer.AddChar(cLastCharForNoNextNukta))
{
cLastCharForNoNextNukta = cLastCharForNextNukta = '\0';
}
else
{
buffer.GetNextByte();
}
}
}
if ((decoder != null) && (chars != null))
{
if ((!decoder.MustFlush || (cLastCharForNoNextNukta != '\0')) || (bLastATR || bLastDevenagariStressAbbr))
{
decoder.currentCodePage = defaultCodePage;
decoder.bLastVirama = bLastVirama;
decoder.bLastATR = bLastATR;
decoder.bLastDevenagariStressAbbr = bLastDevenagariStressAbbr;
decoder.cLastCharForNextNukta = cLastCharForNextNukta;
decoder.cLastCharForNoNextNukta = cLastCharForNoNextNukta;
}
else
{
decoder.currentCodePage = this.defaultCodePage;
decoder.bLastVirama = false;
decoder.bLastATR = false;
decoder.bLastDevenagariStressAbbr = false;
decoder.cLastCharForNextNukta = '\0';
decoder.cLastCharForNoNextNukta = '\0';
}
decoder.m_bytesUsed = buffer.BytesUsed;
}
return buffer.Count;
}
[System.Security.SecurityCritical] // auto-generated
private unsafe int GetCharsCP50225KR(byte* bytes, int byteCount,
char* chars, int charCount, ISO2022Decoder decoder)
{
// Get our info.
Encoding.EncodingCharBuffer buffer = new Encoding.EncodingCharBuffer(
this, decoder, chars, charCount, bytes, byteCount);
// No mode information yet
ISO2022Modes currentMode = ISO2022Modes.ModeASCII; // Our current Mode
byte[] escapeBytes = new byte[4];
int escapeCount = 0;
if (decoder != null)
{
currentMode = decoder.currentMode;
// See if we have leftover decoder buffer to use
// Load our bytesLeftOver
escapeCount = decoder.bytesLeftOverCount;
// Don't want to mess up decoder if we're counting or throw an exception
for (int i = 0; i < escapeCount; i++)
escapeBytes[i] = decoder.bytesLeftOver[i];
}
// Do this until the end, just do '?' replacement because we don't have fallbacks for decodings.
while (buffer.MoreData || escapeCount > 0)
{
byte ch;
if (escapeCount > 0)
{
// Get more escape sequences if necessary
if (escapeBytes[0] == ESCAPE)
{
// Stop if no more input
if (!buffer.MoreData)
{
if (decoder != null && !decoder.MustFlush)
break;
}
else
{
// Add it to the sequence we can check
escapeBytes[escapeCount++] = buffer.GetNextByte();
// We have an escape sequence
ISO2022Modes modeReturn =
CheckEscapeSequenceKR(escapeBytes, escapeCount);
if (modeReturn != ISO2022Modes.ModeInvalidEscape)
{
if (modeReturn != ISO2022Modes.ModeIncompleteEscape)
{
// Processed escape correctly, no effect (we know about KR mode)
escapeCount = 0;
}
// Either way, continue to get next escape or real byte
continue;
}
}
// If ModeInvalidEscape, or no input & must flush, then fall through to add escape.
}
// Still have something left over in escape buffer
// Get it and move them down one
ch = DecrementEscapeBytes(ref escapeBytes, ref escapeCount);
}
else
{
// Get our next byte
ch = buffer.GetNextByte();
if (ch == ESCAPE)
{
// We'll have an escape sequence, use it if we don't have one buffered already
if (escapeCount == 0)
{
// Start this new escape sequence
escapeBytes[0] = ch;
escapeCount = 1;
continue;
}
// Flush previous escape sequence, then reuse this escape byte
buffer.AdjustBytes(-1);
}
}
if (ch == SHIFT_OUT)
{
currentMode = ISO2022Modes.ModeKR;
continue;
}
else if (ch == SHIFT_IN)
{
currentMode = ISO2022Modes.ModeASCII;
continue;
}
// Get our full character
ushort iBytes = ch;
bool b2Bytes = false;
// MLANG was passing through ' ', '\t' and '\n', so we do so as well, but I don't see that in the RFC.
if (currentMode == ISO2022Modes.ModeKR && ch != ' ' && ch != '\t' && ch != '\n')
{
//
// To handle errors, we need to check:
// 1. if trailbyte is there
// 2. if code is valid
//
if (escapeCount > 0)
{
// Let another escape fall through
if (escapeBytes[0] != ESCAPE)
{
// Move them down one & get the next data
iBytes <<= 8;
iBytes |= DecrementEscapeBytes(ref escapeBytes, ref escapeCount);
b2Bytes = true;
}
}
else if (buffer.MoreData)
{
iBytes <<= 8;
iBytes |= buffer.GetNextByte();
b2Bytes = true;
}
else
{
// Not enough input, use decoder if possible
if (decoder == null || decoder.MustFlush)
{
// No decoder, do fallback for lonely 1st byte
buffer.Fallback(ch);
break;
}
// Stick it in the decoder if we're not counting
if (chars != null)
{
escapeBytes[0] = ch;
escapeCount = 1;
}
break;
}
}
// We have a iBytes to try to convert.
char c = mapBytesToUnicode[iBytes];
// See if it was unknown
if (c == UNKNOWN_CHAR_FLAG && iBytes != 0)
{
// Have to do fallback
if (b2Bytes)
{
if (!buffer.Fallback((byte)(iBytes >> 8), (byte)iBytes))
break;
}
else
{
if (!buffer.Fallback(ch))
break;
}
}
else
{
if (!buffer.AddChar(c, b2Bytes ? 2:1))
break;
}
}
// Make sure our decoder state matches our mode, if not counting
if (chars != null && decoder != null)
{
// Remember it if we don't flush
if (!decoder.MustFlush || escapeCount != 0)
{
// Either not flushing or had state (from convert)
Contract.Assert(!decoder.MustFlush || !decoder.m_throwOnOverflow,
"[ISO2022Encoding.GetCharsCP50225KR]Expected no state or not converting or not flushing");
decoder.currentMode = currentMode;
// Remember escape buffer
decoder.bytesLeftOverCount = escapeCount;
decoder.bytesLeftOver = escapeBytes;
}
else
{
// We flush, clear buffer
decoder.currentMode = ISO2022Modes.ModeASCII;
decoder.shiftInOutMode = ISO2022Modes.ModeASCII;
decoder.bytesLeftOverCount = 0;
}
decoder.m_bytesUsed = buffer.BytesUsed;
}
// Return # of characters we found
return buffer.Count;
}
internal override unsafe int GetChars(byte* bytes, int byteCount, char* chars, int charCount, DecoderNLS baseDecoder)
{
Decoder decoder = (Decoder) baseDecoder;
Encoding.EncodingCharBuffer buffer = new Encoding.EncodingCharBuffer(this, decoder, chars, charCount, bytes, byteCount);
int bits = 0;
int bitCount = -1;
bool firstByte = false;
if (decoder != null)
{
bits = decoder.bits;
bitCount = decoder.bitCount;
firstByte = decoder.firstByte;
}
if (bitCount >= 0x10)
{
if (!buffer.AddChar((char) ((bits >> (bitCount - 0x10)) & 0xffff)))
{
base.ThrowCharsOverflow(decoder, true);
}
bitCount -= 0x10;
}
while (buffer.MoreData)
{
int num4;
byte nextByte = buffer.GetNextByte();
if (bitCount >= 0)
{
sbyte num5;
if ((nextByte < 0x80) && ((num5 = this.base64Values[nextByte]) >= 0))
{
firstByte = false;
bits = (bits << 6) | ((byte) num5);
bitCount += 6;
if (bitCount < 0x10)
{
continue;
}
num4 = (bits >> (bitCount - 0x10)) & 0xffff;
bitCount -= 0x10;
goto Label_00FB;
}
bitCount = -1;
if (nextByte == 0x2d)
{
if (!firstByte)
{
continue;
}
num4 = 0x2b;
goto Label_00FB;
}
if (buffer.Fallback(nextByte))
{
continue;
}
break;
}
if (nextByte == 0x2b)
{
bitCount = 0;
firstByte = true;
continue;
}
if (nextByte >= 0x80)
{
if (buffer.Fallback(nextByte))
{
continue;
}
break;
}
num4 = nextByte;
Label_00FB:
if ((num4 >= 0) && !buffer.AddChar((char) num4))
{
if (bitCount >= 0)
{
buffer.AdjustBytes(1);
bitCount += 0x10;
}
break;
}
}
if ((chars != null) && (decoder != null))
{
if (decoder.MustFlush)
{
decoder.bits = 0;
decoder.bitCount = -1;
decoder.firstByte = false;
}
else
{
decoder.bits = bits;
decoder.bitCount = bitCount;
decoder.firstByte = firstByte;
}
decoder.m_bytesUsed = buffer.BytesUsed;
}
return buffer.Count;
}
internal 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
BCLDebug.Assert(bytes != null, "[GB18030Encoding.GetChars]bytes is null");
BCLDebug.Assert(byteCount >= 0, "[GB18030Encoding.GetChars]byteCount is negative");
// BCLDebug.Assert(chars != null, "[GB18030Encoding.GetChars]chars is null");
BCLDebug.Assert(charCount >= 0, "[GB18030Encoding.GetChars]charCount is negative");
// Fix our decoder
GB18030Decoder decoder = (GB18030Decoder)baseDecoder;
// Get our info.
Encoding.EncodingCharBuffer buffer = new Encoding.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(this.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 impliment 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(this.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;
}
private unsafe int GetCharsCP52936(byte* bytes, int byteCount, char* chars, int charCount, ISO2022Decoder decoder)
{
Encoding.EncodingCharBuffer buffer = new Encoding.EncodingCharBuffer(this, decoder, chars, charCount, bytes, byteCount);
ISO2022Modes modeASCII = ISO2022Modes.ModeASCII;
int num = -1;
bool flag = false;
if (decoder != null)
{
modeASCII = decoder.currentMode;
if (decoder.bytesLeftOverCount != 0)
{
num = decoder.bytesLeftOver[0];
}
}
while (buffer.MoreData || (num >= 0))
{
byte nextByte;
if (num >= 0)
{
nextByte = (byte) num;
num = -1;
}
else
{
nextByte = buffer.GetNextByte();
}
if (nextByte == 0x7e)
{
if (!buffer.MoreData)
{
if ((decoder == null) || decoder.MustFlush)
{
buffer.Fallback(nextByte);
}
else
{
if (decoder != null)
{
decoder.ClearMustFlush();
}
if (chars != null)
{
decoder.bytesLeftOverCount = 1;
decoder.bytesLeftOver[0] = 0x7e;
flag = true;
}
}
break;
}
nextByte = buffer.GetNextByte();
if ((nextByte == 0x7e) && (modeASCII == ISO2022Modes.ModeASCII))
{
if (buffer.AddChar((char) nextByte, 2))
{
continue;
}
break;
}
if (nextByte == 0x7b)
{
modeASCII = ISO2022Modes.ModeHZ;
continue;
}
if (nextByte == 0x7d)
{
modeASCII = ISO2022Modes.ModeASCII;
continue;
}
if (nextByte == 10)
{
continue;
}
buffer.AdjustBytes(-1);
nextByte = 0x7e;
}
if ((modeASCII != ISO2022Modes.ModeASCII) && (nextByte >= 0x20))
{
if (!buffer.MoreData)
{
if ((decoder == null) || decoder.MustFlush)
{
buffer.Fallback(nextByte);
}
else
{
if (decoder != null)
{
decoder.ClearMustFlush();
}
if (chars != null)
{
decoder.bytesLeftOverCount = 1;
decoder.bytesLeftOver[0] = nextByte;
flag = true;
}
}
}
else
{
char ch;
byte num3 = buffer.GetNextByte();
ushort index = (ushort) ((nextByte << 8) | num3);
if ((nextByte == 0x20) && (num3 != 0))
{
ch = (char) num3;
}
else
{
if ((((nextByte < 0x21) || (nextByte > 0x77)) || ((num3 < 0x21) || (num3 > 0x7e))) && (((nextByte < 0xa1) || (nextByte > 0xf7)) || ((num3 < 0xa1) || (num3 > 0xfe))))
{
if (((num3 == 0x20) && (0x21 <= nextByte)) && (nextByte <= 0x7d))
{
index = 0x2121;
}
else
{
if (buffer.Fallback((byte) (index >> 8), (byte) index))
{
continue;
}
break;
}
}
index = (ushort) (index | 0x8080);
ch = base.mapBytesToUnicode[index];
}
if ((ch == '\0') && (index != 0))
{
if (buffer.Fallback((byte) (index >> 8), (byte) index))
{
continue;
}
}
else if (buffer.AddChar(ch, 2))
{
continue;
}
}
break;
}
char ch2 = base.mapBytesToUnicode[nextByte];
if (((ch2 == '\0') || (ch2 == '\0')) && (nextByte != 0))
{
if (buffer.Fallback(nextByte))
{
continue;
}
break;
}
if (!buffer.AddChar(ch2))
{
break;
}
}
if ((chars != null) && (decoder != null))
{
if (!flag)
{
decoder.bytesLeftOverCount = 0;
}
if (decoder.MustFlush && (decoder.bytesLeftOverCount == 0))
{
decoder.currentMode = ISO2022Modes.ModeASCII;
}
else
{
decoder.currentMode = modeASCII;
}
decoder.m_bytesUsed = buffer.BytesUsed;
}
return buffer.Count;
}
private unsafe int GetCharsCP5022xJP(byte* bytes, int byteCount, char* chars, int charCount, ISO2022Decoder decoder)
{
Encoding.EncodingCharBuffer buffer = new Encoding.EncodingCharBuffer(this, decoder, chars, charCount, bytes, byteCount);
ISO2022Modes modeASCII = ISO2022Modes.ModeASCII;
ISO2022Modes shiftInOutMode = ISO2022Modes.ModeASCII;
byte[] buffer2 = new byte[4];
int escapeCount = 0;
if (decoder != null)
{
modeASCII = decoder.currentMode;
shiftInOutMode = decoder.shiftInOutMode;
escapeCount = decoder.bytesLeftOverCount;
for (int i = 0; i < escapeCount; i++)
{
buffer2[i] = decoder.bytesLeftOver[i];
}
}
while (buffer.MoreData || (escapeCount > 0))
{
byte nextByte;
if (escapeCount > 0)
{
if (buffer2[0] == 0x1b)
{
if (!buffer.MoreData)
{
if ((decoder != null) && !decoder.MustFlush)
{
break;
}
}
else
{
buffer2[escapeCount++] = buffer.GetNextByte();
ISO2022Modes modes3 = this.CheckEscapeSequenceJP(buffer2, escapeCount);
if (modes3 != ISO2022Modes.ModeInvalidEscape)
{
if (modes3 != ISO2022Modes.ModeIncompleteEscape)
{
escapeCount = 0;
modeASCII = shiftInOutMode = modes3;
}
continue;
}
}
}
nextByte = this.DecrementEscapeBytes(ref buffer2, ref escapeCount);
}
else
{
nextByte = buffer.GetNextByte();
if (nextByte == 0x1b)
{
if (escapeCount == 0)
{
buffer2[0] = nextByte;
escapeCount = 1;
continue;
}
buffer.AdjustBytes(-1);
}
}
if (nextByte == 14)
{
shiftInOutMode = modeASCII;
modeASCII = ISO2022Modes.ModeHalfwidthKatakana;
}
else
{
if (nextByte == 15)
{
modeASCII = shiftInOutMode;
continue;
}
ushort index = nextByte;
bool flag = false;
if (modeASCII == ISO2022Modes.ModeJIS0208)
{
if (escapeCount > 0)
{
if (buffer2[0] != 0x1b)
{
index = (ushort) (index << 8);
index = (ushort) (index | this.DecrementEscapeBytes(ref buffer2, ref escapeCount));
flag = true;
}
}
else if (buffer.MoreData)
{
index = (ushort) (index << 8);
index = (ushort) (index | buffer.GetNextByte());
flag = true;
}
else
{
if ((decoder == null) || decoder.MustFlush)
{
buffer.Fallback(nextByte);
}
else if (chars != null)
{
buffer2[0] = nextByte;
escapeCount = 1;
}
break;
}
if (flag && ((index & 0xff00) == 0x2a00))
{
index = (ushort) (index & 0xff);
index = (ushort) (index | 0x1000);
}
}
else if ((index >= 0xa1) && (index <= 0xdf))
{
index = (ushort) (index | 0x1000);
index = (ushort) (index & 0xff7f);
}
else if (modeASCII == ISO2022Modes.ModeHalfwidthKatakana)
{
index = (ushort) (index | 0x1000);
}
char ch = base.mapBytesToUnicode[index];
if ((ch == '\0') && (index != 0))
{
if (flag)
{
if (buffer.Fallback((byte) (index >> 8), (byte) index))
{
continue;
}
}
else if (buffer.Fallback(nextByte))
{
continue;
}
break;
}
if (!buffer.AddChar(ch, flag ? 2 : 1))
{
break;
}
}
}
if ((chars != null) && (decoder != null))
{
if (!decoder.MustFlush || (escapeCount != 0))
{
decoder.currentMode = modeASCII;
decoder.shiftInOutMode = shiftInOutMode;
decoder.bytesLeftOverCount = escapeCount;
decoder.bytesLeftOver = buffer2;
}
else
{
decoder.currentMode = ISO2022Modes.ModeASCII;
decoder.shiftInOutMode = ISO2022Modes.ModeASCII;
decoder.bytesLeftOverCount = 0;
}
decoder.m_bytesUsed = buffer.BytesUsed;
}
return buffer.Count;
}
internal override unsafe int GetChars(byte* bytes, int byteCount, char* chars, int charCount, DecoderNLS baseDecoder)
{
GB18030Decoder decoder = (GB18030Decoder) baseDecoder;
Encoding.EncodingCharBuffer buffer = new Encoding.EncodingCharBuffer(this, decoder, chars, charCount, bytes, byteCount);
short ch = -1;
short nextByte = -1;
short num3 = -1;
short num4 = -1;
if ((decoder != null) && (decoder.bLeftOver1 != -1))
{
ch = decoder.bLeftOver1;
nextByte = decoder.bLeftOver2;
num3 = decoder.bLeftOver3;
num4 = decoder.bLeftOver4;
while (ch != -1)
{
if (this.IsGBLeadByte(ch))
{
goto Label_00FC;
}
if (ch <= 0x7f)
{
if (!buffer.AddChar((char) ((ushort) ch)))
{
break;
}
}
else if (!buffer.Fallback((byte) ch))
{
break;
}
ch = nextByte;
nextByte = num3;
num3 = num4;
num4 = -1;
continue;
Label_0092:
if (!buffer.MoreData)
{
if (!decoder.MustFlush)
{
if (chars != null)
{
decoder.bLeftOver1 = ch;
decoder.bLeftOver2 = nextByte;
decoder.bLeftOver3 = num3;
decoder.bLeftOver4 = num4;
}
decoder.m_bytesUsed = buffer.BytesUsed;
return buffer.Count;
}
goto Label_010E;
}
if (nextByte == -1)
{
nextByte = buffer.GetNextByte();
}
else if (num3 == -1)
{
num3 = buffer.GetNextByte();
}
else
{
num4 = buffer.GetNextByte();
}
Label_00FC:
if ((nextByte == -1) || (this.IsGBFourByteTrailing(nextByte) && (num4 == -1)))
{
goto Label_0092;
}
Label_010E:
if (this.IsGBTwoByteTrailing(nextByte))
{
int index = ch << 8;
index |= (byte) nextByte;
if (!buffer.AddChar(base.mapBytesToUnicode[index], 2))
{
break;
}
ch = -1;
nextByte = -1;
continue;
}
if ((this.IsGBFourByteTrailing(nextByte) && this.IsGBLeadByte(num3)) && this.IsGBFourByteTrailing(num4))
{
int num6 = this.GetFourBytesOffset(ch, nextByte, num3, num4);
if (num6 <= 0x99fb)
{
if (!buffer.AddChar(this.map4BytesToUnicode[num6], 4))
{
break;
}
}
else if ((num6 >= 0x2e248) && (num6 <= 0x12e247))
{
num6 -= 0x2e248;
if (!buffer.AddChar((char) (0xd800 + (num6 / 0x400)), (char) (0xdc00 + (num6 % 0x400)), 4))
{
break;
}
}
else if (!buffer.Fallback((byte) ch, (byte) nextByte, (byte) num3, (byte) num4))
{
break;
}
ch = -1;
nextByte = -1;
num3 = -1;
num4 = -1;
continue;
}
if (!buffer.Fallback((byte) ch))
{
break;
}
ch = nextByte;
nextByte = num3;
num3 = num4;
num4 = -1;
}
}
while (buffer.MoreData)
{
byte num7 = buffer.GetNextByte();
if (num7 <= 0x7f)
{
if (buffer.AddChar((char) num7))
{
continue;
}
break;
}
if (this.IsGBLeadByte(num7))
{
if (buffer.MoreData)
{
byte num8 = buffer.GetNextByte();
if (this.IsGBTwoByteTrailing(num8))
{
int num9 = num7 << 8;
num9 |= num8;
if (buffer.AddChar(base.mapBytesToUnicode[num9], 2))
{
continue;
}
}
else if (this.IsGBFourByteTrailing(num8))
{
if (buffer.EvenMoreData(2))
{
byte num10 = buffer.GetNextByte();
byte num11 = buffer.GetNextByte();
if (this.IsGBLeadByte(num10) && this.IsGBFourByteTrailing(num11))
{
int num12 = this.GetFourBytesOffset(num7, num8, num10, num11);
if (num12 <= 0x99fb)
{
if (buffer.AddChar(this.map4BytesToUnicode[num12], 4))
{
continue;
}
}
else if ((num12 >= 0x2e248) && (num12 <= 0x12e247))
{
num12 -= 0x2e248;
if (buffer.AddChar((char) (0xd800 + (num12 / 0x400)), (char) (0xdc00 + (num12 % 0x400)), 4))
{
continue;
}
}
else if (buffer.Fallback(num7, num8, num10, num11))
{
continue;
}
}
else
{
buffer.AdjustBytes(-3);
if (buffer.Fallback(num7))
{
continue;
}
}
}
else if ((decoder != null) && !decoder.MustFlush)
{
if (chars != null)
{
ch = num7;
nextByte = num8;
if (buffer.MoreData)
{
num3 = buffer.GetNextByte();
}
else
{
num3 = -1;
}
num4 = -1;
}
}
else if (buffer.Fallback(num7, num8))
{
continue;
}
}
else
{
buffer.AdjustBytes(-1);
if (buffer.Fallback(num7))
{
continue;
}
}
}
else if ((decoder != null) && !decoder.MustFlush)
{
if (chars != null)
{
ch = num7;
nextByte = -1;
num3 = -1;
num4 = -1;
}
}
else if (buffer.Fallback(num7))
{
continue;
}
break;
}
if (!buffer.Fallback(num7))
{
break;
}
}
if (decoder != null)
{
if (chars != null)
{
decoder.bLeftOver1 = ch;
decoder.bLeftOver2 = nextByte;
decoder.bLeftOver3 = num3;
decoder.bLeftOver4 = num4;
}
decoder.m_bytesUsed = buffer.BytesUsed;
}
return buffer.Count;
}