mono/mcs/class/corlib/System.IO/StreamReader.cs

//
// System.IO.StreamReader.cs
//
// Authors:
//   Dietmar Maurer ([email protected])
//   Miguel de Icaza ([email protected]) 
//   Marek Safar ([email protected])
//
// (C) Ximian, Inc.  http://www.ximian.com
// Copyright (C) 2004 Novell (http://www.novell.com)
// Copyright 2011, 2013 Xamarin Inc.
//
// 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.Runtime.InteropServices;
#if NET_4_5
using System.Threading.Tasks;
#endif

namespace System.IO {
	[Serializable]
	[ComVisible (true)]
	public class StreamReader : TextReader
	{
		sealed class NullStreamReader : StreamReader
		{
			public override int Peek ()
			{
				return -1;
			}

			public override int Read ()
			{
				return -1;
			}

			public override int Read ([In, Out] char[] buffer, int index, int count)
			{
				return 0;
			}

			public override string ReadLine ()
			{
				return null;
			}

			public override string ReadToEnd ()
			{
				return String.Empty;
			}

			public override Stream BaseStream {
				get { return Stream.Null; }
			}

			public override Encoding CurrentEncoding {
				get { return Encoding.Unicode; }
			}
		}

		const int DefaultBufferSize = 1024;
		const int DefaultFileBufferSize = 4096;
		const int MinimumBufferSize = 128;

		//
		// The input buffer
		//
		byte [] input_buffer;
		
		// Input buffer ready for recycling
		static byte [] input_buffer_recycle;
		static object input_buffer_recycle_lock = new object ();

		//
		// The decoded buffer from the above input buffer
		//
		char [] decoded_buffer;
		static char[] decoded_buffer_recycle;

		Encoding encoding;
		Decoder decoder;
		StringBuilder line_builder;
		Stream base_stream;

		//
		// Decoded bytes in decoded_buffer.
		//
		int decoded_count;

		//
		// Current position in the decoded_buffer
		//
		int pos;

		//
		// The buffer size that we are using
		//
		int buffer_size;

		int do_checks;
		
		bool mayBlock;

#if NET_4_5
		IDecoupledTask async_task;
		readonly bool leave_open;
#endif

		public new static readonly StreamReader Null =  new NullStreamReader ();
		
		private StreamReader() {}

		public StreamReader(Stream stream)
			: this (stream, Encoding.UTF8Unmarked, true, DefaultBufferSize) { }

		public StreamReader(Stream stream, bool detectEncodingFromByteOrderMarks)
			: this (stream, Encoding.UTF8Unmarked, detectEncodingFromByteOrderMarks, DefaultBufferSize) { }

		public StreamReader(Stream stream, Encoding encoding)
			: this (stream, encoding, true, DefaultBufferSize) { }

		public StreamReader(Stream stream, Encoding encoding, bool detectEncodingFromByteOrderMarks)
			: this (stream, encoding, detectEncodingFromByteOrderMarks, DefaultBufferSize) { }

#if NET_4_5
		public StreamReader(Stream stream, Encoding encoding, bool detectEncodingFromByteOrderMarks, int bufferSize)
			: this (stream, encoding, detectEncodingFromByteOrderMarks, bufferSize, false)
		{
		}

		public StreamReader(Stream stream, Encoding encoding, bool detectEncodingFromByteOrderMarks, int bufferSize, bool leaveOpen)
#else
		const bool leave_open = false;

		public StreamReader(Stream stream, Encoding encoding, bool detectEncodingFromByteOrderMarks, int bufferSize)
#endif
		{
#if NET_4_5
			leave_open = leaveOpen;
#endif
			Initialize (stream, encoding, detectEncodingFromByteOrderMarks, bufferSize);
		}

		public StreamReader(string path)
			: this (path, Encoding.UTF8Unmarked, true, DefaultFileBufferSize) { }

		public StreamReader(string path, bool detectEncodingFromByteOrderMarks)
			: this (path, Encoding.UTF8Unmarked, detectEncodingFromByteOrderMarks, DefaultFileBufferSize) { }

		public StreamReader(string path, Encoding encoding)
			: this (path, encoding, true, DefaultFileBufferSize) { }

		public StreamReader(string path, Encoding encoding, bool detectEncodingFromByteOrderMarks)
			: this (path, encoding, detectEncodingFromByteOrderMarks, DefaultFileBufferSize) { }
		
