memorystream.cpp

机甲指挥官2源代码

//===========================================================================//
// File:	memstrm.cpp                                                      //
// Contents: Implementation Details of resource management                   //
//---------------------------------------------------------------------------//
// Copyright (C) Microsoft Corporation. All rights reserved.                 //
//===========================================================================//

#include "StuffHeaders.hpp"

//#############################################################################
//##########################    MemoryStream    ###############################
//#############################################################################

MemoryStream::ClassData*
	MemoryStream::DefaultData = NULL;

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
	MemoryStream::InitializeClass()
{
	Verify(!DefaultData);
	DefaultData =
		new ClassData(
			MemoryStreamClassID,
			"Stuff::MemoryStream",
			RegisteredClass::DefaultData
		);
	Check_Object(DefaultData);
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
	MemoryStream::TerminateClass()
{
	Check_Object(DefaultData);
	delete DefaultData;
	DefaultData = NULL;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
MemoryStream::MemoryStream(
	void *stream_start,
	DWORD stream_size,
	DWORD initial_offset
):
	RegisteredClass(DefaultData)
{
	Check_Pointer(this);

	streamStart = static_cast<BYTE*>(stream_start);
	streamSize = stream_size;
	Verify(initial_offset <= stream_size);
	currentPosition = streamStart + initial_offset;
	currentBit = Empty_Bit_Buffer;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
MemoryStream::MemoryStream(
	ClassData *class_data,
	void *stream_start,
	DWORD stream_size,
	DWORD initial_offset
):
	RegisteredClass(class_data)
{
	Check_Pointer(this);

	streamStart = static_cast<BYTE*>(stream_start);
	streamSize = stream_size;
	Verify(initial_offset <= stream_size);
	currentPosition = streamStart + initial_offset;
	currentBit = 0;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
MemoryStream::~MemoryStream()
{
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
MemoryStream&
	MemoryStream::ReadBytes(
		void *ptr,
		DWORD number_of_bytes
	)
{
	Check_Object(this);
	Check_Pointer(ptr);
	Verify(number_of_bytes > 0);
	#if defined(_ARMOR)
		DWORD remaining = GetBytesRemaining();
		Verify(remaining >= number_of_bytes);
	#endif

	Mem_Copy(ptr, GetPointer(), number_of_bytes, number_of_bytes);
	AdvancePointer(number_of_bytes);
	return *this;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
int
	MemoryStream::ReadChar()
{
	Check_Object(this);
	DWORD bytes_remaining = GetBytesRemaining();
	if (bytes_remaining > 0)
	{
		BYTE byte;
		ReadBytes(&byte, 1);
		return byte;				
	}
	return End_Of_Stream;
}	

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
bool
	MemoryStream::ReadLine(
		char *buffer,
		int max_number_of_bytes,
		char continuator
	)
{
	Check_Object(this);
	Check_Pointer(buffer);
	Verify(max_number_of_bytes > 0);

	//
	// while the character is not end of file &&
	// there is room left in the buffer,
	// copy the character into the buffer
	//
	int c = ReadChar();
	if (c == End_Of_Stream)
		return false;

	char *p = buffer;
	int i = 0;

	Check_Object(FileStreamManager::Instance);
	const char *eol = "\r\n";
	DWORD eol_length = strlen(eol);

	while (c != End_Of_Stream && i < max_number_of_bytes)
	{
		Check_Pointer(p); 
		Verify(i < max_number_of_bytes); 
		p[i] = (char)c;

		//
		// If we have met the end of line condition, break
		//
		switch (eol_length)
		{
		case 1:
			if (p[i] == *eol)
			{
				c = End_Of_Stream;
			}
			else
			{
				++i;
				c = ReadChar();			
			}
			break;

		case 2:
			if (p[i] == eol[1] && i > 0 && p[i-1] == eol[0])
			{
				i -= 1;
				c = End_Of_Stream;
			}
			else
			{
				++i;
				c = ReadChar();			
			}
			break;

		default:
			STOP(("Unhandled eol style"));
		}
	}
	if (i < max_number_of_bytes)
	{
		p[i] = '\0';
		return true;
	}

	Warn(i >= max_number_of_bytes);
	Verify(i == max_number_of_bytes);
	p[i-1] = '\0';

	return false;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
MString
	MemoryStream::ReadString(
		DWORD size_of_buffer,
		char continuator
	)
{
	Check_Object(this);
	Verify(size_of_buffer > 0);

	static char buffer[1024];
	Verify(size_of_buffer < sizeof(buffer));

	MString temp_string;
	if (ReadLine(buffer, size_of_buffer, continuator))
	{
		temp_string = buffer;
	}
	return temp_string;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
MemoryStream&
	MemoryStream::ReadSwappedBytes(
		void *ptr,
		DWORD number_of_bytes
	)
{
	Check_Object(this);
	Check_Pointer(ptr);
	Verify(number_of_bytes > 0);
	Verify(GetBytesRemaining() >= number_of_bytes);

	BYTE *buffer = new BYTE[number_of_bytes];
	Check_Pointer(buffer);
	ReadBytes(buffer, number_of_bytes);
	for (DWORD i=0; i<number_of_bytes; ++i)
	{
		static_cast<BYTE*>(ptr)[i] = buffer[number_of_bytes-1 - i];
	}
	Check_Pointer(buffer);
	delete[] buffer;
	return *this;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
	MemoryStream::WriteLine(char *buffer)
{
	Check_Object(this);
	Check_Pointer(buffer);

	WriteBytes(buffer, strlen(buffer));
	WriteBytes("\r\n", 2);
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
MemoryStream&
	MemoryStream::WriteBytes(
		const void *ptr,
		DWORD number_of_bytes
	)
{
	Check_Object(this);
	Check_Pointer(ptr);
	Verify(number_of_bytes > 0);

	Mem_Copy(GetPointer(), ptr, number_of_bytes, GetBytesRemaining());
	AdvancePointer(number_of_bytes);
	return *this;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
MemoryStream&
	MemoryStream::WriteSwappedBytes(
		const void *ptr,
		DWORD number_of_bytes
	)
{
	Check_Object(this);
	Check_Pointer(ptr);
	Verify(number_of_bytes > 0);
	Verify(GetBytesRemaining() >= number_of_bytes);

	BYTE *buffer = new BYTE[number_of_bytes];
	Check_Pointer(buffer);
	for (DWORD i=0; i<number_of_bytes; ++i)
	{
		buffer[number_of_bytes-1 - i] = static_cast<const BYTE*>(ptr)[i];
	}
	WriteBytes(buffer, number_of_bytes);
	Check_Pointer(buffer);
	delete[] buffer;
	return *this;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
MemoryStream&
	MemoryStreamIO::Write(
		MemoryStream *stream,
		const MemoryStream *input_stream
	)
{
	Check_Object(stream);
	Check_Object(input_stream);

	return
		stream->WriteBytes(
			input_stream->GetPointer(),
			input_stream->GetBytesRemaining()
		);
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//  Bit packing methods...
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


#if 0
		
		// quick reference for the boneheads...
		
		// >> shift right
		// << shift left	
		// ~ complement
		// ^ exclusive or - 1 if bits match
		// | and		  - 1 if either bit is one
		// & or			  - 1 if both bits are one
		
		// 0000|1111 << 4 = 1111|0000
		// 1111|0000 >> 2 = 0011|1100
		// ~1111|0000 = 0000|1111
		
		//
		//    0000|1111
		//	^ 1010|1010
		//---------------
		//	  0101|1010
		
		//
		//	  0000|0101
		//	| 1100|1100
		//---------------
		//	  1100|1101
		
		//
		//	  0000|0101
		//	& 1100|1100
		//---------------
		//	  0000|0100
						
		
		
		// set a number to a specific value
		
		
		
		// bitmasks
		
		//0x01 // 0000|0001
		//0x03 // 0000|0011
		//0x07 // 0000|0111
		//0x0f // 0000|1111
		//0x1f // 0001|1111
		//0x3f // 0011|1111
		//0x7f // 0111|1111
		//0xff // 1111|1111
		
		// inverted bitmasks
		
		//0x80 // 1000|0000
		//0xc0 // 1100|0000
		//0xe0 // 1110|0000
		//0xf0 // 1111|0000
		//0xf8 // 1111|1000
		//0xfc // 1111|1100
		//0xfe // 1111|1110
		//0xff // 1111|1111

	

		Verify(bit_count > 0);
		Verify(bit_count < 32);

		unsigned int bit_count = 0;
		bit_count = 0x1 << i;

		SPEW(("jerryeds", "%u %u", i,bit_count));
	
#endif


//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//

void
	MemoryStream::ByteAlign()
{
	if (currentBit == 0)
	{
		return;
	}
	Check_Object(this);
	//SPEW(("jerryeds", "WRITE : %x", workingBitBuffer));
	WriteBytes(&workingBitBuffer, 1);
	workingBitBuffer = 0x00;
	currentBit = 0;
}


//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
MemoryStream&
	MemoryStream::ReadBit(bool &bit_value)
{
	Check_Object(this);

	int result = 0;
	
	if (currentBit == Empty_Bit_Buffer)
	{
		ReadBytes(&workingBitBuffer, 1);
		//SPEW(("jerryeds", "READ : %x", workingBitBuffer));
		currentBit = 0;
	}	


	Verify(currentBit >= 0);
	Verify(currentBit <  8);

	result = (0x01 & (workingBitBuffer >> currentBit));
	bit_value = (result)?true:false;

	currentBit++;
	if (currentBit > 7 && GetBytesRemaining())
	{

		ReadBytes(&workingBitBuffer, 1);