Method Read

source/TextIO.cpp:88–346

DWORD TextStream::Read(LPTSTR aBuf, DWORD aBufLen, BOOL aReadLine)
{
	if (!PrepareToRead())
		return 0;

	DWORD target_used = 0;
	LPBYTE src, src_end;
	TCHAR dst[UorA(2,4)];
	int src_size; // Size of source character, in bytes.
	int dst_size; // Number of code units in destination character.

	UINT codepage = mCodePage; // For performance.
	int chr_size = (codepage == CP_UTF16) ? sizeof(WCHAR) : sizeof(CHAR);

	// This is set each iteration based on how many bytes we *need* to have in the buffer.
	// Avoid setting it higher than necessary since that can cause undesired effects with
	// non-file handles -  such as a console waiting for a second line of input when the
	// first line is waiting in our buffer.
	int next_size = chr_size;

	while (target_used < aBufLen)
	{
		// Ensure the buffer contains at least one CHAR/WCHAR, or all bytes of the next
		// character as determined by a previous iteration of the loop.  Note that Read()
		// only occurs if the buffer contains less than next_size bytes, and that this
		// check does not occur frequently due to buffering and the inner loop below.
		if (!ReadAtLeast(next_size) && !mLength)
			break;

		// Reset to default (see comments above).
		next_size = chr_size;

		// The following macro is used when there is insufficient data in the buffer,
		// to determine if more data can possibly be read in.  Using mLastRead should be
		// faster than AtEOF(), and more reliable with console/pipe handles.
		#define LAST_READ_HIT_EOF (mLastRead == 0)
		
		// Because we copy mPos into a temporary variable here and update mPos at the end of
		// each outer loop iteration, it is very important that ReadAtLeast() not be called
		// after this point.
		src = mPos;
		src_end = mBuffer + mLength; // Maint: mLength is in bytes.
		
		// Ensure there are an even number of bytes in the buffer if we are reading UTF-16.
		// This can happen (for instance) when dealing with binary files which also contain
		// UTF-16 strings, or if a UTF-16 file is missing its last byte.
		if (codepage == CP_UTF16 && ((src_end - src) & 1))
		{
			// Try to defer processing of the odd byte until the next byte is read.
			--src_end;
			// If it's the only byte remaining, the safest thing to do is probably to drop it
			// from the stream and output an invalid char so that the error can be detected:
			if (src_end == src)
			{
				mPos = NULL;
				mLength = 0;
				aBuf[target_used++] = INVALID_CHAR;
				break;