private void AppendRawBytes(MutableString /*!*/ buffer, int count) { Debug.Assert(count > 0); int remaining = count; if (_bufferCount > 0) { int c = Math.Min(_bufferCount, count); buffer.Append(_buffer, _bufferStart, c); ConsumeBuffered(c); remaining -= c; } if (count == Int32.MaxValue) { const int chunk = 1024; int done = buffer.GetByteCount(); int bytesRead; do { buffer.Append(_stream, chunk); bytesRead = buffer.GetByteCount() - done; done += bytesRead; } while (bytesRead == chunk); } else { buffer.Append(_stream, remaining); } }
public override int Read(byte[] /*!*/ buffer, int offset, int count) { int maxReadLen = _string.GetByteCount() - _position; if (count > maxReadLen) { count = maxReadLen; } for (int i = 0; i < count; i++) { buffer[offset + i] = _string.GetByte(_position++); } return(count); }
public MutableString ReadLine(MutableString /*!*/ separator, RubyEncoding /*!*/ encoding, bool preserveEndOfLines) { int b = ReadByteNormalizeEoln(preserveEndOfLines); if (b == -1) { return(null); } int separatorOffset = 0; int separatorLength = separator.GetByteCount(); MutableString result = MutableString.CreateBinary(encoding); do { result.Append((byte)b); if (b == separator.GetByte(separatorOffset)) { if (separatorOffset == separatorLength - 1) { break; } separatorOffset++; } else if (separatorOffset > 0) { separatorOffset = 0; } b = ReadByteNormalizeEoln(preserveEndOfLines); } while (b != -1); return(result); }
public static int Write(RubyIO /*!*/ self, [NotNull] MutableString /*!*/ val) { int bytesWritten = val.IsEmpty ? 0 : self.WriteBytes(val, 0, val.GetByteCount()); if (self.AutoFlush) { self.Flush(); } return(bytesWritten); }
private static void FromHex(BinaryWriter /*!*/ writer, MutableString /*!*/ str, int nibbleCount, bool swap) { int maxCount = Math.Min(nibbleCount, str.GetByteCount()); for (int i = 0, j = 0; i < (nibbleCount + 1) / 2; i++, j += 2) { int hiNibble = (j < maxCount) ? FromHexDigit(str.GetByte(j)) : 0; int loNibble = (j + 1 < maxCount) ? FromHexDigit(str.GetByte(j + 1)) : 0; Debug.Assert(hiNibble >= 0 && hiNibble < 16 && loNibble >= 0 && loNibble < 16); int c = (swap) ? (loNibble << 4) | hiNibble : (hiNibble << 4) | loNibble; writer.Write((byte)c); } }
private static string /*!*/ ForceEncoding(MutableString /*!*/ input, Encoding /*!*/ encoding, int start) { int byteCount = input.GetByteCount(); if (start < 0) { start += byteCount; } if (start < 0) { return(null); } return((start <= byteCount) ? input.ToString(encoding, start, byteCount - start) : null); }
/// <summary> /// Searches the pattern for hexadecimal and octal character escapes that represent a non-ASCII character. /// </summary> private static bool HasEscapedNonAsciiBytes(MutableString /*!*/ pattern) { int i = 0; int length = pattern.GetByteCount(); while (i < length - 2) { int c = pattern.GetByte(i++); if (c == '\\') { c = pattern.GetByte(i++); if (c == 'x') { // hexa escape: int d1 = Tokenizer.ToDigit(PeekByte(pattern, length, i++)); if (d1 < 16) { int d2 = Tokenizer.ToDigit(PeekByte(pattern, length, i++)); if (d2 < 16) { return(d1 * 16 + d2 >= 0x80); } } } else if (c >= '2' && c <= '7') { // a backreference (\1..\9) or an octal escape: int d = Tokenizer.ToDigit(PeekByte(pattern, length, i++)); if (d < 8) { int value = Tokenizer.ToDigit(c) * 8 + d; d = Tokenizer.ToDigit(PeekByte(pattern, length, i++)); if (d < 8) { value = value * 8 + d; } return(value >= 0x80); } } } } return(false); }
public int GetByteCount() { return(_string.GetByteCount()); }
/// <summary> /// Reads <paramref name="count"/> bytes from the stream and appends them to the given <paramref name="buffer"/>. /// If <paramref name="count"/> is <c>Int32.MaxValue</c> the stream is read to the end. /// Unless <paramref name="preserveEndOfLines"/> is set the line endings in the appended data are normalized to "\n". /// </summary> public int AppendBytes(MutableString /*!*/ buffer, int count, bool preserveEndOfLines) { ContractUtils.RequiresNotNull(buffer, "buffer"); ContractUtils.Requires(count >= 0, "count"); if (count == 0) { return(0); } bool readAll = count == Int32.MaxValue; buffer.SwitchToBytes(); int initialBufferSize = buffer.GetByteCount(); if (preserveEndOfLines) { AppendRawBytes(buffer, count); } else { // allocate 3 more bytes at the end for a backstop and possible LF: byte[] bytes = Utils.EmptyBytes; int done = initialBufferSize; bool eof; do { AppendRawBytes(buffer, readAll ? 1024 : count); int end = buffer.GetByteCount(); int bytesRead = end - done; if (bytesRead == 0) { break; } eof = bytesRead < count; buffer.EnsureCapacity(end + 3); int byteCount; bytes = buffer.GetByteArray(out byteCount); if (bytes[end - 1] == CR && PeekByte(0) == LF) { ReadByte(); bytes[end++] = LF; } // insert backstop: bytes[end] = CR; bytes[end + 1] = LF; int last = IndexOfCrLf(bytes, done); count -= last - done; done = last; while (last < end) { int next = IndexOfCrLf(bytes, last + 2); int chunk = next - last - 1; Buffer.BlockCopy(bytes, last + 1, bytes, done, chunk); done += chunk; count -= chunk; last = next; } buffer.Remove(done); } while (readAll || count > 0 && !eof); } if (readAll) { buffer.TrimExcess(); } return(buffer.GetByteCount() - initialBufferSize); }