implemented cheat search

git-svn-id: https://pcsxr.svn.codeplex.com/svn/pcsxr@23829 e17a0e51-4ae3-4d35-97c3-1a29b211df97

6 files changed, 660 insertions, 30 deletions

diff --git a/libpcsxcore/cdriso.c b/libpcsxcore/cdriso.c
index 8de93763..07751ce5 100644
--- a/libpcsxcore/cdriso.c
+++ b/libpcsxcore/cdriso.c
@@ -33,7 +33,6 @@ FILE *cdHandle = NULL;
 static unsigned char cdbuffer[CD_FRAMESIZE_RAW * 10];
 
 char* CALLBACK CDR__getDriveLetter(void);
-unsigned char* CALLBACK CDR__getBufferSub(void);
 long CALLBACK CDR__configure(void);
 long CALLBACK CDR__test(void);
 void CALLBACK CDR__about(void);
@@ -279,6 +278,11 @@ static long CALLBACK ISOstop(void) {
 	return 0; // TODO
 }
 
+// gets subchannel data
+unsigned char* CALLBACK ISOgetBufferSub(void) {
+	return NULL; // TODO
+}
+
 void imageReaderInit(void) {
 	assert(hCDRDriver == NULL);
 
@@ -292,10 +296,10 @@ void imageReaderInit(void) {
 	CDR_getBuffer = ISOgetBuffer;
 	CDR_play = ISOplay;
 	CDR_stop = ISOstop;
+	CDR_getBufferSub = ISOgetBufferSub;
 
 	CDR_getStatus = CDR__getStatus;
 	CDR_getDriveLetter = CDR__getDriveLetter;
-	CDR_getBufferSub = CDR__getBufferSub;
 	CDR_configure = CDR__configure;
 	CDR_test = CDR__test;
 	CDR_about = CDR__about;
diff --git a/libpcsxcore/cheat.c b/libpcsxcore/cheat.c
index 284d833b..763c8d01 100644
--- a/libpcsxcore/cheat.c
+++ b/libpcsxcore/cheat.c
@@ -1,6 +1,6 @@
 /*  Cheat Support for PCSX-Reloaded
  *
- *  Copyright (c) 2009, Wei Mingzhi <whistler@openoffice.org>.
+ *  Copyright (c) 2009, Wei Mingzhi <whistler_wmz@users.sf.net>.
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -31,26 +31,12 @@ CheatCode *CheatCodes = NULL;
 int NumCodes = 0;
 static int NumCodesAllocated = 0;
 
-#define ALLOC_INCREMENT		100
+s8 *prevM = NULL;
+u32 *SearchResults = NULL;
+int NumSearchResults = 0;
+static int NumSearchResultsAllocated = 0;
 
-// cheat types
-#define CHEAT_CONST8		0x30	/* 8-bit Constant Write */
-#define CHEAT_CONST16		0x80	/* 16-bit Constant Write */
-#define CHEAT_INC16			0x10	/* 16-bit Increment */
-#define CHEAT_DEC16			0x11	/* 16-bit Decrement */
-#define CHEAT_INC8			0x20	/* 8-bit Increment */
-#define CHEAT_DEC8			0x21	/* 8-bit Decrement */
-#define CHEAT_SLIDE			0x50	/* Slide Codes */
-#define CHEAT_MEMCPY		0xC2	/* Memory Copy */
-
-#define CHEAT_EQU8			0xE0	/* 8-bit Equal To */
-#define CHEAT_NOTEQU8		0xE1	/* 8-bit Not Equal To */
-#define CHEAT_LESSTHAN8		0xE2	/* 8-bit Less Than */
-#define CHEAT_GREATERTHAN8  0xE3	/* 8-bit Greater Than */
-#define CHEAT_EQU16			0xD0	/* 16-bit Equal To */
-#define CHEAT_NOTEQU16		0xD1	/* 16-bit Not Equal To */
-#define CHEAT_LESSTHAN16	0xD2	/* 16-bit Less Than */
-#define CHEAT_GREATERTHAN16 0xD3	/* 16-bit Greater Than */
+#define ALLOC_INCREMENT		100
 
 void ClearAllCheats() {
 	int i;
@@ -457,3 +443,579 @@ int EditCheat(int index, const char *descr, char *code) {
 
 	return 0;
 }
+
+void FreeCheatSearchResults() {
+	if (SearchResults != NULL) {
+		free(SearchResults);
+	}
+	SearchResults = NULL;
+
+	NumSearchResults = 0;
+	NumSearchResultsAllocated = 0;
+}
+
+void FreeCheatSearchMem() {
+	if (prevM != NULL) {
+		free(prevM);
+	}
+	prevM = NULL;
+}
+
+void CheatSearchBackupMemory() {
+	if (prevM != NULL) {
+		memcpy(prevM, psxM, 0x200000);
+	}
+}
+
+static void CheatSearchInitBackupMemory() {
+	if (prevM == NULL) {
+		prevM = (s8 *)malloc(0x200000);
+		CheatSearchBackupMemory();
+	}
+}
+
+static void CheatSearchAddResult(u32 addr) {
+	if (NumSearchResults >= NumSearchResultsAllocated) {
+		NumSearchResultsAllocated += ALLOC_INCREMENT;
+
+		if (SearchResults == NULL) {
+			SearchResults = (u32 *)malloc(sizeof(u32) * NumSearchResultsAllocated);
+		}
+		else {
+			SearchResults = (u32 *)realloc(SearchResults, sizeof(u32) * NumSearchResultsAllocated);
+		}
+	}
+
+	SearchResults[NumSearchResults++] = addr;
+}
+
+void CheatSearchEqual8(u8 val) {
+	u32 i, j;
+
+	CheatSearchInitBackupMemory();
+
+	if (SearchResults == NULL) {
+		// search the whole memory
+		for (i = 0; i < 0x200000; i++) {
+			if (PSXMu8(i) == val) {
+				CheatSearchAddResult(i);
+			}
+		}
+	}
+	else {
+		// only search within the previous results
+		j = 0;
+
+		for (i = 0; i < NumSearchResults; i++) {
+			if (PSXMu8(SearchResults[i]) == val) {
+				SearchResults[j++] = SearchResults[i];
+			}
+		}
+
+		NumSearchResults = j;
+	}
+}
+
+void CheatSearchEqual16(u16 val) {
+	u32 i, j;
+
+	CheatSearchInitBackupMemory();
+
+	if (SearchResults == NULL) {
+		// search the whole memory
+		for (i = 0; i < 0x200000; i += 2) {
+			if (PSXMu16(i) == val) {
+				CheatSearchAddResult(i);
+			}
+		}
+	}
+	else {
+		// only search within the previous results
+		j = 0;
+
+		for (i = 0; i < NumSearchResults; i++) {
+			if (PSXMu16(SearchResults[i]) == val) {
+				SearchResults[j++] = SearchResults[i];
+			}
+		}
+
+		NumSearchResults = j;
+	}
+}
+
+void CheatSearchEqual32(u32 val) {
+	u32 i, j;
+
+	CheatSearchInitBackupMemory();
+
+	if (SearchResults == NULL) {
+		// search the whole memory
+		for (i = 0; i < 0x200000; i += 4) {
+			if (PSXMu32(i) == val) {
+				CheatSearchAddResult(i);
+			}
+		}
+	}
+	else {
+		// only search within the previous results
+		j = 0;
+
+		for (i = 0; i < NumSearchResults; i++) {
+			if (PSXMu32(SearchResults[i]) == val) {
+				SearchResults[j++] = SearchResults[i];
+			}
+		}
+
+		NumSearchResults = j;
+	}
+}
+
+void CheatSearchNotEqual8(u8 val) {
+	u32 i, j;
+
+	CheatSearchInitBackupMemory();
+
+	if (SearchResults == NULL) {
+		// search the whole memory
+		for (i = 0; i < 0x200000; i++) {
+			if (PSXMu8(i) != val) {
+				CheatSearchAddResult(i);
+			}
+		}
+	}
+	else {
+		// only search within the previous results
+		j = 0;
+
+		for (i = 0; i < NumSearchResults; i++) {
+			if (PSXMu8(SearchResults[i]) != val) {
+				SearchResults[j++] = SearchResults[i];
+			}
+		}
+
+		NumSearchResults = j;
+	}
+}
+
+void CheatSearchNotEqual16(u16 val) {
+	u32 i, j;
+
+	CheatSearchInitBackupMemory();
+
+	if (SearchResults == NULL) {
+		// search the whole memory
+		for (i = 0; i < 0x200000; i += 2) {
+			if (PSXMu16(i) != val) {
+				CheatSearchAddResult(i);
+			}
+		}
+	}
+	else {
+		// only search within the previous results
+		j = 0;
+
+		for (i = 0; i < NumSearchResults; i++) {
+			if (PSXMu16(SearchResults[i]) != val) {
+				SearchResults[j++] = SearchResults[i];
+			}
+		}
+
+		NumSearchResults = j;
+	}
+}
+
+void CheatSearchNotEqual32(u32 val) {
+	u32 i, j;
+
+	CheatSearchInitBackupMemory();
+
+	if (SearchResults == NULL) {
+		// search the whole memory
+		for (i = 0; i < 0x200000; i += 4) {
+			if (PSXMu32(i) != val) {
+				CheatSearchAddResult(i);
+			}
+		}
+	}
+	else {
+		// only search within the previous results
+		j = 0;
+
+		for (i = 0; i < NumSearchResults; i++) {
+			if (PSXMu32(SearchResults[i]) != val) {
+				SearchResults[j++] = SearchResults[i];
+			}
+		}
+
+		NumSearchResults = j;
+	}
+}
+
+void CheatSearchRange8(u8 min, u8 max) {
+	u32 i, j;
+
+	CheatSearchInitBackupMemory();
+
+	if (SearchResults == NULL) {
+		// search the whole memory
+		for (i = 0; i < 0x200000; i++) {
+			if (PSXMu8(i) >= min && PSXMu8(i) <= max) {
+				CheatSearchAddResult(i);
+			}
+		}
+	}
+	else {
+		// only search within the previous results
+		j = 0;
+
+		for (i = 0; i < NumSearchResults; i++) {
+			if (PSXMu8(SearchResults[i]) >= min && PSXMu8(SearchResults[i]) <= max) {
+				SearchResults[j++] = SearchResults[i];
+			}
+		}
+
+		NumSearchResults = j;
+	}
+}
+
+void CheatSearchRange16(u16 min, u16 max) {
+	u32 i, j;
+
+	CheatSearchInitBackupMemory();
+
+	if (SearchResults == NULL) {
+		// search the whole memory
+		for (i = 0; i < 0x200000; i += 2) {
+			if (PSXMu16(i) >= min && PSXMu16(i) <= max) {
+				CheatSearchAddResult(i);
+			}
+		}
+	}
+	else {
+		// only search within the previous results
+		j = 0;
+
+		for (i = 0; i < NumSearchResults; i++) {
+			if (PSXMu16(SearchResults[i]) >= min && PSXMu16(SearchResults[i]) <= max) {
+				SearchResults[j++] = SearchResults[i];
+			}
+		}
+
+		NumSearchResults = j;
+	}
+}
+
+void CheatSearchRange32(u32 min, u32 max) {
+	u32 i, j;
+
+	CheatSearchInitBackupMemory();
+
+	if (SearchResults == NULL) {
+		// search the whole memory
+		for (i = 0; i < 0x200000; i += 4) {
+			if (PSXMu32(i) >= min && PSXMu32(i) <= max) {
+				CheatSearchAddResult(i);
+			}
+		}
+	}
+	else {
+		// only search within the previous results
+		j = 0;
+
+		for (i = 0; i < NumSearchResults; i++) {
+			if (PSXMu32(SearchResults[i]) >= min && PSXMu32(SearchResults[i]) <= max) {
+				SearchResults[j++] = SearchResults[i];
+			}
+		}
+
+		NumSearchResults = j;
+	}
+}
+
+void CheatSearchIncreasedBy8(u8 val) {
+	u32 i, j;
+
+	assert(prevM != NULL); // not possible for the first search
+
+	j = 0;
+
+	for (i = 0; i < NumSearchResults; i++) {
+		if (PSXMu8(SearchResults[i]) - PrevMu8(SearchResults[i]) == val) {
+			SearchResults[j++] = SearchResults[i];
+		}
+	}
+
+	NumSearchResults = j;
+}
+
+void CheatSearchIncreasedBy16(u16 val) {
+	u32 i, j;
+
+	assert(prevM != NULL); // not possible for the first search
+
+	j = 0;
+
+	for (i = 0; i < NumSearchResults; i++) {
+		if (PSXMu16(SearchResults[i]) - PrevMu16(SearchResults[i]) == val) {
+			SearchResults[j++] = SearchResults[i];
+		}
+	}
+
+	NumSearchResults = j;
+}
+
+void CheatSearchIncreasedBy32(u32 val) {
+	u32 i, j;
+
+	assert(prevM != NULL); // not possible for the first search
+
+	j = 0;
+
+	for (i = 0; i < NumSearchResults; i++) {
+		if (PSXMu32(SearchResults[i]) - PrevMu32(SearchResults[i]) == val) {
+			SearchResults[j++] = SearchResults[i];
+		}
+	}
+
+	NumSearchResults = j;
+}
+
+void CheatSearchDecreasedBy8(u8 val) {
+	u32 i, j;
+
+	assert(prevM != NULL); // not possible for the first search
+
+	j = 0;
+
+	for (i = 0; i < NumSearchResults; i++) {
+		if (PrevMu8(SearchResults[i]) - PSXMu8(SearchResults[i]) == val) {
+			SearchResults[j++] = SearchResults[i];
+		}
+	}
+
+	NumSearchResults = j;
+}
+
+void CheatSearchDecreasedBy16(u16 val) {
+	u32 i, j;
+
+	assert(prevM != NULL); // not possible for the first search
+
+	j = 0;
+
+	for (i = 0; i < NumSearchResults; i++) {
+		if (PrevMu16(SearchResults[i]) - PSXMu16(SearchResults[i]) == val) {
+			SearchResults[j++] = SearchResults[i];
+		}
+	}
+
+	NumSearchResults = j;
+}
+
+void CheatSearchDecreasedBy32(u32 val) {
+	u32 i, j;
+
+	assert(prevM != NULL); // not possible for the first search
+
+	j = 0;
+
+	for (i = 0; i < NumSearchResults; i++) {
+		if (PrevMu32(SearchResults[i]) - PSXMu32(SearchResults[i]) == val) {
+			SearchResults[j++] = SearchResults[i];
+		}
+	}
+
+	NumSearchResults = j;
+}
+
+void CheatSearchIncreased8() {
+	u32 i, j;
+
+	assert(prevM != NULL); // not possible for the first search
+
+	j = 0;
+
+	for (i = 0; i < NumSearchResults; i++) {
+		if (PrevMu8(SearchResults[i]) < PSXMu8(SearchResults[i])) {
+			SearchResults[j++] = SearchResults[i];
+		}
+	}
+
+	NumSearchResults = j;
+}
+
+void CheatSearchIncreased16() {
+	u32 i, j;
+
+	assert(prevM != NULL); // not possible for the first search
+
+	j = 0;
+
+	for (i = 0; i < NumSearchResults; i++) {
+		if (PrevMu16(SearchResults[i]) < PSXMu16(SearchResults[i])) {
+			SearchResults[j++] = SearchResults[i];
+		}
+	}
+
+	NumSearchResults = j;
+}
+
+void CheatSearchIncreased32() {
+	u32 i, j;
+
+	assert(prevM != NULL); // not possible for the first search
+
+	j = 0;
+
+	for (i = 0; i < NumSearchResults; i++) {
+		if (PrevMu32(SearchResults[i]) < PSXMu32(SearchResults[i])) {
+			SearchResults[j++] = SearchResults[i];
+		}
+	}
+
+	NumSearchResults = j;
+}
+
+void CheatSearchDecreased8() {
+	u32 i, j;
+
+	assert(prevM != NULL); // not possible for the first search
+
+	j = 0;
+
+	for (i = 0; i < NumSearchResults; i++) {
+		if (PrevMu8(SearchResults[i]) > PSXMu8(SearchResults[i])) {
+			SearchResults[j++] = SearchResults[i];
+		}
+	}
+
+	NumSearchResults = j;
+}
+
+void CheatSearchDecreased16() {
+	u32 i, j;
+
+	assert(prevM != NULL); // not possible for the first search
+
+	j = 0;
+
+	for (i = 0; i < NumSearchResults; i++) {
+		if (PrevMu16(SearchResults[i]) > PSXMu16(SearchResults[i])) {
+			SearchResults[j++] = SearchResults[i];
+		}
+	}
+
+	NumSearchResults = j;
+}
+
+void CheatSearchDecreased32() {
+	u32 i, j;
+
+	assert(prevM != NULL); // not possible for the first search
+
+	j = 0;
+
+	for (i = 0; i < NumSearchResults; i++) {
+		if (PrevMu32(SearchResults[i]) > PSXMu32(SearchResults[i])) {
+			SearchResults[j++] = SearchResults[i];
+		}
+	}
+
+	NumSearchResults = j;
+}
+
+void CheatSearchDifferent8() {
+	u32 i, j;
+
+	assert(prevM != NULL); // not possible for the first search
+
+	j = 0;
+
+	for (i = 0; i < NumSearchResults; i++) {
+		if (PrevMu8(SearchResults[i]) != PSXMu8(SearchResults[i])) {
+			SearchResults[j++] = SearchResults[i];
+		}
+	}
+
+	NumSearchResults = j;
+}
+
+void CheatSearchDifferent16() {
+	u32 i, j;
+
+	assert(prevM != NULL); // not possible for the first search
+
+	j = 0;
+
+	for (i = 0; i < NumSearchResults; i++) {
+		if (PrevMu16(SearchResults[i]) != PSXMu16(SearchResults[i])) {
+			SearchResults[j++] = SearchResults[i];
+		}
+	}
+
+	NumSearchResults = j;
+}
+
+void CheatSearchDifferent32() {
+	u32 i, j;
+
+	assert(prevM != NULL); // not possible for the first search
+
+	j = 0;
+
+	for (i = 0; i < NumSearchResults; i++) {
+		if (PrevMu32(SearchResults[i]) != PSXMu32(SearchResults[i])) {
+			SearchResults[j++] = SearchResults[i];
+		}
+	}
+
+	NumSearchResults = j;
+}
+
+void CheatSearchNoChange8() {
+	u32 i, j;
+
+	assert(prevM != NULL); // not possible for the first search
+
+	j = 0;
+
+	for (i = 0; i < NumSearchResults; i++) {
+		if (PrevMu8(SearchResults[i]) == PSXMu8(SearchResults[i])) {
+			SearchResults[j++] = SearchResults[i];
+		}
+	}
+
+	NumSearchResults = j;
+}
+
+void CheatSearchNoChange16() {
+	u32 i, j;
+
+	assert(prevM != NULL); // not possible for the first search
+
+	j = 0;
+
+	for (i = 0; i < NumSearchResults; i++) {
+		if (PrevMu16(SearchResults[i]) == PSXMu16(SearchResults[i])) {
+			SearchResults[j++] = SearchResults[i];
+		}
+	}
+
+	NumSearchResults = j;
+}
+
+void CheatSearchNoChange32() {
+	u32 i, j;
+
+	assert(prevM != NULL); // not possible for the first search
+
+	j = 0;
+
+	for (i = 0; i < NumSearchResults; i++) {
+		if (PrevMu32(SearchResults[i]) == PSXMu32(SearchResults[i])) {
+			SearchResults[j++] = SearchResults[i];
+		}
+	}
+
+	NumSearchResults = j;
+}
diff --git a/libpcsxcore/cheat.h b/libpcsxcore/cheat.h
index 3e32c753..c5c74cd7 100644
--- a/libpcsxcore/cheat.h
+++ b/libpcsxcore/cheat.h
@@ -1,6 +1,6 @@
 /*  Cheat Support for PCSX-Reloaded
  *
- *  Copyright (C) 2009, Wei Mingzhi <whistler@openoffice.org>.
+ *  Copyright (C) 2009, Wei Mingzhi <whistler_wmz@users.sf.net>.
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -43,9 +43,69 @@ int AddCheat(const char *descr, char *code);
 void RemoveCheat(int index);
 int EditCheat(int index, const char *descr, char *code);
 
+void FreeCheatSearchResults();
+void FreeCheatSearchMem();
+void CheatSearchBackupMemory();
+
+void CheatSearchEqual8(u8 val);
+void CheatSearchEqual16(u16 val);
+void CheatSearchEqual32(u32 val);
+void CheatSearchNotEqual8(u8 val);
+void CheatSearchNotEqual16(u16 val);
+void CheatSearchNotEqual32(u32 val);
+void CheatSearchRange8(u8 min, u8 max);
+void CheatSearchRange16(u16 min, u16 max);
+void CheatSearchRange32(u32 min, u32 max);
+void CheatSearchIncreasedBy8(u8 val);
+void CheatSearchIncreasedBy16(u16 val);
+void CheatSearchIncreasedBy32(u32 val);
+void CheatSearchDecreasedBy8(u8 val);
+void CheatSearchDecreasedBy16(u16 val);
+void CheatSearchDecreasedBy32(u32 val);
+void CheatSearchIncreased8();
+void CheatSearchIncreased16();
+void CheatSearchIncreased32();
+void CheatSearchDecreased8();
+void CheatSearchDecreased16();
+void CheatSearchDecreased32();
+void CheatSearchDifferent8();
+void CheatSearchDifferent16();
+void CheatSearchDifferent32();
+void CheatSearchNoChange8();
+void CheatSearchNoChange16();
+void CheatSearchNoChange32();
+
 extern Cheat *Cheats;
 extern CheatCode *CheatCodes;
 extern int NumCheats;
 extern int NumCodes;
 
+extern s8 *prevM;
+extern u32 *SearchResults;
+extern int NumSearchResults;
+
+#define PREVM(mem)		(&prevM[mem])
+#define PrevMu8(mem)	(*(u8 *)PREVM(mem))
+#define PrevMu16(mem)	(SWAP16(*(u16 *)PREVM(mem)))
+#define PrevMu32(mem)	(SWAP32(*(u32 *)PREVM(mem)))
+
+// cheat types
+#define CHEAT_CONST8		0x30	/* 8-bit Constant Write */
+#define CHEAT_CONST16		0x80	/* 16-bit Constant Write */
+#define CHEAT_INC16			0x10	/* 16-bit Increment */
+#define CHEAT_DEC16			0x11	/* 16-bit Decrement */
+#define CHEAT_INC8			0x20	/* 8-bit Increment */
+#define CHEAT_DEC8			0x21	/* 8-bit Decrement */
+#define CHEAT_SLIDE			0x50	/* Slide Codes */
+#define CHEAT_MEMCPY		0xC2	/* Memory Copy */
+
+#define CHEAT_EQU8			0xE0	/* 8-bit Equal To */
+#define CHEAT_NOTEQU8		0xE1	/* 8-bit Not Equal To */
+#define CHEAT_LESSTHAN8		0xE2	/* 8-bit Less Than */
+#define CHEAT_GREATERTHAN8  0xE3	/* 8-bit Greater Than */
+#define CHEAT_EQU16			0xD0	/* 16-bit Equal To */
+#define CHEAT_NOTEQU16		0xD1	/* 16-bit Not Equal To */
+#define CHEAT_LESSTHAN16	0xD2	/* 16-bit Less Than */
+#define CHEAT_GREATERTHAN16 0xD3	/* 16-bit Greater Than */
+
 #endif
diff --git a/libpcsxcore/psxhw.c b/libpcsxcore/psxhw.c
index 27e69ec8..2e48469c 100644
--- a/libpcsxcore/psxhw.c
+++ b/libpcsxcore/psxhw.c
@@ -54,7 +54,7 @@ u8 psxHwRead8(u32 add) {
 #endif
 			return hard;
 	}
-	
+
 #ifdef PSXHW_LOG
 	PSXHW_LOG("*Known 8bit read at address %lx value %x\n", add, hard);
 #endif
@@ -111,7 +111,7 @@ u16 psxHwRead16(u32 add) {
 	 //	case 0x1f801054: hard = serial_status_read(); break;
 	 //	case 0x1f80105a: hard = serial_control_read(); break;
 	 //	case 0x1f80105e: hard = serial_baud_read(); break;
-	
+
 		case 0x1f801100:
 			hard = psxRcntRcount(0);
 #ifdef PSXHW_LOG
@@ -166,12 +166,12 @@ u16 psxHwRead16(u32 add) {
 			PSXHW_LOG("T2 target read16: %x\n", hard);
 #endif
 			return hard;
-	
+
 		//case 0x1f802030: hard =   //int_2000????
 		//case 0x1f802040: hard =//dip switches...??
 
 		default:
-			if (add>=0x1f801c00 && add<0x1f801e00) {
+			if (add >= 0x1f801c00 && add < 0x1f801e00) {
             	hard = SPU_readRegister(add);
 			} else {
 				hard = psxHu16(add); 
diff --git a/libpcsxcore/psxmem.h b/libpcsxcore/psxmem.h
index cc4616c6..ba880ed5 100644
--- a/libpcsxcore/psxmem.h
+++ b/libpcsxcore/psxmem.h
@@ -50,7 +50,7 @@ s8 *psxM;
 #define psxMs8(mem)		psxM[(mem) & 0x1fffff]
 #define psxMs16(mem)	(SWAP16(*(s16*)&psxM[(mem) & 0x1fffff]))
 #define psxMs32(mem)	(SWAP32(*(s32*)&psxM[(mem) & 0x1fffff]))
-#define psxMu8(mem)		(*(u8*)&psxM[(mem) & 0x1fffff]))
+#define psxMu8(mem)		(*(u8*)&psxM[(mem) & 0x1fffff])
 #define psxMu16(mem)	(SWAP16(*(u16*)&psxM[(mem) & 0x1fffff]))
 #define psxMu32(mem)	(SWAP32(*(u32*)&psxM[(mem) & 0x1fffff]))
 
@@ -119,8 +119,7 @@ u8** psxMemRLUT;
 
 #define PSXMu32ref(mem)	(*(u32*)PSXM(mem))
 
-
-#if !defined(PSXREC) && (defined(__x86_64__) || defined(__i386__) || defined(__sh__) || defined(__ppc__)) && !defined(NOPSXREC)
+#if !defined(PSXREC) && (defined(__x86_64__) || defined(__i386__) || defined(__ppc__)) && !defined(NOPSXREC)
 #define PSXREC
 #endif
 
diff --git a/libpcsxcore/r3000a.c b/libpcsxcore/r3000a.c
index b46ec124..6f45a1bb 100644
--- a/libpcsxcore/r3000a.c
+++ b/libpcsxcore/r3000a.c
@@ -51,6 +51,9 @@ int psxInit() {
 }
 
 void psxReset() {
+	FreeCheatSearchResults();
+	FreeCheatSearchMem();
+
 	psxCpu->Reset();
 
 	psxMemReset();
@@ -81,6 +84,8 @@ void psxShutdown() {
 	psxCpu->Shutdown();
 
 	ClearAllCheats();
+	FreeCheatSearchResults();
+	FreeCheatSearchMem();
 }
 
 void psxException(u32 code, u32 bd) {