np2/generic/memdbg32.c - diff

Return to memdbg32.c CVS log

Up to [RetroPC.NET] / np2 / generic

Diff for /np2/generic/memdbg32.c between versions 1.1 and 1.7

version 1.1, 2004/03/09 23:39:19	version 1.7, 2004/04/08 13:51:52
Line 2	Line 2

#if defined(CPUCORE_IA32) && defined(SUPPORT_MEMDBG32)	#if defined(CPUCORE_IA32) && defined(SUPPORT_MEMDBG32)

	#include "strres.h"
#include "cpucore.h"	#include "cpucore.h"
#include "pccore.h"	#include "pccore.h"
#include "iocore.h"	#include "iocore.h"
Line 12 typedef struct {	Line 13 typedef struct {
UINT mode;	UINT mode;
int width;	int width;
int height;	int height;
	int bpp;
CMNPAL pal[MEMDBG32_PALS];	CMNPAL pal[MEMDBG32_PALS];
} MEMDBG32;	} MEMDBG32;

static MEMDBG32 memdbg32;	static MEMDBG32 memdbg32;

	static const char _mode0[] = "Real Mode";
	static const char _mode1[] = "Protected Mode";
	static const char _mode2[] = "Virutal86";
	static const char *modestr[3] = {_mode0, _mode1, _mode2};
	static const RGB32 md32pal[MEMDBG32_PALS] = {
	RGB32D(0x33, 0x33, 0x33),
	RGB32D(0x00, 0x00, 0x00),
	RGB32D(0xff, 0xaa, 0x00),
	RGB32D(0xff, 0x00, 0x00),
	RGB32D(0x11, 0x88, 0x11),
	RGB32D(0x00, 0xff, 0x00),
	RGB32D(0xff, 0xff, 0xff)};


void memdbg32_initialize(void) {	void memdbg32_initialize(void) {

memdbg32.width = MEMDBG32_BLOCKW * 128;	ZeroMemory(&memdbg32, sizeof(memdbg32));
memdbg32.height = (MEMDBG32_BLOCKH * 2 * 16) + 0;	memdbg32.width = (MEMDBG32_BLOCKW * 128) + 8;
}	memdbg32.height = (MEMDBG32_BLOCKH * 2 * 16) + 8;

void memdbg32_setpal(CMNPALFN *palfn) {

cmndraw_getpals(palfn, memdbg32.pal, MEMDBG32_PALS);
}	}

void memdbg32_getsize(int width, int height) {	void memdbg32_getsize(int width, int height) {
Line 40 void memdbg32_getsize(int width, int h	Line 50 void memdbg32_getsize(int width, int h
}	}
}	}

