操作系统——pcb模拟.txt

该程序使用tc2.0编译

    mem->Sts = INUSE;
    return mem;
   }
  }
  last = now;
  now = last->Next;
 }
 return NULL;
}

int ReleaseMem(MemBlock *mem)
{
 MemBlock *last,*now;
 if (MemTable==NULL) return FALSE;
 last = MemTable;
 now = last->Next;
 if (last == mem)/*如果第一个就是要释放的分区*/
 {
  last->Sts = IDLE;
  if (now!=NULL && now->Sts==IDLE)/*如果后邻接分区也是空闲的*/
  {
   last->Size = last->Size+now->Size;
   free(now);
  }
  return TRUE;
 }
 while (now!=NULL)/*在链表中寻找要释放的分区*/
 {
  if (now == mem)/*找到了*/
  {
   now->Sts = IDLE;
   if (now->Next != NULL && now->Next->Sts==IDLE)/*察看后相邻分区是否空闲*/
   {
    last->Next = now->Next;
    now->Next->Offset = now->Offset;
    now->Next->Size = now->Size + now->Next->Size;
    free(now);
    now = last->Next;
   }
   if (last->Sts == IDLE)/*察看前相邻分区是否空闲*/
   {
    last->Next = now->Next;
    last->Size = last->Size + now->Size;
    free(now);
    now = last->Next;
   }
   return TRUE;
  }
  last = now;
  now = last->Next;
 }
 return FALSE;
}
/****************************************************************/

 


