Lines Matching refs:state
63 public static int ParseLength(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
65 return (int)ParseRawVarint32(ref buffer, ref state);
72 public static uint ParseTag(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
77 if (state.hasNextTag)
79 state.lastTag = state.nextTag;
80 state.hasNextTag = false;
81 return state.lastTag;
86 if (state.bufferPos + 2 <= state.bufferSize)
88 int tmp = buffer[state.bufferPos++];
91 state.lastTag = (uint)tmp;
96 if ((tmp = buffer[state.bufferPos++]) < 128)
99 state.lastTag = (uint) result;
104 state.bufferPos -= 2;
105 state.lastTag = ParsingPrimitives.ParseRawVarint32(ref buffer, ref state);
111 if (SegmentedBufferHelper.IsAtEnd(ref buffer, ref state))
113 state.lastTag = 0;
117 state.lastTag = ParsingPrimitives.ParseRawVarint32(ref buffer, ref state);
119 if (WireFormat.GetTagFieldNumber(state.lastTag) == 0)
124 return state.lastTag;
132 public static bool MaybeConsumeTag(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, uint tag)
134 if (PeekTag(ref buffer, ref state) == tag)
136 state.hasNextTag = false;
147 public static uint PeekTag(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
149 if (state.hasNextTag)
151 return state.nextTag;
154 uint savedLast = state.lastTag;
155 state.nextTag = ParseTag(ref buffer, ref state);
156 state.hasNextTag = true;
157 state.lastTag = savedLast; // Undo the side effect of ReadTag
158 return state.nextTag;
164 public static ulong ParseRawVarint64(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
166 if (state.bufferPos + 10 > state.bufferSize)
168 return ParseRawVarint64SlowPath(ref buffer, ref state);
171 ulong result = buffer[state.bufferPos++];
180 byte b = buffer[state.bufferPos++];
193 private static ulong ParseRawVarint64SlowPath(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
199 byte b = ReadRawByte(ref buffer, ref state);
218 public static uint ParseRawVarint32(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
220 if (state.bufferPos + 5 > state.bufferSize)
222 return ParseRawVarint32SlowPath(ref buffer, ref state);
225 int tmp = buffer[state.bufferPos++];
231 if ((tmp = buffer[state.bufferPos++]) < 128)
238 if ((tmp = buffer[state.bufferPos++]) < 128)
245 if ((tmp = buffer[state.bufferPos++]) < 128)
252 result |= (tmp = buffer[state.bufferPos++]) << 28;
261 if (ReadRawByte(ref buffer, ref state) < 128)
274 private static uint ParseRawVarint32SlowPath(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
276 int tmp = ReadRawByte(ref buffer, ref state);
282 if ((tmp = ReadRawByte(ref buffer, ref state)) < 128)
289 if ((tmp = ReadRawByte(ref buffer, ref state)) < 128)
296 if ((tmp = ReadRawByte(ref buffer, ref state)) < 128)
303 result |= (tmp = ReadRawByte(ref buffer, ref state)) << 28;
309 if (ReadRawByte(ref buffer, ref state) < 128)
325 public static uint ParseRawLittleEndian32(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
329 if (state.bufferPos + ulongLength > state.bufferSize)
331 return ParseRawLittleEndian32SlowPath(ref buffer, ref state);
335 uint result = (uint) BinaryPrimitives.ReadUInt64LittleEndian(buffer.Slice(state.bufferPos, ulongLength));
336 state.bufferPos += uintLength;
340 private static uint ParseRawLittleEndian32SlowPath(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
342 uint b1 = ReadRawByte(ref buffer, ref state);
343 uint b2 = ReadRawByte(ref buffer, ref state);
344 uint b3 = ReadRawByte(ref buffer, ref state);
345 uint b4 = ReadRawByte(ref buffer, ref state);
352 public static ulong ParseRawLittleEndian64(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
355 if (state.bufferPos + length > state.bufferSize)
357 return ParseRawLittleEndian64SlowPath(ref buffer, ref state);
359 ulong result = BinaryPrimitives.ReadUInt64LittleEndian(buffer.Slice(state.bufferPos, length));
360 state.bufferPos += length;
364 private static ulong ParseRawLittleEndian64SlowPath(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
366 ulong b1 = ReadRawByte(ref buffer, ref state);
367 ulong b2 = ReadRawByte(ref buffer, ref state);
368 ulong b3 = ReadRawByte(ref buffer, ref state);
369 ulong b4 = ReadRawByte(ref buffer, ref state);
370 ulong b5 = ReadRawByte(ref buffer, ref state);
371 ulong b6 = ReadRawByte(ref buffer, ref state);
372 ulong b7 = ReadRawByte(ref buffer, ref state);
373 ulong b8 = ReadRawByte(ref buffer, ref state);
381 public static double ParseDouble(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
384 if (!BitConverter.IsLittleEndian || state.bufferPos + length > state.bufferSize)
386 return BitConverter.Int64BitsToDouble((long)ParseRawLittleEndian64(ref buffer, ref state));
389 double result = Unsafe.ReadUnaligned<double>(ref MemoryMarshal.GetReference(buffer.Slice(state.bufferPos, length)));
390 state.bufferPos += length;
397 public static float ParseFloat(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
400 if (!BitConverter.IsLittleEndian || state.bufferPos + length > state.bufferSize)
402 return ParseFloatSlow(ref buffer, ref state);
405 float result = Unsafe.ReadUnaligned<float>(ref MemoryMarshal.GetReference(buffer.Slice(state.bufferPos, length)));
406 state.bufferPos += length;
410 private static unsafe float ParseFloatSlow(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
417 tempSpan[i] = ReadRawByte(ref buffer, ref state);
434 public static byte[] ReadRawBytes(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int size)
441 if (size <= state.bufferSize - state.bufferPos)
445 buffer.Slice(state.bufferPos, size).CopyTo(bytes);
446 state.bufferPos += size;
450 return ReadRawBytesSlow(ref buffer, ref state, size);
453 private static byte[] ReadRawBytesSlow(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int size)
455 ValidateCurrentLimit(ref buffer, ref state, size);
457 if ((!state.segmentedBufferHelper.TotalLength.HasValue && size < buffer.Length) ||
458 IsDataAvailableInSource(ref state, size))
464 ReadRawBytesIntoSpan(ref buffer, ref state, size, bytes);
479 int pos = state.bufferSize - state.bufferPos;
481 buffer.Slice(state.bufferPos, pos).CopyTo(firstChunk);
483 state.bufferPos = state.bufferSize;
489 state.segmentedBufferHelper.RefillBuffer(ref buffer, ref state, true);
490 byte[] chunk = new byte[Math.Min(sizeLeft, state.bufferSize)];
494 state.bufferPos += chunk.Length;
518 public static void SkipRawBytes(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int size)
525 ValidateCurrentLimit(ref buffer, ref state, size);
527 if (size <= state.bufferSize - state.bufferPos)
530 state.bufferPos += size;
535 int pos = state.bufferSize - state.bufferPos;
536 state.bufferPos = state.bufferSize;
541 state.segmentedBufferHelper.RefillBuffer(ref buffer, ref state, true);
543 while (size - pos > state.bufferSize)
545 pos += state.bufferSize;
546 state.bufferPos = state.bufferSize;
547 state.segmentedBufferHelper.RefillBuffer(ref buffer, ref state, true);
550 state.bufferPos = size - pos;
558 public static string ReadString(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
560 int length = ParsingPrimitives.ParseLength(ref buffer, ref state);
561 return ParsingPrimitives.ReadRawString(ref buffer, ref state, length);
568 public static ByteString ReadBytes(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
570 int length = ParsingPrimitives.ParseLength(ref buffer, ref state);
571 return ByteString.AttachBytes(ParsingPrimitives.ReadRawBytes(ref buffer, ref state, length));
581 public static string ReadRawString(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int length)
595 if (length <= state.bufferSize - state.bufferPos)
598 ReadOnlySpan<byte> data = buffer.Slice(state.bufferPos, length);
609 state.bufferPos += length;
614 return ReadStringSlow(ref buffer, ref state, length);
620 private static string ReadStringSlow(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int length)
622 ValidateCurrentLimit(ref buffer, ref state, length);
625 if (IsDataAvailable(ref state, length))
646 ReadRawBytesIntoSpan(ref buffer, ref state, length, tempSpan);
666 return WritingPrimitives.Utf8Encoding.GetString(ReadRawBytes(ref buffer, ref state, length), 0, length);
673 private static void ValidateCurrentLimit(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int size)
675 if (state.totalBytesRetired + state.bufferPos + size > state.currentLimit)
678 SkipRawBytes(ref buffer, ref state, state.currentLimit - state.totalBytesRetired - state.bufferPos);
685 private static byte ReadRawByte(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
687 if (state.bufferPos == state.bufferSize)
689 state.segmentedBufferHelper.RefillBuffer(ref buffer, ref state, true);
691 return buffer[state.bufferPos++];
769 public static bool IsDataAvailable(ref ParserInternalState state, int size)
772 if (size <= state.bufferSize - state.bufferPos)
777 return IsDataAvailableInSource(ref state, size);
786 private static bool IsDataAvailableInSource(ref ParserInternalState state, int size)
790 return size <= state.segmentedBufferHelper.TotalLength - state.totalBytesRetired - state.bufferPos;
797 private static void ReadRawBytesIntoSpan(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int length, Span<byte> byteSpan)
802 if (state.bufferSize - state.bufferPos == 0)
804 state.segmentedBufferHelper.RefillBuffer(ref buffer, ref state, true);
807 ReadOnlySpan<byte> unreadSpan = buffer.Slice(state.bufferPos, Math.Min(remainingByteLength, state.bufferSize - state.bufferPos));
811 state.bufferPos += unreadSpan.Length;