memory.cpp

C++实现的模拟操作系统

		if(0==memory.index[i])
		{
			if(index<0)
				index=i;
			big++;
			if(big==room)
				return TRUE;
		}
		else
		{
			index=-1;
			big=0;
		}
	}
	return FALSE;
}

bool CMemory::Seekpub(int &index)				//在PUB中找空间，存放进程
{
	for(int i=1;i<=10;i++)
	{
		if(!memory.pcb[i].full)
		{
			index=i;
			return TRUE;
		}
	}
	return FALSE;
}

bool CMemory::Createprocess(CString name,double processid){

	Sprocess pcb;
	if(!name.Compare("needa")){
		pcb=Cteateother(name);
	}
	else if(!name.Compare("rdir"))
	{
		pcb=Cteaterdir();
	}
	else if(!name.Compare("delete"))
	{
		pcb=Cteatedelete();
	}
	else if(!name.Compare("create"))
	{
		pcb=Cteatechadir();
	}
	else if(!name.Compare("makdir"))
	{
		pcb=Cteatemakdir();
	}
	else if(!name.Compare("deldir"))
	{
		pcb=Cteatedeldir();
	}

	else if(!name.Compare("edit"))
	{
		pcb=Cteateedit();
	}
	else if(!name.Compare("type"))
	{
		pcb=Cteatetype();
	}
	

	else
	{
		CString Error="";
		pcb=CreateTran(name,&Error);
		if(Error.GetLength()>1)
		{
			AfxMessageBox("编译有错");
			return FALSE;
		}
	}
	
	int room=pcb.idictatenum;
	int index=0;
	if(!Seekroom(index,room))
		return FALSE;
	int pubindex=0;
	if(!Seekpub(pubindex))
		return FALSE;
	for(int i=0;i<room;i++)
	{
		memory.index[index+i]=pubindex;
	}
	
	memory.pcb[pubindex].address=index;
	memory.pcb[pubindex].pcb=pcb;
	memory.pcb[pubindex].pcb.iequipment=MD_NULL;//没有设备
	memory.pcb[pubindex].pcb.istate=1;          //就绪
	memory.pcb[pubindex].full=1;
	memory.pcb[pubindex].pcb.ID=processid;

    pdlg->Updataindexlist(memory);
	pdlg->Updatareadylist(memory);
	pdlg->Updatawaitlist(memory);
	return TRUE;
}
/////////////////////////////////////////////////////////////////////
//进程撤销
/////////////////////////////////////////////////////////////////////
bool CMemory::Destroyprocess(int processid){    //进程撤销
	int i;                       //删除进程所在的位置
	for(i=0;i<=10;i++){
		if(TRUE==memory.pcb[i].full){  //判断是否有进程
			if((int)memory.pcb[i].pcb.ID==processid){
				if(0==i)      //如果是闲逛进程
				{
					memory.pcb[i].pcb.istate=1; //为就绪状态	
					memory.pcb[i].pcb.idictaterun=0;
				}
				else
				{
					memory.pcb[i].full=FALSE;  //删除进程
					int index=memory.pcb[i].address;
					if(A==i)                   //释放占用的设备
						A=0;
					for(int j=0;j<2;j++)
					{	
						if(B[j]==i)
							B[j]=0;
						if(C[j]==i)
							C[j]=0;
					}
					for(j=0;j<memory.pcb[i].pcb.idictatenum;j++)
					{
						memory.index[index+j]=0;    //内存回收
					}
				}
				break;
			}
		}
	}
	
	pdlg->Updatareadylist(memory);
	pdlg->Updataindexlist(memory);
	pdlg->Updatawaitlist(memory);
	return TRUE;
}
/////////////////////////////////////////////////////////////////////
//进程阻塞
/////////////////////////////////////////////////////////////////////
bool CMemory::Blockprocess(Sprocess process){       //进程阻塞
	int i;
	for(i=0;i<=10;i++){
		if(TRUE==memory.pcb[i].full){  //判断是否有进程
			if(memory.pcb[i].pcb.istate==2){            //寻找运行的进程
				break;
			}
		}
	}
	memory.pcb[i].pcb=process;                     //现场保护
	if(i==0){                                      //如果为idle进程
		memory.pcb[i].pcb.istate=1;                //设置为就绪
		memory.pcb[i].pcb.idictaterun=0;
	}
	else{
		memory.pcb[i].pcb.istate=0;                //设置中断
		memory.pcb[i].pcb.waittime=0;              //设置等待时间
	}
	pdlg->Updatareadylist(memory);
	pdlg->Updatawaitlist(memory);
	return TRUE;
}
/////////////////////////////////////////////////////////////////////
//增加等待进程的等待时间.程序一直运行
/////////////////////////////////////////////////////////////////////
void CMemory::Addprocesswaitime(){
	int i;
	int num=0;              //存储就绪进程的个数
	for(i=1;i<=10;i++){
		if(memory.pcb[i].full){  //判断是否有进程
			if(memory.pcb[i].pcb.istate==1){
				num++;
			}
		}
	}
	for(i=1;i<=10;i++){
		if(memory.pcb[i].full){  //判断是否有进程
			if(memory.pcb[i].pcb.istate==0){    //为中断进程
				if(memory.pcb[i].pcb.ihaltreasion==1){//如果为中断原因为时间
					if(memory.pcb[i].pcb.waittime>=num){ //如果等待时间大于就绪进程的个数，则唤醒。
						Awakeprocess(i);                 //唤醒第i个进程
					}
					else{
						memory.pcb[i].pcb.waittime++;
					}
				}
				else{                                       //如果为其他原因
					memory.pcb[i].pcb.waittime++;
				}
			}
		}
	}
}
/////////////////////////////////////////////////////////////////////
//进程唤醒
/////////////////////////////////////////////////////////////////////
bool CMemory::Awakeprocess(int i){         //进程唤醒
	
	memory.pcb[i].pcb.istate=1;            //修改第i个进程为就绪
	memory.pcb[i].pcb.waittime=0;
	pdlg->Updatareadylist(memory);
	pdlg->Updatawaitlist(memory);
	return TRUE;
}
/////////////////////////////////////////////////////////////////////
//设置主存中进程i的状态 state.
bool CMemory::Setm_pro_state(int i,int state){     //设置主存中进程i的状态 state
	memory.pcb[i].pcb.istate=state;
	pdlg->Updatareadylist(memory);
	pdlg->Updatawaitlist(memory);
	return TRUE;
}
//////////////////////////////////////////////////////////////////////
//显示主存客户区
//////////////////////////////////////////////////////////////////////
bool CMemory::IsA()       //判断是否有B设备空闲
{
	if(0==A)
		return TRUE;
	else
		return FALSE;
}
bool CMemory::IsB(int &b)         //判断是否有B设备空闲
{
	for(int i=0;i<2;i++)
	{
		if(0==B[i])
		{
			b=i;
			return TRUE;
		}
	}
	return FALSE;
}
bool CMemory::IsC(int &c)         //判断是否有C设备空闲
{
	for(int i=0;i<2;i++)
	{
		if(0==C[i])
		{
			c=i;
			return TRUE;
		}
	}
	return FALSE;
}

