botc: comparison src/dataBuffer.cpp

-:dbbdb870c835
+:eca2fc0acaa2
 	THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 #include "dataBuffer.h"
-// ============================================================================
+// -------------------------------------------------------------------------------------------------
 //
-DataBuffer::DataBuffer (int size)
+DataBuffer::DataBuffer (int size) :
-{
+	m_buffer (new char[size]),
-	setBuffer (new char[size]);
+	m_position (&buffer()[0]),
-	setPosition (&buffer()[0]);
+	m_allocatedSize (size) {}
-	setAllocatedSize (size);
-}
+// -------------------------------------------------------------------------------------------------
-// ============================================================================
 //
 DataBuffer::~DataBuffer()
 {
 	ASSERT (marks().isEmpty());
 	ASSERT (references().isEmpty());
 	delete buffer();
 }
-// ============================================================================
+// -------------------------------------------------------------------------------------------------
+//
+//	Copies the contents of the given buffer into this buffer. The other buffer's marks and
+//	references will be moved along and the buffer is then destroyed.
 //
 void DataBuffer::mergeAndDestroy (DataBuffer* other)
 {
 	if (other == null)
 		return;
 	other->transferMarksTo (this);
 	copyBuffer (other);
 	delete other;
 }
-// ============================================================================
+// -------------------------------------------------------------------------------------------------
 //
-// Clones this databuffer to a new one and returns it. Note that the original
+//	Clones this databuffer to a new one and returns it. Note that the original transfers its marks
-// transfers its marks and references and loses them in the process.
+//	and references and loses them in the process.
 //
 DataBuffer* DataBuffer::clone()
 {
 	DataBuffer* other = new DataBuffer;
 	transferMarksTo (other);
 	m_marks.clear();
 	m_references.clear();
 }
-// ============================================================================
+// -------------------------------------------------------------------------------------------------
+//
+//	Adds a new mark to the current position with the given name
 //
 ByteMark* DataBuffer::addMark (const String& name)
 {
 	ByteMark* mark = new ByteMark;
 	mark->name = name;
 	mark->pos = writtenSize();
 	m_marks << mark;
 	return mark;
 }
-// ============================================================================
+// -------------------------------------------------------------------------------------------------
+//
+//	Adds a new reference to the given mark at the current position. This function will write 4
+//	bytes to the buffer whose value will be determined at final output writing.
 //
 MarkReference* DataBuffer::addReference (ByteMark* mark)
 {
 	MarkReference* ref = new MarkReference;
 	ref->target = mark;
 	writeDWord (0xBEEFCAFE);
 	return ref;
 }
-// ============================================================================
+// -------------------------------------------------------------------------------------------------
+//
+//	Moves the given mark to the current bytecode position.
 //
 void DataBuffer::adjustMark (ByteMark* mark)
 {
 	mark->pos = writtenSize();
 }
-// ============================================================================
+// -------------------------------------------------------------------------------------------------
 //
-void DataBuffer::offsetMark (ByteMark* mark, int position)
+//	Shifts the given mark by the amount of bytes
-{
+//
-	mark->pos += position;
+void DataBuffer::offsetMark (ByteMark* mark, int bytes)
-}
+{
+	mark->pos += bytes;
-// ============================================================================
+}
+// -------------------------------------------------------------------------------------------------
+//
+//	Writes a push of the index of the given string. 8 bytes will be written and the string index
+//	will be pushed to stack.
 //
 void DataBuffer::writeStringIndex (const String& a)
 {
-	writeDWord (DH_PushStringIndex);
+	writeDWord (DataHeader::PushStringIndex);
 	writeDWord (getStringTableIndex (a));
 }
-// ============================================================================
+// -------------------------------------------------------------------------------------------------
+//
+//	Prints the buffer to stdout.
 //
 void DataBuffer::dump()
 {
 	for (int i = 0; i < writtenSize(); ++i)
 		printf ("%d. [0x%X]\n", i, buffer()[i]);
 }
-// ============================================================================
+// -------------------------------------------------------------------------------------------------
+//
+// Ensures there's at least the given amount of bytes left in the buffer. Will resize if necessary,
+// no-op if not. On resize, 512 extra bytes are allocated to reduce the amount of resizes.
 //
 void DataBuffer::checkSpace (int bytes)
 {
 	int writesize = writtenSize();
 	memcpy (m_buffer, copy, allocatedSize());
 	setPosition (buffer() + writesize);
 	delete copy;
 }
-// =============================================================================
+// -------------------------------------------------------------------------------------------------
+//
+//	Writes the given byte into the buffer.
 //
 void DataBuffer::writeByte (int8_t data)
 {
 	checkSpace (1);
 	*m_position++ = data;
 }
-// =============================================================================
+// -------------------------------------------------------------------------------------------------
+//
+//	Writes the given word into the buffer. 2 bytes will be written.
 //
 void DataBuffer::writeWord (int16_t data)
 {
 	checkSpace (2);
 	for (int i = 0; i < 2; ++i)
 		*m_position++ = (data >> (i * 8)) & 0xFF;
 }
-// =============================================================================
+// -------------------------------------------------------------------------------------------------
+//
+//	Writes the given dword into the buffer. 4bytes will be written.
 //
 void DataBuffer::writeDWord (int32_t data)
 {
 	checkSpace (4);
 	for (int i = 0; i < 4; ++i)
 		*m_position++ = (data >> (i * 8)) & 0xFF;
 }
-// =============================================================================
+// -------------------------------------------------------------------------------------------------
+//
+//	Writes the given string to the databuffer. The string will be written as-is without using string
+//	indices. This will write 4 + length bytes. No header will be written.
 //
 void DataBuffer::writeString (const String& a)
 {
 	checkSpace (a.length() + 4);
 	writeDWord (a.length());
 	for (char c : a)
 		writeByte (c);
 }
+// -------------------------------------------------------------------------------------------------
-// =============================================================================
+//
+//	Tries to locate the mark by the given name. Returns null if not found.
 //
 ByteMark* DataBuffer::findMarkByName (const String& name)
 {
 	for (ByteMark* mark : marks())
+	{
 		if (mark->name == name)
 			return mark;
+	}
 	return null;
 }

Mercurial > botc / file comparison

comparison: src/dataBuffer.cpp

src/dataBuffer.cpp