very cool debug display list (#348)

* added a very cool debug display list ^^ (prints variables to screen)

* Decompiled various functions

1 files changed, 251 insertions, 0 deletions

diff --git a/src/debug/debug.c b/src/debug/debug.c
new file mode 100644
index 000000000..cdc333dc5
--- /dev/null
+++ b/src/debug/debug.c
@@ -0,0 +1,251 @@
+#include <ultra64.h>
+#include <debug.h>
+#include "debug.inc.c"
+#include <libc/stdio.h>
+
+#if DVDL
+
+u8 sDisplayListState = OK;
+
+static u32 variable_to_u64(variableWatchAttributes *);
+static void round_up_float(u32 *, u8);
+static void u64_to_string(variableWatchAttributes *, u32, u8);
+static u32 _strlen(const char *);
+static void _memcpy(char *, const char *, u32);
+
+void display_dvdl(void) {
+	u32 variable;
+	u32 i, vNameLen;
+	u32 arraySize = sizeof(gMainVariableWatchList) / sizeof(variableWatchAttributes);
+	s32 text_y_possition = TEXT_Y_POSSITION;
+	u8 base;
+	char *vName, *cBuffer;
+
+	load_debug_font();
+	for (i = 0; i < arraySize; i++) {
+		variableWatchAttributes *currentAttribute = &gMainVariableWatchList[i];
+		currentAttribute->characterBuffer = currentAttribute->buffer;
+		cBuffer = currentAttribute->characterBuffer;
+		vName = currentAttribute->variableName;
+
+		variable = variable_to_u64(currentAttribute);
+		base = 0;
+
+		if (currentAttribute->variableFlag & (DISPLAY_FLOAT_AS_TYPE | DISPLAY_FLOAT_WITH_ROUNDING)) {
+			if (currentAttribute->variableFlag & DISPLAY_FLOAT_NUMBER) {
+				sDisplayListState = BAD;
+			} else if (currentAttribute->variableFlag & DISPLAY_FLOAT_WITH_ROUNDING) {
+				round_up_float(&variable, currentAttribute->variableSize);
+			}
+		}
+
+		switch (currentAttribute->variableFlag & 0x8F) {
+			case DISPLAY_FLOAT_NUMBER:
+				sprintf(cBuffer, "%.3f", *(f32*)&variable);
+				break;
+			case DISPLAY_HEXIDECIMAL_NUMBER:
+				base = HEXIDECIMAL;
+				break;
+			case DISPLAY_DECIMAL_NUMBER:
+				base = DECIMAL;
+				break;
+			case DISPLAY_OCTAL_NUMBER:
+				base = OCTAL;
+				break;
+			case DISPLAY_BINARY_NUMBER:
+				base = BINARY;
+				break;
+			default:
+				sDisplayListState = BAD;
+		}
+		if (base) {
+			u64_to_string(currentAttribute, variable, base);
+		}
+
+		if (sDisplayListState == BAD) {
+			cBuffer = "NaN";
+		}
+		sDisplayListState = OK;
+
+		vNameLen = _strlen(vName);
+
+		debug_print_str2(TEXT_X_POSSITION, text_y_possition, vName);
+		debug_print_str2(TEXT_X_POSSITION + (vNameLen * 0x8), text_y_possition, cBuffer);
+		text_y_possition += 0x8;
+	}
+	gSPDisplayList(gDisplayListHead++, D_0D007EB8);
+	gSPDisplayList(gDisplayListHead++, D_020076E0);
+	func_80093C98(1);
+}
+
+static u32 variable_to_u64(variableWatchAttributes *attribute) {
+	u32 variable;
+
+	switch (attribute->variableSize) {
+		case sizeof(u8): 
+			variable = *((u8*) attribute->variablePointer);
+			break;
+		case sizeof(u16):	
+			variable = *((u16*) attribute->variablePointer);
+			break;
+		case sizeof(u32):
+		case sizeof(u64):	
+			variable = *((u32*) attribute->variablePointer); // no floating point rounding
+			break;
+		default:
+			sDisplayListState = BAD;
+	}
+
+	return variable;
+}
+
+static void round_up_float(u32 *variable, u8 variableSize) {
+	switch (variableSize) {
+		case sizeof(u64):
+		case sizeof(u32):
+			*variable = (u32) (*(f32*) &*variable); 
+			break;
+		default:
+			sDisplayListState = BAD;
+	}
+}
+
+static void u64_to_string(variableWatchAttributes *attribute, u32 variable, u8 base) {
+	s32 signedVariable;
+	u32 stringDifference, indexesToFillAVariable, stringLengthWithZero;
+	u32 indexesToFillAByte, upperIndex, remainder;
+	u32 stringLength, lowerIndex, i;
+	u8 variableSize;
+	char *bufferedString;
+	char swapRegister;
+
+	if (sDisplayListState == BAD) {
+		return;
+	}
+
+	bufferedString 	= attribute->characterBuffer;
+	variableSize 	= attribute->variableSize;
+
+	// converts a minus number into it's unsigned equivalent for proper string conversion
+	if (attribute->variableFlag & DISPLAY_SIGNED_NUMBER) {
+		switch (variableSize) {
+			case sizeof(u8):
+				signedVariable = (s8) variable;
+				if (signedVariable < 0) {	
+					signedVariable = -signedVariable;
+					variable = (u8) signedVariable;
+					*bufferedString = '-';
+					bufferedString++;
+				}
+				break;
+			case sizeof(u16):
+				signedVariable = (s16) variable;
+				if (signedVariable < 0) {
+					signedVariable = -signedVariable;
+					variable = (u16) signedVariable;
+					*bufferedString = '-';
+					bufferedString++;
+				}
+				break;
+			case sizeof(u32):
+			case sizeof(u64):
+				signedVariable = (s32) variable;
+				if (signedVariable < 0) {	
+					signedVariable = -signedVariable;
+					variable = (u32) signedVariable;
+					*bufferedString = '-';
+					bufferedString++;
+				}
+				break;
+		}
+	}
+
+	stringLength = 0;
+
+	// convert u64 into a string but it gets put in reverse
+	if (base != HEXIDECIMAL) {
+		do {	
+			stringLength++;
+			*bufferedString = variable % base + '0';
+			bufferedString++;
+			variable /= base;	
+		} while (variable != 0);
+	} else {
+		do {
+			stringLength++;
+			remainder = variable % 16;
+
+			if ((remainder >= 0) && (remainder <= 9)) {
+        		*bufferedString = '0' + remainder;
+    		} else {
+        		*bufferedString = 'A' + (remainder - 10);
+        	}
+
+			bufferedString++;
+			variable /= 16;
+		} while (variable != 0);
+	}
+
+	bufferedString -= stringLength;	
+	upperIndex = stringLength - 1; 
+
+	// flip string 4321 --> 1234
+	for (lowerIndex = 0; lowerIndex < stringLength >> 1; lowerIndex++) {
+		swapRegister = bufferedString[lowerIndex];
+		bufferedString[lowerIndex] = bufferedString[upperIndex];
+		bufferedString[upperIndex] = swapRegister;
+		upperIndex--;
+	}
+
+	switch (base) {
+		case BINARY:
+			indexesToFillAByte = 8;
+			break;
+		case OCTAL:
+			indexesToFillAByte = 3;
+			break;
+		case DECIMAL:
+			bufferedString[stringLength] = '\0';
+			return;
+		case HEXIDECIMAL:
+			indexesToFillAByte = 2;
+			break;
+	}
+
+	stringLengthWithZero = stringLength - 1;
+	indexesToFillAVariable = indexesToFillAByte * variableSize;
+	stringDifference = indexesToFillAVariable - stringLengthWithZero;
+
+	// makes space and fills in extra space. u32 FE -> 000000FE
+	for (i = stringLength; i > 0; i--) {
+		bufferedString[stringDifference + i - 2] = bufferedString[i - 1];
+	}
+	for (i = 0; i < stringDifference - 1; i++) {
+		bufferedString[i] = '0';
+	}
+	bufferedString[indexesToFillAVariable] = '\0';
+}
+
+static u32 _strlen(const char *str) {
+	u32 len;
+	
+	len = 0;
+	for (; *str != '\0'; str++) {
+		len++;
+	}
+
+	return len;
+}
+
+// unused but may be useful
+static void _memcpy(char *destStr, const char *copyStr, u32 copySize) {
+	u32 i;
+
+	for (i = 0; i < copySize; i++) {
+		*destStr = *copyStr;
+		destStr++;
+		copyStr++;
+	}	
+}
+
+#endif