memory.cpp

一款国产的8051模拟器（全部源代码） 本软件是一款8051模拟器

// memory.cpp: implementation of the memory class.
//
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "GlobalVar.h"
//#include "8051class.h"
#include "memory.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

memory::memory()
{

//	pCodeMemHook=new CodeMemHook[65536];
//	pIdataMemHook=new IdataMemHook[256];
//	pXdatamemHook=new XdataMemHook[65536];
//	idata=new BYTE[256];
#if OS==0
	memset(pCodeMemHookR,0,65536*sizeof(CodeMemHook));
	memset(pIdataMemHookR,0,256*sizeof(IdataMemHook));
	memset(pIdataBitMemHookR,0,256*sizeof(IdataBitMemHook));
	memset(pXdataMemHookR,0,65536*sizeof(XdataMemHook));

	memset(pCodeMemHookW,0,65536*sizeof(CodeMemHook));
	memset(pIdataMemHookW,0,256*sizeof(IdataMemHook));
	memset(pIdataBitMemHookW,0,256*sizeof(IdataMemHook));
	memset(pXdataMemHookW,0,65536*sizeof(XdataMemHook));

	memset(idata,0,256);
    //memset(xdata,0,65536);
#endif
#if OS==1 //WINDOWS
	ZeroMemory(pCodeMemHookR,65536*sizeof(CodeMemHook));
	ZeroMemory(pIdataMemHookR,256*sizeof(IdataMemHook));
	ZeroMemory(pIdataBitMemHookR,256*sizeof(IdataBitMemHook));
	ZeroMemory(pXdataMemHookR,65536*sizeof(XdataMemHook));

	ZeroMemory(pCodeMemHookW,65536*sizeof(CodeMemHook));
	ZeroMemory(pIdataMemHookW,256*sizeof(IdataMemHook));
	ZeroMemory(pIdataBitMemHookW,256*sizeof(IdataBitMemHook));
	ZeroMemory(pXdataMemHookW,65536*sizeof(XdataMemHook));

	ZeroMemory(idata,256);
/*	pCodeMemHookR=(CodeMemHook *)VirtualAlloc(NULL,65536*sizeof(CodeMemHook),MEM_RESERVE|MEM_COMMIT,PAGE_READWRITE);
	pIdataMemHookR=(IdataMemHook*)VirtualAlloc(NULL,256*sizeof(IdataMemHook),MEM_RESERVE|MEM_COMMIT,PAGE_READWRITE);
	pIdataBitMemHookR=(IdataBitMemHook*)VirtualAlloc(NULL,256*sizeof(IdataBitMemHook),MEM_RESERVE|MEM_COMMIT,PAGE_READWRITE);
	pXdataMemHookR=VirtualAlloc(NULL,65536*sizeof(XdataMemHook),MEM_RESERVE|MEM_COMMIT,PAGE_READWRITE);

	pCodeMemHookW=VirtualAlloc(NULL,65536*sizeof(CodeMemHook),MEM_RESERVE|MEM_COMMIT,PAGE_READWRITE);
	pIdataMemHookW=VirtualAlloc(NULL,256*sizeof(IdataMemHook),MEM_RESERVE|MEM_COMMIT,PAGE_READWRITE);
	pIdataBitMemHookW=VirtualAlloc(NULL,256*sizeof(IdataBitMemHook),MEM_RESERVE|MEM_COMMIT,PAGE_READWRITE);
	pXdataMemHookW=VirtualAlloc(NULL,65536*sizeof(XdataMemHook),MEM_RESERVE|MEM_COMMIT,PAGE_READWRITE);

	idata=VirtualAlloc(NULL,256,MEM_RESERVE|MEM_COMMIT,PAGE_READWRITE);
	*/
#endif
	//MemReset();
	VarNum=0;

}

memory::~memory()
{
/*#if OS==0
	delete [] pCodeMemHook;
	delete [] pIdataMemHook;
	delete [] pXdatamemHook
#endif
*/
}

