kernelmsg.cpp

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

#include "stdafx.h"
#include "GlobalVar.h"
#include "kernelmsg.h"

kernelMsg::kernelMsg(void)
{
	
}

kernelMsg::~kernelMsg(void)
{
}



int kernelMsg::init()
{
#if OS==0
	memset(KERNEL_EVENT,0,256*sizeof(EVENT_ON_ONECLOCK));
#endif
#if OS==1 //WINDOWS
	ZeroMemory(KERNEL_EVENT,256*sizeof(EVENT_ON_ONECLOCK));
#endif
	USEABLEEVENT.BOT=255;
	USEABLEEVENT.TOP=0;
	for(int i=0;i<=250;)//初始化可用时间事件缓冲，不是255，是为了防止追尾现象,因此也只有250个时间事件缓冲可用，即最多250个时间事件
	{
		USEABLEEVENT.USEABLEEVENT[i]=&(KERNEL_EVENT[i]);
		USEABLEEVENT.BOT++;
		i++;
	}
	USEABLEEVENT.BOT++;
	Clockpos=0;
//	CheckOutABackBit=SetupMemHook(PSW_P,BitSpace,Read,CheckOutABit);
//	CheckOutABackIdata=SetupMemHook(PSW,IdataSpace,Read,CheckOutAIdata);
	return true;
}


AllMemHook kernelMsg::SetupMemHook(DWORD addr,BYTE MemSpace,BYTE mode,AllMemHook Fun)
{
	AllMemHook BackFun;
	if(mode==Write)
	{
		switch(MemSpace)
		{
		//case CodeSpace:暂时不监控code空间
		///break;
		case BitSpace:
			BackFun=mem->pIdataBitMemHookW[addr];
			mem->pIdataBitMemHookW[addr]=Fun;
			break;
		case IdataSpace:
			BackFun=mem->pIdataMemHookW[addr];
			mem->pIdataMemHookW[addr]=Fun;
			break;
		case XdataSpace:
			BackFun=mem->pXdataMemHookW[addr];
			mem->pXdataMemHookW[addr]=Fun;
			break;
		default: return false;
		}
	}
	else
	{
		switch(MemSpace)
		{
		//case CodeSpace:暂时不监控code空间
		///break;
		case BitSpace:
			BackFun=mem->pIdataBitMemHookR[addr];
			mem->pIdataBitMemHookR[addr]=Fun;
			break;
		case IdataSpace:
			BackFun=mem->pIdataMemHookR[addr];
			mem->pIdataMemHookR[addr]=Fun;
			break;
		case XdataSpace:
			BackFun=mem->pXdataMemHookR[addr];
			mem->pXdataMemHookR[addr]=Fun;
			break;
		default: return false;
		}
	}

	return BackFun;
}

int kernelMsg::CallBackAfterUtterlyClock(ClockHook CallBackFun,EVENT_POS * pos)
{
	unsigned short buf=pos->CLOCK_POS;
	EVENT_ON_ONECLOCK * pevent=var8051[mem->VarNum]->inst->ClockEventPos[buf];
	if(pevent)
	{
		pevent->EVENTHOOKFUNQUEUE[pevent->BOT]=CallBackFun;
		pos->EVENT_QUEUE_POS=pevent->BOT;
		pevent->BOT++;
	}
	else
	{
		EBUF=USEABLEEVENT.USEABLEEVENT[USEABLEEVENT.TOP];
		USEABLEEVENT.TOP++;
		EBUF->EVENTHOOKFUNQUEUE[EBUF->TOP]=CallBackFun;
		pos->EVENT_QUEUE_POS=EBUF->BOT;
		EBUF->BOT++;
		var8051[mem->VarNum]->inst->ClockEventPos[pos->CLOCK_POS]=EBUF;
	}
	pos->CLOCK_POS=buf;
	return true;
}

unsigned short kernelMsg::GetCurrentClockpos()
{
	return Clockpos;
}

int kernelMsg::CallBackAfterRelativeClock(ClockHook CallBackFun,EVENT_POS * pos)
{
	unsigned short buf=Clockpos+pos->CLOCK_POS;
	EVENT_ON_ONECLOCK * pevent=var8051[mem->VarNum]->inst->ClockEventPos[buf];
	if(pevent)
	{
		pevent->EVENTHOOKFUNQUEUE[pevent->BOT]=CallBackFun;
		pos->EVENT_QUEUE_POS=pevent->BOT;
		pevent->BOT++;
	}
	else
	{
		EBUF=USEABLEEVENT.USEABLEEVENT[USEABLEEVENT.TOP];
		USEABLEEVENT.TOP++;
		EBUF->EVENTHOOKFUNQUEUE[EBUF->TOP]=CallBackFun;
		pos->EVENT_QUEUE_POS=EBUF->BOT;
		EBUF->BOT++;
		var8051[mem->VarNum]->inst->ClockEventPos[buf]=EBUF;
	}
	pos->CLOCK_POS=buf;
	return true;
}

int kernelMsg::UtterlyCancelCallBackByClocknum(EVENT_POS * pos)
{
	var8051[mem->VarNum]->inst->ClockEventPos[pos->CLOCK_POS]=0;
	return 1;
}
//调用此函数是比较危险的做法
int kernelMsg::CancelCallBackByClocknum(EVENT_POS * pos)
{
	EBUF=var8051[mem->VarNum]->inst->ClockEventPos[pos->CLOCK_POS];
	if(EBUF)
	{
		if((EBUF->BOT-EBUF->TOP)&0xff==1)
		{
			var8051[mem->VarNum]->inst->ClockEventPos[pos->CLOCK_POS]=0;
			USEABLEEVENT.USEABLEEVENT[USEABLEEVENT.BOT]=EBUF;
			USEABLEEVENT.BOT++;
		}
		else
		{
			EBUF->EVENTHOOKFUNQUEUE[pos->EVENT_QUEUE_POS]=0;
		}
		return 1;
	}
	return 0;
}

void kernelMsg::ClockCallHook(EVENT_ON_ONECLOCK *eventpos)
{
	for(;eventpos->TOP!=eventpos->BOT;)
	{
		if(eventpos->EVENTHOOKFUNQUEUE[eventpos->TOP])
		{
			eventpos->EVENTHOOKFUNQUEUE[eventpos->TOP](mem->VarNum,Clockpos);
		}
		eventpos->TOP++;
	}
	USEABLEEVENT.USEABLEEVENT[USEABLEEVENT.BOT]=eventpos;
	USEABLEEVENT.BOT++;
}