		public StreamReader(string path, Encoding encoding, bool detectEncodingFromByteOrderMarks, int bufferSize)
		{
			if (null == path)
				throw new ArgumentNullException("path");
			if (String.Empty == path)
				throw new ArgumentException("Empty path not allowed");
			if (path.IndexOfAny (Path.InvalidPathChars) != -1)
				throw new ArgumentException("path contains invalid characters");
			if (null == encoding)
				throw new ArgumentNullException ("encoding");
			if (bufferSize <= 0)
				throw new ArgumentOutOfRangeException ("bufferSize", "The minimum size of the buffer must be positive");

			Stream stream = (Stream) File.OpenRead (path);
			Initialize (stream, encoding, detectEncodingFromByteOrderMarks, bufferSize);
		}

		internal void Initialize (Stream stream, Encoding encoding, bool detectEncodingFromByteOrderMarks, int bufferSize)
		{
			if (null == stream)
				throw new ArgumentNullException ("stream");
			if (null == encoding)
				throw new ArgumentNullException ("encoding");
			if (!stream.CanRead)
				throw new ArgumentException ("Cannot read stream");
			if (bufferSize <= 0)
				throw new ArgumentOutOfRangeException ("bufferSize", "The minimum size of the buffer must be positive");

			if (bufferSize < MinimumBufferSize)
				bufferSize = MinimumBufferSize;
			
			// since GetChars() might add flushed character, it 
			// should have additional char buffer for extra 1 
			// (probably 1 is ok, but might be insufficient. I'm not sure)
			var decoded_buffer_size = encoding.GetMaxCharCount (bufferSize) + 1;

			//
			// Instead of allocating a new default buffer use the
			// last one if there is any available
			//
			if (bufferSize <= DefaultBufferSize && input_buffer_recycle != null) {
				lock (input_buffer_recycle_lock) {
					if (input_buffer_recycle != null) {
						input_buffer = input_buffer_recycle;
						input_buffer_recycle = null;
					}
					
					if (decoded_buffer_recycle != null && decoded_buffer_size <= decoded_buffer_recycle.Length) {
						decoded_buffer = decoded_buffer_recycle;
						decoded_buffer_recycle = null;
					}
				}
			}
			
			if (input_buffer == null)
				input_buffer = new byte [bufferSize];
			else
				Array.Clear (input_buffer, 0, bufferSize);
			
			if (decoded_buffer == null)
				decoded_buffer = new char [decoded_buffer_size];
			else
				Array.Clear (decoded_buffer, 0, decoded_buffer_size);

			base_stream = stream;		
			this.buffer_size = bufferSize;
			this.encoding = encoding;
			decoder = encoding.GetDecoder ();

			byte [] preamble = encoding.GetPreamble ();
			do_checks = detectEncodingFromByteOrderMarks ? 1 : 0;
			do_checks += (preamble.Length == 0) ? 0 : 2;
			
			decoded_count = 0;
			pos = 0;
		}

		public virtual Stream BaseStream {
			get {
				return base_stream;
			}
		}

		public virtual Encoding CurrentEncoding {
			get {
				if (encoding == null)
					throw new Exception ();
				return encoding;
			}
		}

		public bool EndOfStream {
			get { return Peek () < 0; }
		}

		public override void Close ()
		{
			Dispose (true);
		}

		protected override void Dispose (bool disposing)
		{
			if (disposing && base_stream != null && !leave_open)
				base_stream.Close ();
			
			if (input_buffer != null && input_buffer.Length == DefaultBufferSize && input_buffer_recycle == null) {
				lock (input_buffer_recycle_lock) {
					if (input_buffer_recycle == null) {
						input_buffer_recycle = input_buffer;
					}
					
					if (decoded_buffer_recycle == null) {
						decoded_buffer_recycle = decoded_buffer;
					}
				}
			}
			
			input_buffer = null;
			decoded_buffer = null;
			encoding = null;
			decoder = null;
			base_stream = null;
			base.Dispose (disposing);
		}