BYTE memory::SetBit(BYTE addr,BYTE bit)//8051位操作
{
	
	
    BYTE addrbase;
    BYTE addroffset;
    BYTE addrbasebuf=addr&0xf0;
    BYTE addroffsetbuf=addr&0x0f;	
	//BYTE buf;
    if(addr<=0x7f)//判断地址空间?位寻址区?特殊寄存器区?
	{
		//计算位地址
        addrbase=(addr/8)+0x20;
        addroffset=(addr%8);
		//设置位
		//idata
        if(bit==0)
		{
			idata[addrbase]=idata[addrbase]&MarkBitMap0[addroffset];
		}
		else
		{
			idata[addrbase]=idata[addrbase]|MarkBitMap1[addroffset];
		}
	}
    else
	{
		//计算位地址
        if(addroffsetbuf>=8)
		{
			addrbase=addrbasebuf+8;
			addroffset=addroffsetbuf-8;
		}
		else
		{
			addrbase=addrbasebuf;
			addroffset=addroffsetbuf;
		}
		//设置位
		if(bit==0)
		{
			idata[addrbase]=idata[addrbase]&MarkBitMap0[addroffset];
		}
		else
		{
			idata[addrbase]=idata[addrbase]|MarkBitMap1[addroffset];
		}
	}
	if(pIdataBitMemHookW[addr]!=0)
	{
		pIdataBitMemHookFunW=pIdataBitMemHookW[addr];
		pIdataBitMemHookFunW(VarNum,Write,bit);
	}
	//SetidataMemByte(addrbase,buf);

return true;
}

BYTE memory::SetBitf(BYTE addr,BYTE bit)//8051位操作
{
	
	
    BYTE addrbase;
    BYTE addroffset;
    BYTE addrbasebuf=addr&0xf0;
    BYTE addroffsetbuf=addr&0x0f;	
	//BYTE buf;
    if(addr<=0x7f)//判断地址空间?位寻址区?特殊寄存器区?
	{
		//计算位地址
        addrbase=(addr/8)+0x20;
        addroffset=(addr%8);
		//设置位
		//idata
        if(bit==0)
		{
			idata[addrbase]=idata[addrbase]&MarkBitMap0[addroffset];
		}
		else
		{
			idata[addrbase]=idata[addrbase]|MarkBitMap1[addroffset];
		}
	}
    else
	{
		//计算位地址
        if(addroffsetbuf>=8)
		{
			addrbase=addrbasebuf+8;
			addroffset=addroffsetbuf-8;
		}
		else
		{
			addrbase=addrbasebuf;
			addroffset=addroffsetbuf;
		}
		//设置位
		if(bit==0)
		{
			idata[addrbase]=idata[addrbase]&MarkBitMap0[addroffset];
		}
		else
		{
			idata[addrbase]=idata[addrbase]|MarkBitMap1[addroffset];
		}
	}

return true;
}

BYTE memory::GetBit(BYTE addr)
{
    BYTE addrbase;
    BYTE addroffset;
    BYTE addrbasebuf=addr&0xf0;
    BYTE addroffsetbuf=addr&0x0f;
    BYTE returnByte;
    if(addr<=0x7f)//判断地址空间?位寻址区?特殊寄存器区?
	{
		//计算位地址
        addrbase=(addr/8)+0x20;
        addroffset=(addr%8);
		//读位
		
		
	}
    else
	{
		//计算位地址
        if(addroffsetbuf>=8)
		{
			addrbase=addrbasebuf+8;
			addroffset=addroffsetbuf-8;
		}
		else
		{
			addrbase=addrbasebuf;
			addroffset=addroffsetbuf;
		}
		//读位
		
		
	}
	if(pIdataBitMemHookR[addr]!=0)
	{
		pIdataBitMemHookFunR=pIdataBitMemHookR[addr];
		pIdataBitMemHookFunR(VarNum,Read,0);
	}
    returnByte=idata[addrbase]&MarkBitMap1[addroffset];
    if(returnByte==0)
	{
        return 0;
	}
    else
	{
        return 1;
	}
}