BOOL memdbg32_paint(CMNVRAM *vram, BOOL redraw) {	REG8 memdbg32_process(void) {

	return(MEMDBG32_FLAGDRAW);
	}

	BOOL memdbg32_paint(CMNVRAM *vram, CMNPALCNV cnv, BOOL redraw) {

UINT mode;	UINT mode;
UINT8 use[16*256];	UINT8 use[16*256];
	UINT32 pd[1024];
	UINT pdmax;
UINT i, j;	UINT i, j;
UINT32 pde;	UINT32 pde;
	UINT32 pdea;
UINT32 pte;	UINT32 pte;
	char str[4];

mode = 0;	mode = 0;
if (CPU_STAT_PM) {	if (CPU_STAT_PM) {
Line 62 BOOL memdbg32_paint(CMNVRAM *vram, BOOL	Line 81 BOOL memdbg32_paint(CMNVRAM *vram, BOOL
if ((!redraw) && (!CPU_STAT_PAGING)) {	if ((!redraw) && (!CPU_STAT_PAGING)) {
return(FALSE);	return(FALSE);
}	}
	if (vram == NULL) {
	return(FALSE);
	}
	if ((memdbg32.bpp != vram->bpp) \|\| (redraw)) {
	if (cnv == NULL) {
	return(FALSE);
	}
	(*cnv)(memdbg32.pal, md32pal, MEMDBG32_PALS, vram->bpp);
	memdbg32.bpp = vram->bpp;
	}

cmddraw_fill(vram, 0, 0, memdbg32.width, memdbg32.height,	cmndraw_fill(vram, 0, 0, memdbg32.width, memdbg32.height,
memdbg32.pal + MEMDBG32_PALBG);	memdbg32.pal[MEMDBG32_PALBDR]);
ZeroMemory(use, sizeof(use));	ZeroMemory(use, sizeof(use));
if (CPU_STAT_PAGING) {	if (CPU_STAT_PAGING) {
	pdmax = 0;
for (i=0; i<1024; i++) {	for (i=0; i<1024; i++) {
pde = cpu_memoryread_d(CPU_STAT_PDE_BASE + (i * 4));	pde = cpu_memoryread_d(CPU_STAT_PDE_BASE + (i * 4));
if (pde & CPU_PDE_PRESENT) {	if (pde & CPU_PDE_PRESENT) {
pde &= CPU_PDE_BASEADDR_MASK;	for (j=0; j<pdmax; j++) {
for (j=0; j<1024; j++) {	if (!((pde ^ pd[j]) & CPU_PDE_BASEADDR_MASK)) {
pte = cpu_memoryread_d(pde + (j * 4));	break;
if ((pte & CPU_PTE_PRESENT) && (pte < 0x1000000)) {	}
use[pte >> 12] = MEMDBG32_PALPAGE;	}
	if (j < pdmax) {
	pd[j] \|= pde & CPU_PDE_ACCESS;
	}
	else {
	pd[pdmax++] = pde;
	}
	}
	}
	for (i=0; i<pdmax; i++) {
	pde = pd[i];
	pdea = pde & CPU_PDE_BASEADDR_MASK;
	for (j=0; j<1024; j++) {
	pte = cpu_memoryread_d(pdea + (j * 4));
	if ((pte & CPU_PTE_PRESENT) && (pte < 0x1000000)) {
	if ((pde & CPU_PDE_ACCESS) && (pte & CPU_PTE_ACCESS)) {
	use[pte >> 12] = MEMDBG32_PALPAGE1;
	}
	else if (!use[pte >> 12]) {
	use[pte >> 12] = MEMDBG32_PALPAGE0;
}	}
}	}
}	}
Line 89 BOOL memdbg32_paint(CMNVRAM *vram, BOOL	Line 138 BOOL memdbg32_paint(CMNVRAM *vram, BOOL
}	}
for (i=0; i<32; i++) {	for (i=0; i<32; i++) {
for (j=0; j<128; j++) {	for (j=0; j<128; j++) {
cmddraw_fill(vram, j * MEMDBG32_BLOCKW, i * MEMDBG32_BLOCKH,	cmndraw_fill(vram, 8 + j * MEMDBG32_BLOCKW, i * MEMDBG32_BLOCKH,
MEMDBG32_BLOCKW - 1, MEMDBG32_BLOCKH - 1,	MEMDBG32_BLOCKW - 1, MEMDBG32_BLOCKH - 1,
memdbg32.pal + use[(i * 128) + j]);	memdbg32.pal[use[(i * 128) + j]]);
}	}
}	}
	for (i=0; i<16; i++) {
	SPRINTF(str, str_x, i);
	cmddraw_text8(vram, 0, i * MEMDBG32_BLOCKH * 2, str,
	memdbg32.pal[MEMDBG32_PALTXT]);
	}
	cmddraw_text8(vram, 0, memdbg32.height - 8, modestr[mode],
	memdbg32.pal[MEMDBG32_PALTXT]);
return(TRUE);	return(TRUE);
}	}

#endif	#endif

RetroPC.NET-CVS <cvs@retropc.net>

Removed from v.1.1
changed lines
	Added in v.1.7