//
// Author:
// Matt Kimball (matt@kimball.net)
+// Dick Porter (dick@ximian.com)
+//
+
+//
+// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Text;
+using System.Globalization;
+using Mono.Security;
namespace System.IO {
public class BinaryReader : IDisposable {
int m_encoding_max_byte;
byte[] m_buffer;
- int m_buffer_used;
- int m_buffer_pos;
+ Decoder decoder;
+ char [] charBuffer;
+
+ //
+ // 128 chars should cover most strings in one grab.
+ //
+ const int MaxBufferSize = 128;
+
+
+ private bool m_disposed = false;
- public BinaryReader(Stream input) : this(input, Encoding.UTF8) {
+ public BinaryReader(Stream input) : this(input, Encoding.UTF8Unmarked) {
}
public BinaryReader(Stream input, Encoding encoding) {
if (input == null || encoding == null)
- throw new ArgumentNullException();
+ throw new ArgumentNullException(Locale.GetText ("Input or Encoding is a null reference."));
if (!input.CanRead)
- throw new ArgumentException();
+ throw new ArgumentException(Locale.GetText ("The stream doesn't support reading."));
m_stream = input;
- m_encoding = Encoding.UTF8;
- m_encoding_max_byte = m_encoding.GetMaxByteCount(1);
+ m_encoding = encoding;
+ decoder = encoding.GetDecoder ();
+ m_buffer = new byte [32];
}
public virtual Stream BaseStream {
}
public virtual void Close() {
- Dispose();
- m_stream.Close();
+ Dispose (true);
+ m_disposed = true;
}
+
+ protected virtual void Dispose (bool disposing)
+ {
+ if (disposing && m_stream != null)
+ m_stream.Close ();
- public virtual void Dispose() {
+ m_disposed = true;
m_buffer = null;
- m_buffer_used = 0;
+ m_encoding = null;
+ m_stream = null;
+ charBuffer = null;
}
- protected virtual void FillBuffer(int bytes) {
- if (!EnsureBuffered(m_buffer_used - m_buffer_pos + bytes)) {
- throw new EndOfStreamException();
- }
+ void IDisposable.Dispose()
+ {
+ Dispose (true);
}
- public virtual int PeekChar() {
- EnsureBuffered(m_encoding_max_byte);
+ protected virtual void FillBuffer (int bytes)
+ {
+ if (m_disposed)
+ throw new ObjectDisposedException ("BinaryReader", "Cannot read from a closed BinaryReader.");
+ if (m_stream==null)
+ throw new IOException("Stream is invalid");
- int i;
- for (i = 1; m_encoding.GetCharCount(m_buffer, m_buffer_pos, i) == 0; i++) {
- if (m_buffer_pos + i >= m_buffer_used) {
- return -1;
+ CheckBuffer(bytes);
+
+ /* Cope with partial reads */
+ int pos=0;
+
+ while(pos<bytes) {
+ int n=m_stream.Read(m_buffer, pos, bytes-pos);
+ if(n==0) {
+ throw new EndOfStreamException();
}
+
+ pos+=n;
}
+ }
- char[] decode = m_encoding.GetChars(m_buffer, m_buffer_pos, i);
- return decode[0];
+ public virtual int PeekChar() {
+ if(m_stream==null) {
+
+ if (m_disposed)
+ throw new ObjectDisposedException ("BinaryReader", "Cannot read from a closed BinaryReader.");
+
+ throw new IOException("Stream is invalid");
+ }
+
+ if ( !m_stream.CanSeek )
+ {
+ return -1;
+ }
+
+ char[] result = new char[1];
+ byte[] bytes;
+ int bcount;
+
+ int ccount = ReadCharBytes (result, 0, 1, out bytes, out bcount);
+
+ // Reposition the stream
+ m_stream.Position -= bcount;
+
+ // If we read 0 characters then return -1
+ if (ccount == 0)
+ {
+ return -1;
+ }
+
+ // Return the single character we read
+ return result[0];
}
public virtual int Read() {
char[] decode = new char[1];
- Read(decode, 0, 1);
+ int count=Read(decode, 0, 1);
+ if(count==0) {
+ /* No chars available */
+ return(-1);
+ }
+
return decode[0];
}
public virtual int Read(byte[] buffer, int index, int count) {
+ if(m_stream==null) {
+
+ if (m_disposed)
+ throw new ObjectDisposedException ("BinaryReader", "Cannot read from a closed BinaryReader.");
+
+ throw new IOException("Stream is invalid");
+ }
+
if (buffer == null) {
- throw new ArgumentNullException();
+ throw new ArgumentNullException("buffer is null");
}
- if (buffer.Length - index < count) {
- throw new ArgumentException();
+ if (index < 0) {
+ throw new ArgumentOutOfRangeException("index is less than 0");
}
- if (index < 0 || count < 0) {
- throw new ArgumentOutOfRangeException();
+ if (count < 0) {
+ throw new ArgumentOutOfRangeException("count is less than 0");
}
-
- EnsureBuffered(count);
-
- if (m_buffer_used - m_buffer_pos < count) {
- count = m_buffer_used - m_buffer_pos;
+ if (buffer.Length - index < count) {
+ throw new ArgumentException("buffer is too small");
}
- Array.Copy(m_buffer, m_buffer_pos, buffer, index, count);
+ int bytes_read=m_stream.Read(buffer, index, count);
- ConsumeBuffered(count);
- return count;
+ return(bytes_read);
}
public virtual int Read(char[] buffer, int index, int count) {
+
+ if(m_stream==null) {
+
+ if (m_disposed)
+ throw new ObjectDisposedException ("BinaryReader", "Cannot read from a closed BinaryReader.");
+
+ throw new IOException("Stream is invalid");
+ }
+
if (buffer == null) {
- throw new ArgumentNullException();
+ throw new ArgumentNullException("buffer is null");
}
- if (buffer.Length - index < count) {
- throw new ArgumentException();
+ if (index < 0) {
+ throw new ArgumentOutOfRangeException("index is less than 0");
}
- if (index < 0 || count < 0) {
- throw new ArgumentOutOfRangeException();
+ if (count < 0) {
+ throw new ArgumentOutOfRangeException("count is less than 0");
+ }
+ if (buffer.Length - index < count) {
+ throw new ArgumentException("buffer is too small");
}
- EnsureBuffered(m_encoding_max_byte * count);
+ int bytes_read;
+ byte[] bytes;
+ return ReadCharBytes (buffer, index, count, out bytes, out bytes_read);
+ }
- int i;
- for (i = 1; m_encoding.GetCharCount(m_buffer, m_buffer_pos, i) < count; i++) {
- if (m_buffer_pos + i >= m_buffer_used) {
- break;
- }
- }
+ private int ReadCharBytes(char[] buffer, int index, int count, out byte[] bytes, out int bytes_read) \r
+ {
+ int chars_read=0;
+ bytes_read=0;
- count = m_encoding.GetCharCount(m_buffer, m_buffer_pos, i);
+ while(chars_read < count)
+ {
+ CheckBuffer(bytes_read + 1);
+
+ int read_byte = m_stream.ReadByte();
+
+ if(read_byte==-1)
+ {
+ /* EOF */
+ bytes = m_buffer;
+ return(chars_read);
+ }
- char[] dec = m_encoding.GetChars(m_buffer, m_buffer_pos, i);
- Array.Copy(dec, 0, buffer, index, count);
+ m_buffer[bytes_read]=(byte)read_byte;
+ bytes_read++;
- ConsumeBuffered(i);
- return count;
+ chars_read=m_encoding.GetChars(m_buffer, 0,
+ bytes_read,
+ buffer, index);
+
+ }
+
+ bytes = m_buffer;
+ return(chars_read);
}
protected int Read7BitEncodedInt() {
int ret = 0;
int shift = 0;
- int count = 0;
byte b;
do {
- if (!EnsureBuffered(++count)) {
- throw new EndOfStreamException();
- }
- b = m_buffer[m_buffer_pos + count - 1];
+ b = ReadByte();
ret = ret | ((b & 0x7f) << shift);
shift += 7;
} while ((b & 0x80) == 0x80);
- ConsumeBuffered(count);
return ret;
}
public virtual bool ReadBoolean() {
- if (!EnsureBuffered(1)) {
- throw new EndOfStreamException();
- }
-
- bool ret = BitConverter.ToBoolean(m_buffer, m_buffer_pos);
- ConsumeBuffered(1);
- return ret;
+ // Return value:
+ // true if the byte is non-zero; otherwise false.
+ return ReadByte() != 0;
}
public virtual byte ReadByte() {
- if (!EnsureBuffered(1)) {
- throw new EndOfStreamException();
- }
+ if (m_stream == null) {
+ if (m_disposed)
+ throw new ObjectDisposedException ("BinaryReader", "Cannot read from a closed BinaryReader.");
- byte ret = m_buffer[m_buffer_pos];
- ConsumeBuffered(1);
- return ret;
+ throw new IOException ("Stream is invalid");
+ }
+
+ int val = m_stream.ReadByte ();
+ if (val != -1)
+ return (byte) val;
+
+ throw new EndOfStreamException ();
}
public virtual byte[] ReadBytes(int count) {
- if (count < 0) {
- throw new ArgumentOutOfRangeException();
- }
+ if(m_stream==null) {
- EnsureBuffered(count);
+ if (m_disposed)
+ throw new ObjectDisposedException ("BinaryReader", "Cannot read from a closed BinaryReader.");
- if (count > m_buffer_used - m_buffer_pos) {
- count = m_buffer_used - m_buffer_pos;
+ throw new IOException("Stream is invalid");
}
-
- if (count == 0) {
- throw new EndOfStreamException();
+
+ if (count < 0) {
+ throw new ArgumentOutOfRangeException("count is less than 0");
}
+ /* Can't use FillBuffer() here, because it's OK to
+ * return fewer bytes than were requested
+ */
+
byte[] buf = new byte[count];
- Read(buf, 0, count);
- return buf;
+ int pos=0;
+
+ while(pos < count) \r
+ {
+ int n=m_stream.Read(buf, pos, count-pos);
+ if(n==0) {
+ /* EOF */
+ break;
+ }
+
+ pos+=n;
+ }
+
+ if (pos!=count) {
+ byte[] new_buffer=new byte[pos];
+ Buffer.BlockCopy (buf, 0, new_buffer, 0, pos);
+ return(new_buffer);
+ }
+
+ return(buf);
}
public virtual char ReadChar() {
- char[] buf = ReadChars(1);
- return buf[0];
+ int ch=Read();
+
+ if(ch==-1) {
+ throw new EndOfStreamException();
+ }
+
+ return((char)ch);
}
public virtual char[] ReadChars(int count) {
if (count < 0) {
- throw new ArgumentOutOfRangeException();
+ throw new ArgumentOutOfRangeException("count is less than 0");
}
+ if (count == 0)
+ return new char [0];
+
char[] full = new char[count];
- count = Read(full, 0, count);
+ int chars = Read(full, 0, count);
- if (count != full.Length) {
- char[] ret = new char[count];
- Array.Copy(full, 0, ret, 0, count);
+ if (chars == 0) {
+ throw new EndOfStreamException();
+ } else if (chars != full.Length) {
+ char[] ret = new char[chars];
+ Array.Copy(full, 0, ret, 0, chars);
return ret;
} else {
return full;
}
unsafe public virtual decimal ReadDecimal() {
- if (!EnsureBuffered(16)) {
- throw new EndOfStreamException();
- }
+ FillBuffer(16);
decimal ret;
byte* ret_ptr = (byte *)&ret;
- for (int i = 0; i < 16; i++) {
- ret_ptr[i] = m_buffer[m_buffer_pos + i];
+
+ /*
+ * internal representation of decimal is
+ * ss32, hi32, lo32, mi32,
+ * but in stream it is
+ * lo32, mi32, hi32, ss32
+ * So we have to rerange this int32 values
+ */
+
+ if (BitConverter.IsLittleEndian) {
+ for (int i = 0; i < 16; i++) {
+ if (i < 4) {
+ // lo 8 - 12
+ ret_ptr [i + 8] = m_buffer [i];
+ } else if (i < 8) {
+ // mid 12 - 16
+ ret_ptr [i + 8] = m_buffer [i];
+ } else if (i < 12) {
+ // hi 4 - 8
+ ret_ptr [i - 4] = m_buffer [i];
+ } else if (i < 16) {
+ // ss 0 - 4
+ ret_ptr [i - 12] = m_buffer [i];
+ }
+ }
+ } else {
+ for (int i = 0; i < 16; i++) {
+ if (i < 4) {
+ // lo 8 - 12
+ ret_ptr [11 - i] = m_buffer [i];
+ } else if (i < 8) {
+ // mid 12 - 16
+ ret_ptr [19 - i] = m_buffer [i];
+ } else if (i < 12) {
+ // hi 4 - 8
+ ret_ptr [15 - i] = m_buffer [i];
+ } else if (i < 16) {
+ // ss 0 - 4
+ ret_ptr [15 - i] = m_buffer [i];
+ }
+ }
}
- ConsumeBuffered(16);
return ret;
}
public virtual double ReadDouble() {
- if (!EnsureBuffered(8)) {
- throw new EndOfStreamException();
- }
+ FillBuffer(8);
- double ret = BitConverter.ToDouble(m_buffer, m_buffer_pos);
- ConsumeBuffered(8);
- return ret;
+ return(BitConverterLE.ToDouble(m_buffer, 0));
}
public virtual short ReadInt16() {
- if (!EnsureBuffered(2)) {
- throw new EndOfStreamException();
- }
+ FillBuffer(2);
- short ret = BitConverter.ToInt16(m_buffer, m_buffer_pos);
- ConsumeBuffered(2);
- return ret;
+ return((short) (m_buffer[0] | (m_buffer[1] << 8)));
}
public virtual int ReadInt32() {
- if (!EnsureBuffered(1)) {
- throw new EndOfStreamException();
- }
+ FillBuffer(4);
- int ret = BitConverter.ToInt32(m_buffer, m_buffer_pos);
- ConsumeBuffered(1);
- return ret;
+ return(m_buffer[0] | (m_buffer[1] << 8) |
+ (m_buffer[2] << 16) | (m_buffer[3] << 24));
}
public virtual long ReadInt64() {
- if (!EnsureBuffered(8)) {
- throw new EndOfStreamException();
- }
-
- long ret = BitConverter.ToInt64(m_buffer, m_buffer_pos);
- ConsumeBuffered(8);
- return ret;
+ FillBuffer(8);
+
+ uint ret_low = (uint) (m_buffer[0] |
+ (m_buffer[1] << 8) |
+ (m_buffer[2] << 16) |
+ (m_buffer[3] << 24)
+ );
+ uint ret_high = (uint) (m_buffer[4] |
+ (m_buffer[5] << 8) |
+ (m_buffer[6] << 16) |
+ (m_buffer[7] << 24)
+ );
+ return (long) ((((ulong) ret_high) << 32) | ret_low);
}
[CLSCompliant(false)]
- unsafe public virtual sbyte ReadSByte() {
- if (!EnsureBuffered(1)) {
- throw new EndOfStreamException();
- }
-
- sbyte ret;
- byte* ret_ptr = (byte *)&ret;
- ret_ptr[0] = m_buffer[m_buffer_pos];
-
- ConsumeBuffered(1);
- return ret;
+ public virtual sbyte ReadSByte() {
+ return (sbyte) ReadByte ();
}
public virtual string ReadString() {
+ /* Inspection of BinaryWriter-written files
+ * shows that the length is given in bytes,
+ * not chars
+ */
int len = Read7BitEncodedInt();
+
+ if (len < 0)
+ throw new IOException ("Invalid binary file (string len < 0)");
- char[] str = ReadChars(len);
- string ret = "";
- for (int i = 0; i < str.Length; i++) {
- ret = ret + str[i];
- }
+ if (len == 0)
+ return String.Empty;
+
+
+ if (charBuffer == null)
+ charBuffer = new char [MaxBufferSize];
+
+ //
+ // We read the string here in small chunks. Also, we
+ // Attempt to optimize the common case of short strings.
+ //
+ StringBuilder sb = null;
+ do {
+ int readLen = (len > MaxBufferSize)
+ ? MaxBufferSize
+ : len;
+
+ FillBuffer (readLen);
+
+ int cch = decoder.GetChars (m_buffer, 0, readLen, charBuffer, 0);
- return ret;
+ if (sb == null && readLen == len) // ok, we got out the easy way, dont bother with the sb
+ return new String (charBuffer, 0, cch);
+
+ if (sb == null)
+ // Len is a fairly good estimate of the number of chars in a string
+ // Most of the time 1 byte == 1 char
+ sb = new StringBuilder (len);
+
+ sb.Append (charBuffer, 0, cch);
+ len -= readLen;
+ } while (len > 0);
+
+ return sb.ToString();
}
public virtual float ReadSingle() {
- if (!EnsureBuffered(4)) {
- throw new EndOfStreamException();
- }
+ FillBuffer(4);
- float ret = BitConverter.ToSingle(m_buffer, m_buffer_pos);
- ConsumeBuffered(4);
- return ret;
+ return(BitConverterLE.ToSingle(m_buffer, 0));
}
[CLSCompliant(false)]
public virtual ushort ReadUInt16() {
- if (!EnsureBuffered(2)) {
- throw new EndOfStreamException();
- }
+ FillBuffer(2);
- ushort ret = BitConverter.ToUInt16(m_buffer, m_buffer_pos);
- ConsumeBuffered(2);
- return ret;
+ return((ushort) (m_buffer[0] | (m_buffer[1] << 8)));
}
[CLSCompliant(false)]
public virtual uint ReadUInt32() {
- if (!EnsureBuffered(4)) {
- throw new EndOfStreamException();
- }
+ FillBuffer(4);
+
- uint ret = BitConverter.ToUInt32(m_buffer, m_buffer_pos);
- ConsumeBuffered(4);
- return ret;
+ return((uint) (m_buffer[0] |
+ (m_buffer[1] << 8) |
+ (m_buffer[2] << 16) |
+ (m_buffer[3] << 24)));
}
[CLSCompliant(false)]
public virtual ulong ReadUInt64() {
- if (!EnsureBuffered(8)) {
- throw new EndOfStreamException();
- }
-
- ulong ret = BitConverter.ToUInt64(m_buffer, m_buffer_pos);
- ConsumeBuffered(8);
- return ret;
+ FillBuffer(8);
+
+ uint ret_low = (uint) (m_buffer[0] |
+ (m_buffer[1] << 8) |
+ (m_buffer[2] << 16) |
+ (m_buffer[3] << 24)
+ );
+ uint ret_high = (uint) (m_buffer[4] |
+ (m_buffer[5] << 8) |
+ (m_buffer[6] << 16) |
+ (m_buffer[7] << 24)
+ );
+ return (((ulong) ret_high) << 32) | ret_low;
}
-
- bool EnsureBuffered(int bytes) {
- int needed = bytes - (m_buffer_used - m_buffer_pos);
- if (needed <= 0)
- return true;
-
- if (m_buffer_used + needed > m_buffer.Length) {
- byte[] old_buffer = m_buffer;
- m_buffer = new byte[m_buffer_used + needed];
- Array.Copy(old_buffer, 0, m_buffer, 0, m_buffer_used);
- }
-
- m_buffer_used += m_stream.Read(m_buffer, m_buffer_used, needed);
-
- return (m_buffer_used >= m_buffer_pos + bytes);
- }
-
-
- void ConsumeBuffered(int bytes) {
- m_buffer_pos += bytes;
- if (m_buffer_pos == m_buffer_used) {
- m_buffer_pos = 0;
+ /* Ensures that m_buffer is at least length bytes
+ * long, growing it if necessary
+ */
+ private void CheckBuffer(int length)
+ {
+ if(m_buffer.Length <= length) {
+ byte[] new_buffer=new byte[length];
+ Buffer.BlockCopy (m_buffer, 0, new_buffer, 0, m_buffer.Length);
+ m_buffer=new_buffer;
}
}
}
projects / mono.git / blobdiff