BYTE memory::GetBitf(BYTE addr)
{
    BYTE addrbase;
    BYTE addroffset;
    BYTE addrbasebuf=addr&0xf0;
    BYTE addroffsetbuf=addr&0x0f;
    BYTE returnByte;
    if(addr<=0x7f)//判断地址空间?位寻址区?特殊寄存器区?
	{
		//计算位地址
        addrbase=(addr/8)+0x20;
        addroffset=(addr%8);
		//读位
		
		
	}
    else
	{
		//计算位地址
        if(addroffsetbuf>=8)
		{
			addrbase=addrbasebuf+8;
			addroffset=addroffsetbuf-8;
		}
		else
		{
			addrbase=addrbasebuf;
			addroffset=addroffsetbuf;
		}
		//读位
		
		
	}
    returnByte=idata[addrbase]&MarkBitMap1[addroffset];
    if(returnByte==0)
	{
        return 0;
	}
    else
	{
        return 1;
	}
}

int memory::init()
{
	BYTE MarkBitMapx[]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};
	BYTE MarkBitMapy[]={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80};
    memcpy(MarkBitMap0,MarkBitMapx,8);
	memcpy(MarkBitMap1,MarkBitMapy,8);
	Am=(BYTE *)(idata+0xe0);
	DPTRm=(unsigned short *)(idata+0x82);
	SetidataMemByte(0x81,0x7);
	SPm=(BYTE *)(idata+0x81);
	CurrentCPULevel=127;
	CurrentIRQLevel=0;
	return true;
}

BYTE memory::GetCodeMemByte(unsigned short addr)
{
	return pcode[addr];
}

BYTE memory::GetxdataMemByte(unsigned short addr)
{
#if IS_ON_Xdata_Read_Mon
	if(pXdataMemHookR[addr]!=0)
	{
		pXdataMemHookFunR=pXdataMemHookR[addr];
		pXdataMemHookFunR(VarNum,Read,0);
	}
#endif
	return pxdata[addr];
}

BYTE memory::GetidataMemByte(BYTE addr)
{
	if(pIdataMemHookR[addr]!=0)
	{
		pIdataMemHookFunR=pIdataMemHookR[addr];
		pIdataMemHookFunR(VarNum,Read,0);
	}
	return idata[addr];
}

BYTE memory::SetCodeMemByte(unsigned short addr, BYTE data)
{
	pcode[addr]=data;
	////内存监控回调
	return true;
}

BYTE memory::SetxdataMemByte(unsigned short addr, BYTE data)
{
	pxdata[addr]=data;
	////内存监控回调
#if IS_ON_Xdata_Write_Mon
	if(pXdataMemHookW[addr]!=0)
	{
		pXdataMemHookFunW=pXdataMemHookW[addr];
		pXdataMemHookFunW(VarNum,Write,data);
	}
#endif
	return true;
}

BYTE memory::SetidataMemByte(BYTE addr, BYTE data)
{
	idata[addr]=data;
	////内存监控回调
	if(pIdataMemHookW[addr]!=0)
	{
		pIdataMemHookFunW=pIdataMemHookW[addr];
		pIdataMemHookFunW(VarNum,Write,data);
	}
	return true;
}

BYTE memory::GetCodeMemBytef(unsigned short addr)
{
	return pcode[addr];
}

BYTE memory::GetxdataMemBytef(unsigned short addr)
{
	return pxdata[addr];
}

BYTE memory::GetidataMemBytef(BYTE addr)
{
	return idata[addr];
}

BYTE memory::SetCodeMemBytef(unsigned short addr, BYTE data)
{
	pcode[addr]=data;
	return true;
}

BYTE memory::SetxdataMemBytef(unsigned short addr, BYTE data)
{
	pxdata[addr]=data;
	return true;
}

BYTE memory::SetidataMemBytef(BYTE addr, BYTE data)
{
	idata[addr]=data;
	return true;
}

__forceinline BYTE memory::NULLFun()
{
	return true;
}

void memory::AddPC(int PCcount)
{
	PCm=PCm+PCcount;
}

void memory::SetPC(unsigned int addr)
{
	PCm=addr;
}

int memory::MemReset()
{
	memset(idata,0,256);
	PCm=0;
	(*Am)=0;
	(*SPm)=7;
	CLKNUML=0;
	CLKNUMH=0;
	SetidataMemByte(P0,0xff);
	SetidataMemByte(P1,0xff);
	SetidataMemByte(P2,0xff);
	SetidataMemByte(P3,0xff);
	return true;
}