		//
		// Provides auto-detection of the encoding, as well as skipping over
		// byte marks at the beginning of a stream.
		//
		int DoChecks (int count)
		{
			if ((do_checks & 2) == 2){
				byte [] preamble = encoding.GetPreamble ();
				int c = preamble.Length;
				if (count >= c){
					int i;
					
					for (i = 0; i < c; i++)
						if (input_buffer [i] != preamble [i])
							break;

					if (i == c)
						return i;
				}
			}

			if ((do_checks & 1) == 1){
				if (count < 2)
					return 0;

				if (input_buffer [0] == 0xfe && input_buffer [1] == 0xff){
					this.encoding = Encoding.BigEndianUnicode;
					return 2;
				}
				if (input_buffer [0] == 0xff && input_buffer [1] == 0xfe && count < 4) {
					// If we don't have enough bytes we can't check for UTF32, so use Unicode
					this.encoding = Encoding.Unicode;
					return 2;
				}

				if (count < 3)
					return 0;

				if (input_buffer [0] == 0xef && input_buffer [1] == 0xbb && input_buffer [2] == 0xbf){
					this.encoding = Encoding.UTF8Unmarked;
					return 3;
				}

				if (count < 4) {
					if (input_buffer [0] == 0xff && input_buffer [1] == 0xfe && input_buffer [2] != 0) {
						this.encoding = Encoding.Unicode;
						return 2;
					}
					return 0;
				}

				if (input_buffer [0] == 0 && input_buffer [1] == 0
					&& input_buffer [2] == 0xfe && input_buffer [3] == 0xff)
				{
					this.encoding = Encoding.BigEndianUTF32;
					return 4;
				}

				if (input_buffer [0] == 0xff && input_buffer [1] == 0xfe) {
					if (input_buffer [2] == 0 && input_buffer[3] == 0) {
						this.encoding = Encoding.UTF32;
						return 4;
					}

					this.encoding = Encoding.Unicode;
					return 2;
				}
			}

			return 0;
		}

		public void DiscardBufferedData ()
		{
			CheckState ();

			pos = decoded_count = 0;
			mayBlock = false;
			// Discard internal state of the decoder too.
			decoder = encoding.GetDecoder ();
		}
		
		// the buffer is empty, fill it again
		// Keep in sync with ReadBufferAsync
		int ReadBuffer ()
		{
			pos = 0;

			// keep looping until the decoder gives us some chars
			decoded_count = 0;
			do {
				var cbEncoded = base_stream.Read (input_buffer, 0, buffer_size);
				if (cbEncoded <= 0)
					return 0;

				decoded_count = ReadBufferCore (cbEncoded);
			} while (decoded_count == 0);

			return decoded_count;
		}

		int ReadBufferCore (int cbEncoded)
		{
			int parse_start;

			mayBlock = cbEncoded < buffer_size;
			if (do_checks > 0){
				Encoding old = encoding;
				parse_start = DoChecks (cbEncoded);
				if (old != encoding){
					int old_decoded_size = old.GetMaxCharCount (buffer_size) + 1;
					int new_decoded_size = encoding.GetMaxCharCount (buffer_size) + 1;
					if (old_decoded_size != new_decoded_size)
						decoded_buffer = new char [new_decoded_size];
					decoder = encoding.GetDecoder ();
				}
				do_checks = 0;
				cbEncoded -= parse_start;
			} else {
				parse_start = 0;
			}
				
			return decoder.GetChars (input_buffer, parse_start, cbEncoded, decoded_buffer, 0);
		}

		//
		// Peek can block:
		// http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=96484
		//
		public override int Peek ()
		{
			CheckState ();

			if (pos >= decoded_count && ReadBuffer () == 0)
				return -1;

			return decoded_buffer [pos];
		}

		//
		// Used internally by our console, as it previously depended on Peek() being a
		// routine that would not block.
		//
		internal bool DataAvailable ()
		{
			return pos < decoded_count;
		}
		
		public override int Read ()
		{
			CheckState ();

			if (pos >= decoded_count && ReadBuffer () == 0)
				return -1;

			return decoded_buffer [pos++];
		}

