// For fallback we may need a fallback buffer, we know we aren't default fallback.
EncoderFallbackBuffer fallbackBuffer = null;
+ char* charsForFallback;
if (encoder != null)
{
fallbackBuffer.InternalInitialize(chars, charEnd, encoder, false);
// This will fallback a pair if *chars is a low surrogate
- fallbackBuffer.InternalFallback(charLeftOver, ref chars);
+ charsForFallback = chars; // Avoid passing chars by reference to allow it to be enregistered
+ fallbackBuffer.InternalFallback(charLeftOver, ref charsForFallback);
+ chars = charsForFallback;
}
// Now we may have fallback char[] already from the encoder
}
// Get Fallback
- fallbackBuffer.InternalFallback(ch, ref chars);
+ charsForFallback = chars; // Avoid passing chars by reference to allow it to be enregistered
+ fallbackBuffer.InternalFallback(ch, ref charsForFallback);
+ chars = charsForFallback;
continue;
}
// For fallback we may need a fallback buffer, we know we aren't default fallback.
EncoderFallbackBuffer fallbackBuffer = null;
+ char* charsForFallback;
// prepare our end
char* charEnd = chars + charCount;
// Since left over char was a surrogate, it'll have to be fallen back.
// Get Fallback
// This will fallback a pair if *chars is a low surrogate
- fallbackBuffer.InternalFallback(charLeftOver, ref chars);
+ charsForFallback = chars; // Avoid passing chars by reference to allow it to be enregistered
+ fallbackBuffer.InternalFallback(charLeftOver, ref charsForFallback);
+ chars = charsForFallback;
}
// Now we may have fallback char[] already from the encoder
}
// Get Fallback
- fallbackBuffer.InternalFallback(ch, ref chars);
+ charsForFallback = chars; // Avoid passing chars by reference to allow it to be enregistered
+ fallbackBuffer.InternalFallback(ch, ref charsForFallback);
+ chars = charsForFallback;
// Go ahead & continue (& do the fallback)
continue;
// Only need decoder fallback buffer if not using ? fallback.
// ASCII doesn't do best fit, so don't have to check for it, find out which decoder fallback we're using
DecoderReplacementFallback fallback = null;
+ char* charsForFallback;
if (decoder == null)
fallback = this.DecoderFallback as DecoderReplacementFallback;
byteBuffer[0] = b;
// Note that chars won't get updated unless this succeeds
- if (!fallbackBuffer.InternalFallback(byteBuffer, bytes, ref chars))
+ charsForFallback = chars; // Avoid passing chars by reference to allow it to be enregistered
+ bool fallbackResult = fallbackBuffer.InternalFallback(byteBuffer, bytes, ref charsForFallback);
+ chars = charsForFallback;
+
+ if (!fallbackResult)
{
// May or may not throw, but we didn't get this byte
Debug.Assert(bytes > byteStart || chars == charStart,
// For fallback we may need a fallback buffer, we know we aren't default fallback.
EncoderFallbackBuffer fallbackBuffer = null;
+ char* charsForFallback;
// We may have a left over character from last time, try and process it.
if (charLeftOver > 0)
// Since left over char was a surrogate, it'll have to be fallen back.
// Get Fallback
// This will fallback a pair if *chars is a low surrogate
- fallbackBuffer.InternalFallback(charLeftOver, ref chars);
+ charsForFallback = chars;
+ fallbackBuffer.InternalFallback(charLeftOver, ref charsForFallback);
+ chars = charsForFallback;
}
// Now we may have fallback char[] already from the encoder
}
// Get Fallback
- fallbackBuffer.InternalFallback(ch, ref chars);
+ charsForFallback = chars;
+ fallbackBuffer.InternalFallback(ch, ref charsForFallback);
+ chars = charsForFallback;
continue;
}
// For fallback we may need a fallback buffer, we know we aren't default fallback, create & init it
EncoderFallbackBuffer fallbackBuffer = null;
+ char* charsForFallback;
// We may have a left over character from last time, try and process it.
if (charLeftOver > 0)
// Since left over char was a surrogate, it'll have to be fallen back.
// Get Fallback
// This will fallback a pair if *chars is a low surrogate
- fallbackBuffer.InternalFallback(charLeftOver, ref chars);
+ charsForFallback = chars;
+ fallbackBuffer.InternalFallback(charLeftOver, ref charsForFallback);
+ chars = charsForFallback;
+
if (fallbackBuffer.Remaining > byteEnd - bytes)
{
// Throw it, if we don't have enough for this we never will
}
// Get Fallback
- fallbackBuffer.InternalFallback(ch, ref chars);
+ charsForFallback = chars;
+ fallbackBuffer.InternalFallback(ch, ref charsForFallback);
+ chars = charsForFallback;
// Make sure we have enough room. Each fallback char will be 1 output char
// (or else cause a recursion exception)
// For fallback we may need a fallback buffer
EncoderFallbackBuffer fallbackBuffer = null;
+ char* charsForFallback;
+
if (encoder != null)
{
highSurrogate = encoder.charLeftOver;
chars--;
// Do the fallback
- fallbackBuffer.InternalFallback(highSurrogate, ref chars);
+ charsForFallback = chars;
+ fallbackBuffer.InternalFallback(highSurrogate, ref charsForFallback);
+ chars = charsForFallback;
// We're going to fallback the old high surrogate.
highSurrogate = '\0';
if (Char.IsLowSurrogate(ch))
{
// We have a leading low surrogate, do the fallback
- fallbackBuffer.InternalFallback(ch, ref chars);
+ charsForFallback = chars;
+ fallbackBuffer.InternalFallback(ch, ref charsForFallback);
+ chars = charsForFallback;
// Try again with fallback buffer
continue;
if ((encoder == null || encoder.MustFlush) && highSurrogate > 0)
{
// We have to do the fallback for the lonely high surrogate
- fallbackBuffer.InternalFallback(highSurrogate, ref chars);
+ charsForFallback = chars;
+ fallbackBuffer.InternalFallback(highSurrogate, ref charsForFallback);
+ chars = charsForFallback;
+
highSurrogate = (char)0;
goto TryAgain;
}
// For fallback we may need a fallback buffer
EncoderFallbackBuffer fallbackBuffer = null;
+ char* charsForFallback;
+
if (encoder != null)
{
highSurrogate = encoder.charLeftOver;
chars--;
// Do the fallback
- fallbackBuffer.InternalFallback(highSurrogate, ref chars);
+ charsForFallback = chars;
+ fallbackBuffer.InternalFallback(highSurrogate, ref charsForFallback);
+ chars = charsForFallback;
// We're going to fallback the old high surrogate.
highSurrogate = '\0';
if (Char.IsLowSurrogate(ch))
{
// We have a leading low surrogate, do the fallback
- fallbackBuffer.InternalFallback(ch, ref chars);
+ charsForFallback = chars;
+ fallbackBuffer.InternalFallback(ch, ref charsForFallback);
+ chars = charsForFallback;
// Try again with fallback buffer
continue;
if ((encoder == null || encoder.MustFlush) && highSurrogate > 0)
{
// We have to do the fallback for the lonely high surrogate
- fallbackBuffer.InternalFallback(highSurrogate, ref chars);
+ charsForFallback = chars;
+ fallbackBuffer.InternalFallback(highSurrogate, ref charsForFallback);
+ chars = charsForFallback;
+
highSurrogate = (char)0;
goto TryAgain;
}
// For fallback we may need a fallback buffer
DecoderFallbackBuffer fallbackBuffer = null;
+ char* charsForFallback;
// See if there's anything in our decoder
if (decoder != null)
}
// Chars won't be updated unless this works.
- if (!fallbackBuffer.InternalFallback(fallbackBytes, bytes, ref chars))
+ charsForFallback = chars;
+ bool fallbackResult = fallbackBuffer.InternalFallback(fallbackBytes, bytes, ref charsForFallback);
+ chars = charsForFallback;
+
+ if (!fallbackResult)
{
+
// Couldn't fallback, throw or wait til next time
// We either read enough bytes for bytes-=4 to work, or we're
// going to throw in ThrowCharsOverflow because chars == charStart
}
}
- if (!fallbackBuffer.InternalFallback(fallbackBytes, bytes, ref chars))
+ charsForFallback = chars;
+ bool fallbackResult = fallbackBuffer.InternalFallback(fallbackBytes, bytes, ref charsForFallback);
+ chars = charsForFallback;
+
+ if (!fallbackResult)
{
// Couldn't fallback.
fallbackBuffer.InternalReset();
// For fallback we may need a fallback buffer.
// We wait to initialize it though in case we don't have any broken input unicode
EncoderFallbackBuffer fallbackBuffer = null;
+ char* pSrcForFallback;
+
char* pSrc = chars;
char* pEnd = pSrc + count;
// Do our fallback. Actually we already know its a mixed up surrogate,
// so the ref pSrc isn't gonna do anything.
- fallbackBuffer.InternalFallback(unchecked((char)ch), ref pSrc);
+ pSrcForFallback = pSrc; // Avoid passing pSrc by reference to allow it to be enregistered
+ fallbackBuffer.InternalFallback(unchecked((char)ch), ref pSrcForFallback);
+ pSrc = pSrcForFallback;
// Ignore it if we don't throw (we had preallocated this ch)
byteCount--;
// For fallback we may need a fallback buffer.
// We wait to initialize it though in case we don't have any broken input unicode
EncoderFallbackBuffer fallbackBuffer = null;
+ char* pSrcForFallback;
+
char* pSrc = chars;
byte* pTarget = bytes;
// Do our fallback. Actually we already know its a mixed up surrogate,
// so the ref pSrc isn't gonna do anything.
- fallbackBuffer.InternalFallback(unchecked((char)ch), ref pSrc);
+ pSrcForFallback = pSrc; // Avoid passing pSrc by reference to allow it to be enregistered
+ fallbackBuffer.InternalFallback(unchecked((char)ch), ref pSrcForFallback);
+ pSrc = pSrcForFallback;
// Ignore it if we don't throw
ch = 0;
int ch = 0;
DecoderFallbackBuffer fallback = null;
+ byte* pSrcForFallback;
+ char* pTargetForFallback;
if (baseDecoder != null)
{
UTF8Decoder decoder = (UTF8Decoder)baseDecoder;
fallback.InternalInitialize(bytes, pAllocatedBufferEnd);
}
// This'll back us up the appropriate # of bytes if we didn't get anywhere
- if (!FallbackInvalidByteSequence(ref pSrc, ch, fallback, ref pTarget))
+ pSrcForFallback = pSrc; // Avoid passing pSrc by reference to allow it to be enregistered
+ pTargetForFallback = pTarget; // Avoid passing pTarget by reference to allow it to be enregistered
+ bool fallbackResult = FallbackInvalidByteSequence(ref pSrcForFallback, ch, fallback, ref pTargetForFallback);
+ pSrc = pSrcForFallback;
+ pTarget = pTargetForFallback;
+
+ if (!fallbackResult)
{
// Ran out of buffer space
// Need to throw an exception?
}
// This'll back us up the appropriate # of bytes if we didn't get anywhere
- if (!FallbackInvalidByteSequence(ref pSrc, ch, fallback, ref pTarget))
+ pSrcForFallback = pSrc; // Avoid passing pSrc by reference to allow it to be enregistered
+ pTargetForFallback = pTarget; // Avoid passing pTarget by reference to allow it to be enregistered
+ bool fallbackResult = FallbackInvalidByteSequence(ref pSrcForFallback, ch, fallback, ref pTargetForFallback);
+ pSrc = pSrcForFallback;
+ pTarget = pTargetForFallback;
+
+ if (!fallbackResult)
{
Debug.Assert(pSrc >= bytes || pTarget == chars,
"[UTF8Encoding.GetChars]Expected to throw or remain in byte buffer while flushing");
// For fallback we may need a fallback buffer
EncoderFallbackBuffer fallbackBuffer = null;
+ char* charsForFallback;
if (encoder != null)
{
fallbackBuffer.InternalInitialize(charStart, charEnd, encoder, false);
}
- fallbackBuffer.InternalFallback(charLeftOver, ref chars);
+ charsForFallback = chars; // Avoid passing chars by reference to allow it to be enregistered
+ fallbackBuffer.InternalFallback(charLeftOver, ref charsForFallback);
+ chars = charsForFallback;
// Now no high surrogate left over
charLeftOver = (char)0;
// Set our internal fallback interesting things.
fallbackBuffer.InternalInitialize(charStart, charEnd, encoder, false);
}
- fallbackBuffer.InternalFallback(ch, ref chars);
+ charsForFallback = chars; // Avoid passing chars by reference to allow it to be enregistered
+ fallbackBuffer.InternalFallback(ch, ref charsForFallback);
+ chars = charsForFallback;
continue;
}
// Set our internal fallback interesting things.
fallbackBuffer.InternalInitialize(charStart, charEnd, encoder, false);
}
- fallbackBuffer.InternalFallback(charLeftOver, ref chars);
+ charsForFallback = chars; // Avoid passing chars by reference to allow it to be enregistered
+ fallbackBuffer.InternalFallback(charLeftOver, ref charsForFallback);
+ chars = charsForFallback;
// Ignore charLeftOver or throw
byteCount -= 2;
// Set our internal fallback interesting things.
fallbackBuffer.InternalInitialize(charStart, charEnd, encoder, false);
}
- fallbackBuffer.InternalFallback(charLeftOver, ref chars);
+ charsForFallback = chars; // Avoid passing chars by reference to allow it to be enregistered
+ fallbackBuffer.InternalFallback(charLeftOver, ref charsForFallback);
+ chars = charsForFallback;
charLeftOver = (char)0;
wasHereBefore = true;
goto TryAgain;
// For fallback we may need a fallback buffer
EncoderFallbackBuffer fallbackBuffer = null;
+ char* charsForFallback;
// Get our encoder, but don't clear it yet.
if (encoder != null)
fallbackBuffer.InternalInitialize(charStart, charEnd, encoder, true);
}
- fallbackBuffer.InternalFallback(charLeftOver, ref chars);
+ charsForFallback = chars; // Avoid passing chars by reference to allow it to be enregistered
+ fallbackBuffer.InternalFallback(charLeftOver, ref charsForFallback);
+ chars = charsForFallback;
charLeftOver = (char)0;
continue;
fallbackBuffer.InternalInitialize(charStart, charEnd, encoder, true);
}
- fallbackBuffer.InternalFallback(ch, ref chars);
+ charsForFallback = chars; // Avoid passing chars by reference to allow it to be enregistered
+ fallbackBuffer.InternalFallback(ch, ref charsForFallback);
+ chars = charsForFallback;
continue;
}
fallbackBuffer.InternalInitialize(charStart, charEnd, encoder, true);
}
- fallbackBuffer.InternalFallback(charLeftOver, ref chars);
+ charsForFallback = chars; // Avoid passing chars by reference to allow it to be enregistered
+ fallbackBuffer.InternalFallback(charLeftOver, ref charsForFallback);
+ chars = charsForFallback;
// Ignore charLeftOver or throw
charLeftOver = (char)0;
}
// If we're not flushing, this'll remember the left over character.
- fallbackBuffer.InternalFallback(charLeftOver, ref chars);
+ charsForFallback = chars; // Avoid passing chars by reference to allow it to be enregistered
+ fallbackBuffer.InternalFallback(charLeftOver, ref charsForFallback);
+ chars = charsForFallback;
charLeftOver = (char)0;
wasHereBefore = true;
// For fallback we may need a fallback buffer
DecoderFallbackBuffer fallbackBuffer = null;
+ char* charsForFallback;
byte* byteEnd = bytes + byteCount;
char* charEnd = chars + charCount;
fallbackBuffer.InternalInitialize(byteStart, charEnd);
}
- if (!fallbackBuffer.InternalFallback(byteBuffer, bytes, ref chars))
+ charsForFallback = chars; // Avoid passing chars by reference to allow it to be enregistered
+ bool fallbackResult = fallbackBuffer.InternalFallback(byteBuffer, bytes, ref charsForFallback);
+ chars = charsForFallback;
+
+ if (!fallbackResult)
{
// couldn't fall back lonely surrogate
// We either advanced bytes or chars should == charStart and throw below
fallbackBuffer.InternalInitialize(byteStart, charEnd);
}
- if (!fallbackBuffer.InternalFallback(byteBuffer, bytes, ref chars))
+ charsForFallback = chars; // Avoid passing chars by reference to allow it to be enregistered
+ bool fallbackResult = fallbackBuffer.InternalFallback(byteBuffer, bytes, ref charsForFallback);
+ chars = charsForFallback;
+
+ if (!fallbackResult)
{
// couldn't fall back lonely surrogate
// We either advanced bytes or chars should == charStart and throw below
fallbackBuffer.InternalInitialize(byteStart, charEnd);
}
- if (!fallbackBuffer.InternalFallback(byteBuffer, bytes, ref chars))
+ charsForFallback = chars; // Avoid passing chars by reference to allow it to be enregistered
+ bool fallbackResult = fallbackBuffer.InternalFallback(byteBuffer, bytes, ref charsForFallback);
+ chars = charsForFallback;
+
+ if (!fallbackResult)
{
// couldn't fall back high surrogate, or char that would be next
// We either advanced bytes or chars should == charStart and throw below
fallbackBuffer.InternalInitialize(byteStart, charEnd);
}
- if (!fallbackBuffer.InternalFallback(byteBuffer, bytes, ref chars))
+ charsForFallback = chars; // Avoid passing chars by reference to allow it to be enregistered
+ bool fallbackResult = fallbackBuffer.InternalFallback(byteBuffer, bytes, ref charsForFallback);
+ chars = charsForFallback;
+
+ if (!fallbackResult)
{
// 2 bytes couldn't fall back
// We either advanced bytes or chars should == charStart and throw below
}
// No hanging odd bytes allowed if must flush
- if (!fallbackBuffer.InternalFallback(new byte[] { unchecked((byte)lastByte) }, bytes, ref chars))
+ charsForFallback = chars; // Avoid passing chars by reference to allow it to be enregistered
+ bool fallbackResult = fallbackBuffer.InternalFallback(new byte[] { unchecked((byte)lastByte) }, bytes, ref charsForFallback);
+ chars = charsForFallback;
+
+ if (!fallbackResult)
{
// odd byte couldn't fall back
bytes--; // didn't use this byte
projects / platform / upstream / dotnet / runtime.git / commitdiff