initial commit

1 files changed, 406 insertions, 0 deletions

diff --git a/src/T2DLL/LArray.cpp b/src/T2DLL/LArray.cpp
new file mode 100644
index 0000000..647162f
--- /dev/null
+++ b/src/T2DLL/LArray.cpp
@@ -0,0 +1,406 @@
+#include "LArray.h"
+#include "T2Archive.h"
+
+// unknown/assumed name -- not in T2DLL exports!
+class LDefaultComparator : public LComparator {
+public:
+	LDefaultComparator();
+	virtual ~LDefaultComparator();
+	virtual int Compare(const void* inItemOne, const void* inItemTwo, unsigned int inSizeOne, unsigned int inSizeTwo) const;
+	virtual BOOL IsEqualTo(const void* inItemOne, const void* inItemTwo, unsigned int inSizeOne, unsigned int inSizeTwo) const;
+	static LDefaultComparator* GetComparator();
+protected:
+	static LDefaultComparator* sDefaultComparator;
+};
+
+LArray::LArray() {
+	init(sizeof(void *), NULL, false);
+}
+
+LArray::LArray(int size, LComparator* comparator, BOOL keepSorted) {
+	init(size, comparator, keepSorted);
+}
+
+void LArray::init(int size, LComparator* comparator, BOOL keepSorted) {
+	mKeepSorted = keepSorted;
+	mOwnsComparator = true;
+	if (!comparator) {
+		mComparator = LDefaultComparator::GetComparator();
+		mOwnsComparator = false;
+	} else {
+		mComparator = comparator;
+	}
+	mItemSize = size;
+	mItemCount = 0;
+	mExpandSize = 10;
+	mBuffer = malloc(mExpandSize * mItemSize);
+}
+
+LArray::~LArray() {
+	if (mComparator && mOwnsComparator)
+		delete mComparator;
+	free(mBuffer);
+}
+
+/*virtual*/ int LArray::GetCount() const {
+	return mItemCount;
+}
+
+void LArray::Expand(int amount) {
+	int threshold = mItemCount + amount;
+	if (threshold > mExpandSize) {
+		mExpandSize = threshold + 10;
+		mBuffer = realloc(mBuffer, mExpandSize * mItemSize);
+	}
+	mItemCount += amount;
+}
+
+void LArray::AdjustAllocation(int amount) {
+	if (amount > mExpandSize) {
+		mExpandSize = amount + 10;
+		mBuffer = realloc(mBuffer, mExpandSize * mItemSize);
+	}
+}
+
+void LArray::SetKeepSorted(int keepSorted) {
+	mKeepSorted = keepSorted;
+}
+
+/*virtual*/ void LArray::InsertItemsAt(int count, int where, const void* data) {
+	if (!mKeepSorted) {
+		if (where == 0)
+			where = 1;
+
+		int oldCount = mItemCount;
+		Expand(count);
+		memmove(
+			(char *) mBuffer + mItemSize * (where - 1 + count),
+			(char *) mBuffer + mItemSize * (where - 1),
+			mItemSize * (oldCount - (where - 1))
+			);
+
+		if (data) {
+			for (int i = 0; i < count; i++) {
+				memcpy((char *) mBuffer + mItemSize * (where - 1 + i), data, mItemSize);
+			}
+		}
+	} else {
+		for (int i = 0; i < count; i++) {
+			Add((const char *) data + i * mItemSize);
+		}
+	}
+}
+
+/*virtual*/ void LArray::RemoveItemsAt(int count, int where) {
+#line 94
+	_ASSERT(where > 0);
+
+	if (where < (mItemCount + 1)) {
+		memmove(
+			(char *) mBuffer + mItemSize * (where - 1),
+			(char *) mBuffer + mItemSize * (where - 1 + count),
+			mItemSize * (mItemCount - (where - 1 + count))
+		);
+	}
+
+	mItemCount -= count;
+}
+
+/*virtual*/ void LArray::Remove(const void* item) {
+	int index = FetchIndexOf(item);
+	if (index != 0)
+		RemoveItemsAt(1, index);
+}
+
+/*virtual*/ int LArray::FetchIndexOf(const void* item) const {
+	char *p = (char *) mBuffer;
+	for (int i = 0; i < mItemCount; i++) {
+		if (memcmp(p, item, mItemSize) == 0)
+			return i + 1;
+		p += mItemSize;
+	}
+	return 0;
+}
+
+/*virtual*/ int LArray::FetchItemAt(int index, void* outItem) const {
+#line 123
+	_ASSERT(index > 0);
+
+	if (index > mItemCount)
+		return false;
+
+	memcpy(outItem, (char *) mBuffer + mItemSize * (index - 1), mItemSize);
+	return true;
+}
+
+/*virtual*/ void LArray::AssignItemsAt(int count, int where, void* data) {
+	if (!mKeepSorted) {
+#line 134
+		_ASSERT(where > 0);
+
+		if ((where - 1 + count) > mItemCount)
+			Expand((where - 1 + count) - mItemCount);
+
+		if (data) {
+			for (int i = 0; i < count; i++) {
+				memcpy((char *) mBuffer + mItemSize * (where - 1 + i), data, mItemSize);
+			}
+		}
+	} else {
+		if ((where - 1 + count) > mItemCount)
+			Expand((where - 1 + count) - mItemCount);
+
+		RemoveItemsAt(count, where);
+		InsertItemsAt(count, where, data);
+	}
+}
+
+/*virtual*/ void LArray::Add(const void* item) {
+	if (!mKeepSorted) {
+		Expand(1);
+		memcpy((char *) mBuffer + mItemSize * (mItemCount - 1), item, mItemSize);
+	} else {
+		char *p = (char *) mBuffer;
+		int i;
+
+		for (i = 0; i < mItemCount; i++) {
+			if (mComparator->Compare(item, p, mItemSize, mItemSize) < 0) {
+				mKeepSorted = false;
+				InsertItemsAt(1, i + 1, item);
+				mKeepSorted = true;
+				break;
+			}
+			p += mItemSize;
+		}
+
+		if (i == mItemCount) {
+			mKeepSorted = false;
+			Add(item);
+			mKeepSorted = true;
+		}
+	}
+}
+
+void LArray::SetComparator(LComparator* comparator) {
+	if (mComparator && mOwnsComparator)
+		delete mComparator;
+	mComparator = comparator;
+}
+
+/*virtual*/ void LArray::ReadAsWord(T2Archive& archive) {
+	int itemSize;
+	int count;
+	int i;
+	unsigned char zero;
+	int totalSize;
+	unsigned short item;
+
+	archive >> itemSize;
+	archive >> count;
+	archive >> i;
+	archive >> i;
+	archive >> zero;
+	archive >> zero;
+	archive >> totalSize;
+
+	if (mItemCount > 0)
+		RemoveItemsAt(mItemCount, 1);
+
+	for (i = 0; i < count; i++) {
+		archive >> item;
+		unsigned int v = item;
+		Add(&v);
+	}
+
+	for (; i < totalSize / itemSize; i++) {
+		archive >> item;
+	}
+}
+
+/*virtual*/ void LArray::WriteAsWord(T2Archive& archive) {
+	int boop = 2;
+	archive << boop;
+
+	boop = mItemCount;
+	archive << boop;
+
+	int byteCount = boop * 2;
+	archive << byteCount;
+	archive << byteCount;
+
+	unsigned char zero = 0;
+	archive << zero;
+
+	zero = 0;
+	archive << zero;
+
+	int totalSize = mItemCount * 2;
+	archive << totalSize;
+
+	LArrayIterator iter(*this);
+	unsigned int item;
+	while (iter.Next(&item)) {
+		unsigned short v = item;
+		archive << v;
+	}
+}
+
+/*virtual*/ void LArray::ReadAsDWord(T2Archive& archive) {
+	unsigned long code;
+	archive >> code;
+#line 261
+	_ASSERT(code == 'Darr');
+
+	if (mItemCount > 0)
+		RemoveItemsAt(mItemCount, 1);
+
+	int count;
+	archive >> count;
+
+	unsigned int item;
+	for (int i = 0; i < count; i++) {
+		archive >> item;
+		Add(&item);
+	}
+}
+
+/*virtual*/ void LArray::ReadAsChar(T2Archive& archive) {
+	if (mItemCount > 0)
+		RemoveItemsAt(mItemCount, 1);
+
+	int i;
+	int elemSize;
+	int elemCount;
+	int byteCount;
+	int byteCount2;
+	int totalSize;
+	unsigned char buf;
+
+	archive >> elemSize;
+	archive >> elemCount;
+	archive >> byteCount;
+	archive >> byteCount2;
+	archive >> totalSize;
+
+	for (i = 0; i < elemCount; i++) {
+		archive >> buf;
+		Add(&buf);
+	}
+	for (; i < totalSize; i++) {
+		archive >> buf;
+	}
+}
+
+/*virtual*/ void LArray::WriteAsDWord(T2Archive& archive) {
+	unsigned long code = 'Darr';
+	archive << code;
+	archive << mItemCount;
+
+	LArrayIterator iter(*this);
+	unsigned int item;
+	while (iter.Next(&item)) {
+		archive << item;
+	}
+}
+
+/*virtual*/ void LArray::WriteAsChar(T2Archive& archive) {
+	int elemSize = 1;
+	int byteCount = mItemCount;
+	int byteCount2 = byteCount;
+	int totalSize = byteCount;
+
+	archive << elemSize;
+	archive << mItemCount;
+	archive << byteCount;
+	archive << byteCount2;
+	archive << totalSize;
+
+	LArrayIterator iter(*this);
+	unsigned char item;
+	while (iter.Next(&item)) {
+		archive << item;
+	}
+}
+
+LArrayIterator::LArrayIterator(const LArray& array, int index) {
+	mArray = &array;
+	mNextIndex = index;
+}
+
+LArrayIterator::LArrayIterator(const LArrayIterator& iter) {
+	mArray = iter.mArray;
+	mNextIndex = iter.mNextIndex;
+}
+
+LArrayIterator::~LArrayIterator() {
+}
+
+void LArrayIterator::ResetTo(int index) {
+#line 366
+	_ASSERT(index == 0 || index == 1);
+	mNextIndex = 1;
+}
+
+void LArrayIterator::Rewind() {
+	mNextIndex = 1;
+}
+
+void LArrayIterator::Seek(const LArrayIterator& iter) {
+	mArray = iter.mArray;
+	mNextIndex = iter.mNextIndex;
+}
+
+BOOL LArrayIterator::Next(void* item) {
+	if (mNextIndex > mArray->GetCount()) {
+		mCurrentIndex = 0;
+		return false;
+	} else {
+		mArray->FetchItemAt(mNextIndex, item);
+		mCurrentIndex = mNextIndex;
+		mNextIndex++;
+		return true;
+	}
+}
+
+BOOL LArrayIterator::Previous(void* item) {
+	mCurrentIndex = mNextIndex;
+	mNextIndex--;
+	if (mNextIndex < 1) {
+		mCurrentIndex = 0;
+		return false;
+	} else {
+		mArray->FetchItemAt(mNextIndex, item);
+		return true;
+	}
+}
+
+
+
+LDefaultComparator* LDefaultComparator::sDefaultComparator;
+
+/*virtual*/ int LDefaultComparator::Compare(const void* inItemOne, const void* inItemTwo, unsigned int inSizeOne, unsigned int inSizeTwo) const {
+	int result = memcmp(inItemOne, inItemTwo, (inSizeOne < inSizeTwo) ? inSizeOne : inSizeTwo);
+	if (result == 0)
+		result = inSizeOne - inSizeTwo;
+	return result;
+}
+
+/*virtual*/ BOOL LDefaultComparator::IsEqualTo(const void* inItemOne, const void* inItemTwo, unsigned int inSizeOne, unsigned int inSizeTwo) const {
+	if (inSizeOne != inSizeTwo) {
+		return 0;
+	} else {
+		return memcmp(inItemOne, inItemTwo, inSizeOne) == 0;
+	}
+}
+
+LDefaultComparator* LDefaultComparator::GetComparator() {
+	if (!sDefaultComparator)
+		sDefaultComparator = new LDefaultComparator;
+	return sDefaultComparator;
+}
+
+LDefaultComparator::LDefaultComparator() {
+}
+
+/*virtual*/ LDefaultComparator::~LDefaultComparator() {
+}