		// Keep in sync with ReadAsync
		public override int Read ([In, Out] char[] buffer, int index, int count)
		{
			if (buffer == null)
				throw new ArgumentNullException ("buffer");
			if (index < 0)
				throw new ArgumentOutOfRangeException ("index", "< 0");
			if (count < 0)
				throw new ArgumentOutOfRangeException ("count", "< 0");
			// re-ordered to avoid possible integer overflow
			if (index > buffer.Length - count)
				throw new ArgumentException ("index + count > buffer.Length");

			CheckState ();

			int chars_read = 0;
			while (count > 0) {
				if (pos >= decoded_count && ReadBuffer () == 0)
					return chars_read > 0 ? chars_read : 0;

				int cch = Math.Min (decoded_count - pos, count);
				Array.Copy (decoded_buffer, pos, buffer, index, cch);
				pos += cch;
				index += cch;
				count -= cch;
				chars_read += cch;
				if (mayBlock)
					break;
			}
			return chars_read;
		}

		bool foundCR;
		int FindNextEOL ()
		{
			char c = '\0';
			for (; pos < decoded_count; pos++) {
				c = decoded_buffer [pos];
				if (c == '\n') {
					pos++;
					int res = (foundCR) ? (pos - 2) : (pos - 1);
					if (res < 0)
						res = 0; // if a new buffer starts with a \n and there was a \r at
							// the end of the previous one, we get here.
					foundCR = false;
					return res;
				} else if (foundCR) {
					foundCR = false;
					if (pos == 0)
						return -2; // Need to flush the current buffered line.
							   // This is a \r at the end of the previous decoded buffer that
							   // is not followed by a \n in the current decoded buffer.
					return pos - 1;
				}

				foundCR = (c == '\r');
			}

			return -1;
		}

		// Keep in sync with ReadLineAsync
		public override string ReadLine()
		{
			CheckState ();

			if (pos >= decoded_count && ReadBuffer () == 0)
				return null;

			int begin = pos;
			int end = FindNextEOL ();
			if (end < decoded_count && end >= begin)
				return new string (decoded_buffer, begin, end - begin);
			if (end == -2)
				return line_builder.ToString (0, line_builder.Length);

			if (line_builder == null)
				line_builder = new StringBuilder ();
			else
				line_builder.Length = 0;

			while (true) {
				if (foundCR) // don't include the trailing CR if present
					decoded_count--;

				line_builder.Append (decoded_buffer, begin, decoded_count - begin);
				if (ReadBuffer () == 0) {
					if (line_builder.Capacity > 32768) {
						StringBuilder sb = line_builder;
						line_builder = null;
						return sb.ToString (0, sb.Length);
					}
					return line_builder.ToString (0, line_builder.Length);
				}

				begin = pos;
				end = FindNextEOL ();
				if (end < decoded_count && end >= begin) {
					line_builder.Append (decoded_buffer, begin, end - begin);
					if (line_builder.Capacity > 32768) {
						StringBuilder sb = line_builder;
						line_builder = null;
						return sb.ToString (0, sb.Length);
					}
					return line_builder.ToString (0, line_builder.Length);
				}

				if (end == -2)
					return line_builder.ToString (0, line_builder.Length);
			}
		}

		// Keep in sync with ReadToEndAsync
		public override string ReadToEnd()
		{
			CheckState ();

			StringBuilder text = new StringBuilder ();

			do {
				text.Append (decoded_buffer, pos, decoded_count - pos);
			} while (ReadBuffer () != 0);

			return text.ToString ();
		}

		void CheckState ()
		{
			if (base_stream == null)
				throw new ObjectDisposedException ("StreamReader", "Cannot read from a closed StreamReader");

#if NET_4_5
			if (async_task != null && !async_task.IsCompleted)
				throw new InvalidOperationException ();
#endif
		}

#if NET_4_5
		public override int ReadBlock ([In, Out] char[] buffer, int index, int count)
		{
			if (buffer == null)
				throw new ArgumentNullException ("buffer");
			if (index < 0)
				throw new ArgumentOutOfRangeException ("index", "< 0");
			if (count < 0)
				throw new ArgumentOutOfRangeException ("count", "< 0");
			// re-ordered to avoid possible integer overflow
			if (index > buffer.Length - count)
				throw new ArgumentException ("index + count > buffer.Length");

			CheckState ();

			return base.ReadBlock (buffer, index, count);
		}