void CMemory::Showindex(){                         //显示主存客户区

	

	pdlg->Updatashow();
}

void CMemory::DealHalt()			//处理中断
{
	int num=0;    //存进程数；
	int i;
	int b,c;
	for(i=1;i<=10;i++)     //计算进程数
	{
		if(memory.pcb[i].full)
			if(0!=memory.pcb[i].pcb.istate)
				num++;
	}
	for(i=1;i<=10;i++)
	{
		if(memory.pcb[i].full)    //如果有进程
		{
			if(0==memory.pcb[i].pcb.istate)     //如果是中断
			{
				switch(memory.pcb[i].pcb.ihaltreasion)
				{
				case HALT_TIME:
					memory.pcb[i].pcb.waittime++;
					if(memory.pcb[i].pcb.waittime>=num)//如果等等时间超过进程数
					{
						memory.pcb[i].pcb.istate=1;    //就绪队列
						memory.pcb[i].pcb.waittime=0;
						pdlg->Updatareadylist(memory);
						pdlg->Updatawaitlist(memory);
					}
					break;
				case HALT_NA:
					if(IsA()) //如果A设备没有使用
					{
						memory.pcb[i].pcb.istate=1;    //就绪队列
						memory.pcb[i].pcb.iequipment=MD_A; //占用了A设备
						memory.pcb[i].pcb.waittime=0;
						A=i;   
						pdlg->Updatareadylist(memory);
						pdlg->Updatawaitlist(memory);
					}
					else
					{
						memory.pcb[i].pcb.waittime++;
					}
					break;
				case  HALT_NB:
					if(IsB(b)) //如果A设备没有使用
					{
						memory.pcb[i].pcb.istate=1;    //就绪队列
						memory.pcb[i].pcb.iequipment=MD_B; //占用了A设备
						memory.pcb[i].pcb.waittime=0;
						B[b]=i;
						pdlg->Updatareadylist(memory);
						pdlg->Updatawaitlist(memory);
					}
					else
					{
						memory.pcb[i].pcb.waittime++;
					}
					break;
				case HALT_NC:
					if(IsC(c)) //如果A设备没有使用
					{
						memory.pcb[i].pcb.istate=1;    //就绪队列
						memory.pcb[i].pcb.iequipment=MD_C; //占用了A设备
						memory.pcb[i].pcb.waittime=0;
						C[c]=i;
						pdlg->Updatareadylist(memory);
						pdlg->Updatawaitlist(memory);
					}
					else
					{
						memory.pcb[i].pcb.waittime++;
					}
					break;
				case HALT_NBC:
					if(IsB(b)&&IsC(c))
					{
						memory.pcb[i].pcb.istate=1;    //就绪队列
						memory.pcb[i].pcb.iequipment=MD_BC; //占用了A设备
						memory.pcb[i].pcb.waittime=0;
						C[c]=i;
						B[b]=i;
						pdlg->Updatareadylist(memory);
						pdlg->Updatawaitlist(memory);
					}
					else
					{
						memory.pcb[i].pcb.waittime++;
					}
					break;
				case HALT_NAC:
					if(IsA()&&IsC(c))
					{
						memory.pcb[i].pcb.istate=1;    //就绪队列
						memory.pcb[i].pcb.iequipment=MD_AC; //占用了A设备
						memory.pcb[i].pcb.waittime=0;
						C[c]=i;
						A=i;
						pdlg->Updatareadylist(memory);
						pdlg->Updatawaitlist(memory);
					}
					else
					{
						memory.pcb[i].pcb.waittime++;
					}
					break;
				case HALT_NAB:
					if(IsA()&&IsB(b))
					{
						memory.pcb[i].pcb.istate=1;    //就绪队列
						memory.pcb[i].pcb.iequipment=MD_AB; //占用了A设备
						memory.pcb[i].pcb.waittime=0;
						B[b]=i;
						A=i;
						pdlg->Updatareadylist(memory);
						pdlg->Updatawaitlist(memory);
					}
					else
					{
						memory.pcb[i].pcb.waittime++;
					}
					break;
				case HALT_NABC:
					if(IsA()&&IsC(c)&&IsB(b))
					{
						memory.pcb[i].pcb.istate=1;    //就绪队列
						memory.pcb[i].pcb.iequipment=MD_ABC; //占用了A设备
						memory.pcb[i].pcb.waittime=0;
						C[c]=i;
						A=i;
						B[b]=i;
						pdlg->Updatareadylist(memory);
						pdlg->Updatawaitlist(memory);
					}
					else
					{
						memory.pcb[i].pcb.waittime++;
					}
					break;
				case HALT_NOUT:
					break;
				case HALT_NINPUT:
					break;
					
				}
			}
		}
	}
}

bool CMemory::Tran(CString str,Sdictate *di,CString *Error)       //编译指令
{