/*图形系统相关函数声明及全局变量定义*/
/****************************************************************/
#define HEIGHT 11
#define WIDTH 20
#define HN(n) HEIGHT*(n)
#define HNT(n) HEIGHT*(n)-1
/****************************************************************/
int InitGraph();/*初始化图形系统*/
int DrawProcHeader(int x, int y);/*在x,y处绘制进程控制块表头结构*/
int DrawProcStruct(int x, int y, PCB* pcb);/*在x,y处绘制进程控制块pcb数据*/
int DrawAllProc();/*绘制进程列表*/
int DrawFrame();/*绘制图形框架*/
int DrawMemStruct(int x, int y, MemBlock* mem);/*绘制分区mem的数据*/
int DrawMemTable();/*绘制分区表*/
int DrawConsole();/*绘制控制台*/
int DrawConsoleHelp();/*绘制控制台帮助信息*/
int DrawConsoleEcho();/*绘制控制台命令提示符*/
int gprintf( int xloc, int yloc, char *fmt, ... );/*图形系统中的格式输出*/
/****************************************************************/
/*系统控制台(用户接口)相关函数声明及相关全局变量*/
/****************************************************************/
enum _ConsoleCmd/*从系统控制台输入的命令枚举*/
{
 CMD_EXIT =0,/*退出系统*/
 CMD_PAUSE,/*系统时间暂停*/
 CMD_PROC,/*加入新的进程*/
 CMD_READY,/*将某个挂起进程转入就绪队列*/
 CMD_HIBAT,/*增加道数*/
 CMD_LOBAT,/*减少道数*/
};
typedef enum _ConsoleCmd ConsoleCmd;
/****************************************************************/
char StrCmd[][6]={"exit\0","pause\0","proc\0","ready\0","hibat\0","lobat\0"};
char CmdString[30];
/****************************************************************/
int InitConsole();/*初始化控制台*/
ConsoleCmd GetConsoleCmd();/*从控制台输入缓冲得到用户命令*/
UINT GetData(int n);/*得到第n个数据参数(n>=1)*/
int ExecuteCmd();/*分析命令并得到命令*/
int CmdKeyDown(char ch);/*命令缓冲得到新的键盘输入*/
/****************************************************************/
int InitGraph()
{
 int    GraphDriver, GraphMode;
 GraphDriver = DETECT;
 initgraph( &GraphDriver, &GraphMode, "" );
 if( graphresult() != grOk )
  return FALSE;
 cleardevice();
 return TRUE;
}
int DrawProcHeader(int x, int y)
{
 gprintf(x,y,"ID");
 gprintf(x+31,y,"Prio");
 gprintf(x+72,y,"Time");
 gprintf(x+113,y,"Offset");
}
int DrawProcStruct(int x, int y, PCB* pcb)
{
 bar(x,y,x+197,y+HEIGHT-2);
 if (pcb->PID>=0)/*绘制数据*/
 {
  gprintf(x,y,"%d", pcb->PID);
  gprintf(x+32,y,"%d",pcb->Prior);
  gprintf(x+73,y,"%d",pcb->Time);
  gprintf(x+114,y,"%u",pcb->Mem->Offset);
 }
 else
 {
  gprintf(x,y,"idle process");
  gprintf(x+114,y,"%u",pcb->Mem->Offset);
 }
 return TRUE;
}
int DrawAllProc()
{
 int run=0,sus=0,red=0,i;
 PCB *last, *now;
 setfillstyle(1, BLACK);
 if (ProcQueue==NULL) return FALSE;
 last = ProcQueue;
 now = last->Next;
 switch (last->Sts)
 {
 case RUN: DrawProcStruct(1,HN(3+(run++)),last); break;
 case SUSPEND: DrawProcStruct(201,HN(3+(sus++)),last); break;
 case READY: DrawProcStruct(201,HN(22+(red++)),last); break;
 }
 while (now!=NULL)
 {
  switch (now->Sts)
  {
  case RUN: DrawProcStruct(1,HN(3+(run++)),now); break;
  case SUSPEND: DrawProcStruct(201,HN(3+(sus++)),now); break;
  case READY: DrawProcStruct(201,HN(22+(red++)),now); break;
  }
  last = now;
  now = last->Next;
 }
 bar(1,HN(3+run),198,HN(26)+HEIGHT-2);/*擦除运行进程列表与控制台之间的空隙*/
 bar(201,HN(3+sus),398,HN(19)+HEIGHT-2);/*擦除挂起队列与就绪队列之间的空隙*/
 bar(201,HN(22+red),398,478);/*擦除就绪队列下面的空隙*/
 rectangle(199,HNT(1),399,478);/*补上误擦除的线*/
 return TRUE;
}
int DrawFrame()
{
 rectangle(0,HNT(1),639,479);
 gprintf(200,0,"Multi-Batchs System Emulation");
 rectangle(199,HNT(1),399,479);
 rectangle(0,HNT(2),639,HNT(3));/*最上方的表头框*/

 rectangle(0,HNT(27),199,HNT(28));/*系统控制台表头框*/
 rectangle(0,HNT(28),199,HNT(29));

 rectangle(199,HNT(20),399,HNT(21));
 rectangle(199,HNT(21),399,HNT(22));/*就绪进程队列表头框*/
 gprintf(1,HN(1),"Running Processes");
 DrawProcHeader(1,HN(2));
 gprintf(201,HN(1),"Suspend Processes");
 DrawProcHeader(201,HN(2));
 gprintf(201,HN(20),"Ready Processes");
 DrawProcHeader(201,HN(21));
 gprintf(401,HN(1),"Memory Use Information");
 gprintf(401,HN(2),"Offset");
 gprintf(501,HN(2),"Size");
 gprintf(601,HN(2),"Use");
 gprintf(1,HN(27),"System Console");
 return TRUE;
}
int DrawMemStruct(int x, int y, MemBlock* mem)
{
 bar(x,y,x+237,y+HEIGHT-2);
 gprintf(x,y,"%u", mem->Offset);
 gprintf(x+100,y,"%u",mem->Size);
 switch(mem->Sts)
 {
 case INUSE: gprintf(x+200,y,"USE"); break;
 case IDLE: gprintf(x+200,y,"IDLE"); break;
 }
 return TRUE;
}
int DrawMemTable()
{
 int num=0;
 MemBlock *last, *now;
 setfillstyle(1, BLACK);
 if (MemTable==NULL) return FALSE;
 now = MemTable;
 while (now!=NULL)
 {
  DrawMemStruct(401,HN(3+(num++)),now);
  now = now->Next;
 }
 bar(401,HN(3+num),638,478);/*擦除列表下面的空隙*/
 line(639,HN(2),639,479);/*补上误擦除的线*/
 return TRUE;
}
int DrawConsole()
{
 setfillstyle(1, BLACK);
 bar(1,HN(28),198,HN(28)+HEIGHT-2);
 DrawConsoleEcho();
 gprintf(19,HN(28),CmdString);
 return TRUE;
}
int DrawConsoleHelp()
{
 gprintf(1,HN(29),"exit---Quit System");
 gprintf(1,HN(30),"pause--Clock Pause");
 gprintf(1,HN(31),"proc prior time memory ");
 gprintf(1,HN(32),"-------Add New Process");
 gprintf(1,HN(33),"ready ID");
 gprintf(1,HN(34),"-------UnSuspend Process");
 gprintf(1,HN(35),"hibat--Increase Batchs");
 gprintf(1,HN(36),"lobat--Decrease Batchs");
 return TRUE;
}
int DrawConsoleEcho()
{
 static show = TRUE;
 bar(1,HN(28),18,HN(28)+HEIGHT-2);
 if (show)
  gprintf(1,HN(28),">>");
 else
  gprintf(1,HN(28),"<<");
 show = show?FALSE:TRUE;
 return TRUE;
}
int gprintf( int xloc, int yloc, char *fmt, ... )
{
  va_list  argptr;
  char str[140];
  int cnt;
  va_start( argptr, format );
  cnt = vsprintf( str, fmt, argptr );
  outtextxy( xloc+1, yloc+1, str );
  va_end( argptr ); 
  return( cnt );
}
/****************************************************************/
int InitConsole()
{
 CmdString[0] = '\0';
 return TRUE;
}
ConsoleCmd GetConsoleCmd()
{
 char cmd[10];
 int pos=0,i;
 while (pos<10)
 {
  cmd[pos] = CmdString[pos];
  if ((cmd[pos]<'A')
   ||(cmd[pos]>'Z' && cmd[pos]<'a')
   ||(cmd[pos]>'z')
   )/*该字符不是字母*/
  {
   cmd[pos] = '\0';
   break;
  }
  ++pos;
 }
 cmd[9] = '\0';
 for (i=0; i<6; i++)
 {
  if (strcmp(cmd, StrCmd[i])==0)
   return (ConsoleCmd)(i);
 }
 return -1;
}
UINT GetData(int n)
{
 char ch, buf[10];
 int pos=0, space=0,i;
 while (space<n && pos<20)/*未到达要读取数据的位置*/
 {
  ch = CmdString[pos++];
  if (ch==' ')/*如果找到空格*/
   ++space;
 }
 for (i=0; i<10; i++)
 {
  buf[i] = CmdString[pos+i];
  if (buf[i]<'0' || buf[i]>'9')/*不是数字*/
  {
   if (i==0)/*第一个字符便不是数字*/
    return 0;
   buf[i] = '\0';
   break;
  }
 }
 return (UINT)atoi(buf);
}
int ExecuteCmd()
{
 switch (GetConsoleCmd())
 {
 case CMD_EXIT:
  return FALSE;
 case CMD_PAUSE:
  flushall();
  bar(18,HN(28),197,HN(28)+HEIGHT-2);
  gprintf(18,HN(28),"press any key...");
  getch();
  flushall();
  break;
 case CMD_PROC:
  InsertProc(GetData(1),GetData(2),GetData(3));
  UpdateBatchs();
  break;
 case CMD_READY:
  UnSuspendProc(GetData(1));
  UpdateBatchs();
  break;
 case CMD_HIBAT:
  AddBatch();
  UpdateBatchs();
  break;
 case CMD_LOBAT:
  DeleteBatch();
  UpdateBatchs();
  break;
 default: break;
 }
 return TRUE;
}
int CmdKeyDown(char ch)
{
 static int pos = 0;
 int ret;
 if (ch == ENTER)
 {
  CmdString[pos] = '\0';
  ret = ExecuteCmd();
  pos=0;
  CmdString[0] = '\0';
  return ret;
 }
 else if (ch == BACKSPACE)
 {
  if (pos>0)
   CmdString[--pos] = '\0';
  return TRUE;
 }
 else
 {
  CmdString[pos] = ch;
  CmdString[++pos] = '\0';
  if (pos>20)
   pos=20;
  return TRUE;
 }
}
/****************************************************************/
/*main函数*/
int main()
{
 clock_t start=0, end=0;
 char ch;
 if (!InitConsole())
 {
  printf("can;t initialize console");getch();
  return FALSE;
 }
 if (!InitMem())
 {
  printf("can't initialize memory");getch();
  return FALSE;
 }
 if (!InitBatchs(3))
 {
  printf("can't initialize system batchs");getch();
  return FALSE;
 }
 if (!InitGraph())
 {
  printf("can't initialize graphics system");getch();
  return FALSE;
 }
 DrawFrame();
 DrawAllProc();
 DrawMemTable();
 DrawConsole();
 DrawConsoleHelp();
 while (TRUE)
 {
  start = end = clock();
  while (!kbhit())
  {
   start = clock();
   if ((start-end)/18.2 >= 1)/*时间过了一秒*/
   {
    start = end = clock();
    DrawConsoleEcho();
    PassSeconds(1);
    DrawAllProc();
    DrawMemTable();
   }
  }
  ch = getch();
  if (ch == ESC)
   return TRUE;
  if ((ch>='0' && ch<='9')/*如果字符是数字*/
   || (ch>='A' && ch<='Z')
   || (ch>='a' && ch<='z')/*或是字母*/
   || (ch==ENTER)/*如果是回车*/
   || (ch==' ')/*是空格*/
   || (ch==BACKSPACE)/*是退格*/
   )
  {
   if (CmdKeyDown(ch)==FALSE)/*如果执行了exit命令*/
    return TRUE;
   else if (ch==ENTER)/*如果执行了命令*/
   {
    DrawAllProc();
    DrawMemTable();
   }
   DrawConsole();
  }
 }
 return TRUE;
}