		public override Task<int> ReadAsync (char[] buffer, int index, int count)
		{
			if (buffer == null)
				throw new ArgumentNullException ("buffer");
			if (index < 0)
				throw new ArgumentOutOfRangeException ("index", "< 0");
			if (count < 0)
				throw new ArgumentOutOfRangeException ("count", "< 0");
			// re-ordered to avoid possible integer overflow
			if (index > buffer.Length - count)
				throw new ArgumentException ("index + count > buffer.Length");

			CheckState ();

			DecoupledTask<int> res;
			async_task = res = new DecoupledTask<int> (ReadAsyncCore (buffer, index, count));
			return res.Task;
		}

		async Task<int> ReadAsyncCore (char[] buffer, int index, int count)
		{
			int chars_read = 0;

			while (count > 0) {
				if (pos >= decoded_count && await ReadBufferAsync ().ConfigureAwait (false) == 0)
					return chars_read > 0 ? chars_read : 0;

				int cch = Math.Min (decoded_count - pos, count);
				Array.Copy (decoded_buffer, pos, buffer, index, cch);
				pos += cch;
				index += cch;
				count -= cch;
				chars_read += cch;
				if (mayBlock)
					break;
			}

			return chars_read;
		}

		public override Task<int> ReadBlockAsync (char[] buffer, int index, int count)
		{
			if (buffer == null)
				throw new ArgumentNullException ("buffer");
			if (index < 0)
				throw new ArgumentOutOfRangeException ("index", "< 0");
			if (count < 0)
				throw new ArgumentOutOfRangeException ("count", "< 0");
			// re-ordered to avoid possible integer overflow
			if (index > buffer.Length - count)
				throw new ArgumentException ("index + count > buffer.Length");

			CheckState ();

			DecoupledTask<int> res;
			async_task = res = new DecoupledTask<int> (ReadAsyncCore (buffer, index, count));
			return res.Task;
		}

		public override Task<string> ReadLineAsync ()
		{
			CheckState ();

			DecoupledTask<string> res;
			async_task = res = new DecoupledTask<string> (ReadLineAsyncCore ());
			return res.Task;
		}

		async Task<string> ReadLineAsyncCore ()
		{
			if (pos >= decoded_count && await ReadBufferAsync ().ConfigureAwait (false) == 0)
				return null;

			int begin = pos;
			int end = FindNextEOL ();
			if (end < decoded_count && end >= begin)
				return new string (decoded_buffer, begin, end - begin);
			if (end == -2)
				return line_builder.ToString (0, line_builder.Length);

			if (line_builder == null)
				line_builder = new StringBuilder ();
			else
				line_builder.Length = 0;

			while (true) {
				if (foundCR) // don't include the trailing CR if present
					decoded_count--;

				line_builder.Append (decoded_buffer, begin, decoded_count - begin);
				if (await ReadBufferAsync ().ConfigureAwait (false) == 0) {
					if (line_builder.Capacity > 32768) {
						StringBuilder sb = line_builder;
						line_builder = null;
						return sb.ToString (0, sb.Length);
					}
					return line_builder.ToString (0, line_builder.Length);
				}

				begin = pos;
				end = FindNextEOL ();
				if (end < decoded_count && end >= begin) {
					line_builder.Append (decoded_buffer, begin, end - begin);
					if (line_builder.Capacity > 32768) {
						StringBuilder sb = line_builder;
						line_builder = null;
						return sb.ToString (0, sb.Length);
					}
					return line_builder.ToString (0, line_builder.Length);
				}

				if (end == -2)
					return line_builder.ToString (0, line_builder.Length);
			}
		}

		public override Task<string> ReadToEndAsync ()
		{
			CheckState ();

			DecoupledTask<string> res;
			async_task = res = new DecoupledTask<string> (ReadToEndAsyncCore ());
			return res.Task;
		}

		async Task<string> ReadToEndAsyncCore ()
		{
			StringBuilder text = new StringBuilder ();

			do {
				text.Append (decoded_buffer, pos, decoded_count - pos);
			} while (await ReadBufferAsync () != 0);

			return text.ToString ();
		}

		async Task<int> ReadBufferAsync ()
		{
			pos = 0;

			// keep looping until the decoder gives us some chars
			decoded_count = 0;
			do {
				var cbEncoded = await base_stream.ReadAsync (input_buffer, 0, buffer_size).ConfigureAwait (false);
				if (cbEncoded <= 0)
					return 0;

				decoded_count = ReadBufferCore (cbEncoded);
			} while (decoded_count == 0);

			return decoded_count;
		}
#endif
	}
}