虚拟机源码分析

converse

1）虚拟机是什么？“虚拟机”的概念其实很广，最常见的有以下两种虚拟机，第一种是模拟“裸机”运行的虚拟机，这样的虚拟机有VMWAREVirturePC,Bochs等，另一种是模拟操作系统运行情况的虚拟机，这样的虚拟机有Wine，JVM（java虚拟机）。其实，虚拟机就是一个中间层，可以理解为是两种环境的桥梁，如果把虚拟机的概念抽象一点描述，可以认为虚拟机是在某一个环境上模拟另一种环境运行情况的软件，这样的环境可以是不同的cpu，不同的os....等等。
    这里选择的是两个非常简单的虚拟机，一个是<<编译原理与实践>;>;一书中自带的TM虚拟机，另一个是<<程序员>;>;杂志2003年第六期里的一篇文章<<一个小型虚拟机的实现>;>;中实现的虚拟机，两者都有一个共同点，就是两者都是在汇编语言级别虚拟cpu运行情况的虚拟机，正因为这两个虚拟机的如此定位，所以在实现或者阅读这两个虚拟机的时候，你不得不从cpu的角度去思考问题，你必须对cpu的运行情况有了解，反过来说，阅读这两个虚拟机的源码也可以加深对cpu工作原理以及汇编语言的理解。这两个虚拟机的源码都可以在网上找到，前者在http://www.mathcs.sjsu.edu/faculty/louden/cmptext/，而后者可以在CSDN的网站上查找2003年第六期的源码。值得一提的是，CS:APP（<<深入理解计算机系统>;>;）一书中也有一章专门讲述CPU的运行原理，而且作者也自己实现了一个CPU，而且还是流水线型，所以这个虚拟机功能更酷也更加强大，因为作者自己定义了一种硬件语言来描述cpu，最后还有在这种cpu支持的汇编指令，在有Tcl/Tk的环境下还带有图形界面，非常直观，可以在http://csapp.cs.cmu.edu/public/students.html里的Chapter 4rocessor Architecture中找到源代码。

3)设计一个汇编语言级别的虚拟机的要求
学习过计算机原理的人都知道，一个cpu至少需要有以下几个部件：a)内存，装载所要执行的指令之用;b)寄存器;3)指令集，没有指令集执行指令就无从谈起。前两者非常简单，无非就是在内存中分配一个空间来模拟就可以了，而后者这
里要专门说明一下。我们知道任何高级语言，经过这个高级语言的编译器编译之后都是翻译成汇编语言的，然后由汇编器汇编成二进制文件最后再进行库的链接等等才形成了可执行文件，而可执行文件最终也是二进制格式的，在执行可执行文件的时候由加载器加载到内存中去，那么这里就有一个问题了：cpu是如何识别已经加载到内存中二进制文件并且正确执行的？这需要下
面的一个概念：OpCode。
    OpCode是什么？简而言之，OpCode就是与汇编指令相对应的二进制格式的代码，OpCode的英文名是OperationCode（中文可以翻译成“操作码”），每一个汇编指令都有一个相对应的OpCode格式，反之不然，不过这个问题这里不再深究，只需要知道汇编器把汇编指令翻译成相应的由opcode组成的二进制文件，这样在可执行文件加载到内存的时候，cpu就可以根据在可执行文件中的opcode来执行程序了。理论上来说，不同厂家的cpu所支持的opcode是不同的，那么这里就有一个问题了，比如说在Intel机子上编译成功的可执行文件到了AMD的机子上如何正确执行呢？如果没有猜错的是，每个cpu在实现的时候需要在cpu的上层加一个翻译指令的东东....具体的我不清楚，只是猜测而已，也许不对。扯了这么多，回到这里要实现的cpu上，因为只是简易的cpu，所以在opcode上也尽量的精简，在这两个虚拟机的实现中，都是采用了汇编指令和opcode一一对应的关系进行实现（记住我前面说过汇编指令和opcode在真正的cpu中并不是一一对应的！），这样简化了cpu的实现。关于opcode，网上
有一份不错的教程<<学习opcode>;>;：http://www.luocong.com/learningopcode.htm，遗憾的是作者从开始写这份教程一直到现在差不多两年时间过去了还没有完成，不过前面的文章对于理解opcode的基本概念已经足够了。opcode看起来好像很高深，其实它就在我们身边，在linux上有一个objdump的反汇编软件可以反汇编二进制文件，比如这样的一段反汇编的代码：

1. 
   
2. 116: 89 e5 mov %esp,%ebp
   

复制代码

其中的116是指令地址，而89 e5就是指令mov %esp,%ebp 所对应的opcode。
    总结一下，设计一个汇编语言级别的虚拟机至少需要以下的部件：1)内存空间，用于存放机器指令之用。2)寄存器：用于保存程序运行的状态，暂存数据等等之用。3)汇编器，汇编器的功能就是把汇编指令翻译成cpu指定的机器指令，然后将指令装入虚拟机的内存之中。4)指令集，指令集包括了指令的助记符，也就是汇编语言中的指令，还需要有每个指令所对        应的机器指令也就是OpCode，助记符由汇编器处理翻译成为机器指令，最后在cpu执行的时候根据不同的机器指令来执行相关的操作。
    虽然这两个虚拟机的设计略有不同，但是由于都是模拟的汇编语言级别的cpu，所以工作过程大体都是一致的，把握这个运行的过程是正确掌握这两个源代码的关键所在！虚拟机运行的大体过程如下：首先由汇编起扫描汇编源文件，将汇编指令也就是机器指令的助记符翻译为机器指令，如果没有错误就把机器指令加载到内存之中，这时汇编器的任务就结束了；然后由虚拟机读取已经装载到内存中的机器指令，根据机器指令对应的操作来执行指令。
   ok，这里基本上把一些基本的概念解释完了，后面紧跟着就可以开始我们的虚拟机之旅了....

holyfire

怎么没了？

aero

好。

gvim

原创的吗？
友情挺一下。

converse

原帖由 "gvim" 发表：
原创的吗？
友情挺一下。

是原创的呀，刚刚去吃饭了，现在在赶制第一个虚拟机源码的分析文档中，稍等稍等...

lenovo

我认为最好把它们放在一起，
给你加一个原创，你说呢？

converse

ok，听从斑竹的意见，现在就移过来。

converse

第一个剖析对象是<<编译原理与实践>;>;中自带的TM虚拟机

1)cpu技术指标
TM虚拟机中由一个只读指令存储区，数据区和8个寄存器组成，其中最后一个寄存器是PC寄存器，也就是程序计数器，用来保存下一个指令的地址，在跳转中以及读取指令的时候要用到，如下：

1. 
   
2. /* 只读指令存储区的大小 */
   
3. #define   IADDR_SIZE  1024 /* increase for large programs */
   
4. /* 数据区的大小 */
   
5. #define   DADDR_SIZE  1024 /* increase for large programs */
   
6. /* 寄存器的数目 */
   
7. #define   NO_REGS 8
   
8. /* PC寄存器（程序计数器）的下标 */
   
9. #define   PC_REG  7
   
10. 在内存中分配了三个数组来实现模拟这三个数据区：
    
11. /* 只读指令存储区 */
    
12. INSTRUCTION iMem [IADDR_SIZE];
    
13. /* 数据存储区 */
    
14. int dMem [DADDR_SIZE];
    
15. /* 寄存器 */
    
16. int reg [NO_REGS];
    

复制代码

所支持的指令集，为了简化cpu的实现，采用的是一个enum类型来存储指令的opcode，在这里opcode和汇编指令是一一对应的，而指令分为三种类型，分别是RR,RM,RA，其中的RM类型的指令需要对数据区进行读取，而另外两种只需要对寄存器进行读取就可以了，opcode的类型用一个enum OPCLASS来分别：

1. 
   
2. typedef enum {
   
3.          opclRR,     /* reg operands r,s,t */
   
4.          opclRM,     /* reg r, mem d+s */
   
5.          opclRA      /* reg r, int d+s */
   
6. } OPCLASS;
   

复制代码

三种不同的opcode类型的opcode的格式是有区别的：

1. 
   
2. 指令类型                指令的格式
   
3. RR                      r,s,t
   
4. RM                      r,d(s)
   
5. RA                      r,d(s)
   

复制代码

说明一下，对于不同类型的汇编指令，必须与这种汇编指令的opcode格式严格对应，如RR指令的类型必须是r,s,t等等。RM和RA的指令格式稍微有一点区别，这里要根据输入的"d(s)"得到另外一个值a = d + reg，就是说d是偏移值，而s在这里是寄存器数组的下标，对于RM来说，得到的a是对应于数据内存区数组的下标，这个a不能小于0或者大于这个内存区的大小，否则就会报错，而对RA而言，这个a值就是存储到相应的寄存器中的值，寄存器的选择根据不同的指令而定。

下面是这个虚拟机的汇编指令对应的opcode的列表，右边的注释是每个不同的指令对应的动作，也就是要根据opcode中的数据所要进行的不同的处理：

1. 
   
2. /* 虚拟机的汇编指令对应的OPCODE */
   
3. typedef enum {
   
4.          /* RR instructions */
   
5.          opHALT,    /* RR     halt, operands are ignored */
   
6.          opIN,      /* RR     read into reg(r); s and t are ignored */
   
7.          opOUT,     /* RR     write from reg(r), s and t are ignored */
   
8.          opADD,     /* RR     reg(r) = reg(s)+reg(t) */
   
9.          opSUB,     /* RR     reg(r) = reg(s)-reg(t) */
   
10.          opMUL,     /* RR     reg(r) = reg(s)*reg(t) */
    
11.          opDIV,     /* RR     reg(r) = reg(s)/reg(t) */
    
12.          opRRLim,   /* limit of RR opcodes */
    
13. 
    
14.          /* RM instructions */
    
15.          opLD,      /* RM     reg(r) = mem(d+reg(s)) */
    
16.          opST,      /* RM     mem(d+reg(s)) = reg(r) */
    
17.          opRMLim,   /* Limit of RM opcodes */
    
18. 
    
19.          /* RA instructions */
    
20.          opLDA,     /* RA     reg(r) = d+reg(s) */
    
21.          opLDC,     /* RA     reg(r) = d ; reg(s) is ignored */
    
22.          opJLT,     /* RA     if reg(r)<0 then reg(7) = d+reg(s) */
    
23.          opJLE,     /* RA     if reg(r)<=0 then reg(7) = d+reg(s) */
    
24.          opJGT,     /* RA     if reg(r)>;0 then reg(7) = d+reg(s) */
    
25.          opJGE,     /* RA     if reg(r)>;=0 then reg(7) = d+reg(s) */
    
26.          opJEQ,     /* RA     if reg(r)==0 then reg(7) = d+reg(s) */
    
27.          opJNE,     /* RA     if reg(r)!=0 then reg(7) = d+reg(s) */
    
28.          opRALim    /* Limit of RA opcodes */
    
29. } OPCODE;
    

复制代码

不论是哪一种类型的指令，都必须在指令内存区中保存相应的信息，比如说访问的寄存器的位置，内存的位置等等，这些信息保存在下面的一个结构体变量中的：

1. 
   
2. /* 存储指令的值，iop是OPCODE，剩下三个是r,s,t */
   
3. typedef struct {
   
4.          int iop;
   
5.          int iarg1;
   
6.          int iarg2;
   
7.          int iarg3;
   
8. } INSTRUCTION;
   

复制代码

其中的iop就是指令对应的opcode，与前面的enum OPCODE中的成员一一对应，剩下的三个变量就是opcode中的r,s,t变量。指令内存区都INSTRUCTION类型的。

另外，执行指令的时候还要有不同的结果，这里同样的使用一个enum STEPRESULT类型来识别不同的结果，需要说明的是在读取内存的时候如果指针大小小于0或者大于内存的大小就会报错，另外在执行除法指令的时候还有可能出现零除错误：

1. 
   
2. /* 枚举执行结果 */
   
3. typedef enum {
   
4.          srOKAY,                                        /* 正确执行 */
   
5.          srHALT,                                        /* 停止执行 */
   
6.          srIMEM_ERR,                                /* IMEM错误 */
   
7.          srDMEM_ERR,                                /* DMEM错误 */
   
8.          srZERODIVIDE                                /* 零除错误 */
   
9. } STEPRESULT;
   

复制代码

2)cpu的工作原理
代码的量不大，只有700行不到，核心的函数有下面几个：
a)int readInstructions (void)
这个函数负责读取代码文件，是逐行处理的，对于每一行的文件首先检查指令是否符合这个虚拟机的汇编指令的格式，然后分辩这个指令的类型，再根据这个指令的类型存储不同的指令中opcode里的数据，每读取完一行代码如果没有错误的话就把指令及相应的opcode存储到指令存储区中，就是INSTRUCTION iMem [IADDR_SIZE]数组中，当读取文件结束的时候，这个数组中就都是相应的指令了，而后面的存储区存放的是HALT指令。

b)int doCommand (void)
这个函数负责读取stdin中用户输入的命令行参数来执行不同的动作，相关的动作这里不再详述，这个函数会一直执行下去，一直到用户输入q时才退出，在主函数main中是这样调用这个函数的：

1. 
   
2.          do
   
3.                   done = ! doCommand ();
   
4.          while (! done );
   

复制代码

c)STEPRESULT stepTM (void)
这个函数是根据指令内存区中的指令逐步执行程序的函数，其中设定的一个局部变量         INSTRUCTION currentinstruction  ;
负责存储当前的指令：

1. 
   
2. /* 从PC寄存器中读取下一条指令地址 */
   
3.          pc = reg[PC_REG] ;
   
4.          /* 如果小于零或者大于IADDR_SIZE，就是超过指令内存大小，就返回srIMEM_ERR错误 */
   
5.          if ( (pc < 0) || (pc >; IADDR_SIZE)  )
   
6.                   return srIMEM_ERR ;
   
7.          /* PC加一 */
   
8.          reg[PC_REG] = pc + 1 ;
   
9.          /* 从内存中根据PC地址值读取当前要执行的指令 */
   
10.          currentinstruction = iMem[ pc ] ;
    

复制代码

每读取完一个指令，就根据指令的类型以及指令所定义的不同的动作来执行代码，比如说：

1. 
   
2. /* 根据iop中存储的OPCODE来执行指令，每个case右边是指令的执行情况 */
   
3.          switch ( currentinstruction.iop)
   
4.          {
   
5.          case opHALT :                                /* RR     halt, operands are ignored */
   
6.                   printf("HALT: %1d,%1d,%1d\n",r,s,t);
   
7.                   return srHALT ;
   
8.                   /* break; */
   
9. 
   
10.          case opIN :                                /* RR     read into reg(r); s and t are ignored */
    
11.                   do{
    
12.                            printf("Enter value for IN instruction: ") ;
    
13.                            fflush (stdin);
    
14.                            fflush (stdout);
    
15.                            gets(in_Line);
    
16.                            lineLen = strlen(in_Line) ;
    
17.                            inCol = 0;
    
18.                            ok = getNum();
    
19.                            if ( ! ok )
    
20.                                         printf ("Illegal value\n");
    
21.                            else
    
22.                                         reg[r] = num;
    
23.                   } while (! ok);
    
24.                   break;
    

复制代码

剩余的其它函数都是简单的辅助函数了，无非是一些跳过空格，跳过检查是否是特定字符，得到字符串以及得到数字等等之类的函数了。

3)汇编指令的格式
这个虚拟机能够识别的汇编指令有一定的格式，如下：
a)忽略空行
b)以“*”号开头的都是注释
c)任何其它行都必须以整数开头，这个整数用于指定代码的位置，任何指令后面的文字都被认为是注释而忽略掉。
至于支持的指令就是与opcode一一对应的，不再详述

4)虚拟机的使用方式
TM虚拟机只有一个文件，只需要简单的编译就可以了，下面提供一个与该虚拟机对应的汇编代码：

1. 
   
2.   0:     LD  6,0(0)
   
3.   1:     ST  0,0(0)
   
4.   2:     IN  0,0,0
   
5.   3:     ST  0,0(5)
   
6.   4:    LDC  0,0(0)
   
7.   5:     ST  0,0(6)
   
8.   6:     LD  0,0(5)
   
9.   7:     LD  1,0(6)
   
10.   8:    SUB  0,1,0
    
11.   9:    JLT  0,2(7)
    
12. 10:    LDC  0,0(0)
    
13. 11:    LDA  7,1(7)
    
14. 12:    LDC  0,1(0)
    
15. 14:    LDC  0,1(0)
    
16. 15:     ST  0,1(5)
    
17. 16:     LD  0,1(5)
    
18. 17:     ST  0,0(6)
    
19. 18:     LD  0,0(5)
    
20. 19:     LD  1,0(6)
    
21. 20:    MUL  0,1,0
    
22. 21:     ST  0,1(5)
    
23. 22:     LD  0,0(5)
    
24. 23:     ST  0,0(6)
    
25. 24:    LDC  0,1(0)
    
26. 25:     LD  1,0(6)
    
27. 26:    SUB  0,1,0
    
28. 27:     ST  0,0(5)
    
29. 28:     LD  0,0(5)
    
30. 29:     ST  0,0(6)
    
31. 30:    LDC  0,0(0)
    
32. 31:     LD  1,0(6)
    
33. 32:    SUB  0,1,0
    
34. 33:    JEQ  0,2(7)
    
35. 34:    LDC  0,0(0)
    
36. 35:    LDA  7,1(7)
    
37. 36:    LDC  0,1(0)
    
38. 37:    JEQ  0,-22(7)
    
39. 38:     LD  0,1(5)
    
40. 39:    OUT  0,0,0
    
41. 13:    JEQ  0,27(7)
    
42. 40:    LDA  7,0(7)
    
43. 41:   HALT  0,0,0
    

复制代码

假设编译好的虚拟机的可执行文件是TM，而汇编代码文件是1.tm(这个虚拟机默认的可识别的汇编文件是*.tm),那么只需要简单的使用:

1. 
   
2. TM 1.tm
   

复制代码

就可以了。

ok，第一个虚拟机的分析到此，下面是完整的源代码：

converse

1. 
   
2. /****************************************************/
   
3. /* File: tm.c                                       */
   
4. /* The TM ("Tiny Machine") computer                 */
   
5. /* Compiler Construction: Principles and Practice   */
   
6. /* Kenneth C. Louden                                */
   
7. /****************************************************/
   
8. 
   
9. #include <stdio.h>;
   
10. #include <stdlib.h>;
    
11. #include <string.h>;
    
12. #include <ctype.h>;
    
13. 
    
14. #ifndef TRUE
    
15. #define TRUE 1
    
16. #endif
    
17. #ifndef FALSE
    
18. #define FALSE 0
    
19. #endif
    
20. 
    
21. /******* const *******/
    
22. /* 只读指令存储区的大小 */
    
23. #define   IADDR_SIZE  1024 /* increase for large programs */
    
24. /* 数据区的大小 */
    
25. #define   DADDR_SIZE  1024 /* increase for large programs */
    
26. /* 寄存器的数目 */
    
27. #define   NO_REGS 8
    
28. /* PC寄存器（程序计数器）的下标 */
    
29. #define   PC_REG  7
    
30. 
    
31. #define   LINESIZE  121
    
32. #define   WORDSIZE  20
    
33. 
    
34. /******* type  *******/
    
35. 
    
36. /* 虚拟机的指令类型，有三种 */
    
37. typedef enum {
    
38.          opclRR,     /* reg operands r,s,t */
    
39.          opclRM,     /* reg r, mem d+s */
    
40.          opclRA      /* reg r, int d+s */
    
41. } OPCLASS;
    
42. 
    
43. /* 虚拟机的汇编指令对应的OPCODE */
    
44. typedef enum {
    
45.          /* RR instructions */
    
46.          opHALT,    /* RR     halt, operands are ignored */
    
47.          opIN,      /* RR     read into reg(r); s and t are ignored */
    
48.          opOUT,     /* RR     write from reg(r), s and t are ignored */
    
49.          opADD,     /* RR     reg(r) = reg(s)+reg(t) */
    
50.          opSUB,     /* RR     reg(r) = reg(s)-reg(t) */
    
51.          opMUL,     /* RR     reg(r) = reg(s)*reg(t) */
    
52.          opDIV,     /* RR     reg(r) = reg(s)/reg(t) */
    
53.          opRRLim,   /* limit of RR opcodes */
    
54. 
    
55.          /* RM instructions */
    
56.          opLD,      /* RM     reg(r) = mem(d+reg(s)) */
    
57.          opST,      /* RM     mem(d+reg(s)) = reg(r) */
    
58.          opRMLim,   /* Limit of RM opcodes */
    
59. 
    
60.          /* RA instructions */
    
61.          opLDA,     /* RA     reg(r) = d+reg(s) */
    
62.          opLDC,     /* RA     reg(r) = d ; reg(s) is ignored */
    
63.          opJLT,     /* RA     if reg(r)<0 then reg(7) = d+reg(s) */
    
64.          opJLE,     /* RA     if reg(r)<=0 then reg(7) = d+reg(s) */
    
65.          opJGT,     /* RA     if reg(r)>;0 then reg(7) = d+reg(s) */
    
66.          opJGE,     /* RA     if reg(r)>;=0 then reg(7) = d+reg(s) */
    
67.          opJEQ,     /* RA     if reg(r)==0 then reg(7) = d+reg(s) */
    
68.          opJNE,     /* RA     if reg(r)!=0 then reg(7) = d+reg(s) */
    
69.          opRALim    /* Limit of RA opcodes */
    
70. } OPCODE;
    
71. 
    
72. /* 枚举执行结果 */
    
73. typedef enum {
    
74.          srOKAY,                                        /* 正确执行 */
    
75.          srHALT,                                        /* 停止执行 */
    
76.          srIMEM_ERR,                                /* IMEM错误 */
    
77.          srDMEM_ERR,                                /* DMEM错误 */
    
78.          srZERODIVIDE                                /* 零除错误 */
    
79. } STEPRESULT;
    
80. 
    
81. /* 存储指令的值，iop是OPCODE，剩下三个是r,s,t */
    
82. typedef struct {
    
83.          int iop;
    
84.          int iarg1;
    
85.          int iarg2;
    
86.          int iarg3;
    
87. } INSTRUCTION;
    
88. 
    
89. /******** vars ********/
    
90. /* 指向只读指令存储区的指针 */
    
91. int iloc = 0 ;
    
92. /* 指向数据存储区的指针 */
    
93. int dloc = 0 ;
    
94. /* 是否跟踪程序执行情况 */
    
95. int traceflag = FALSE;
    
96. /* 是否需要打印出执行的指令数量 */
    
97. int icountflag = FALSE;
    
98. 
    
99. /* 只读指令存储区 */
    
100. INSTRUCTION iMem [IADDR_SIZE];
     
101. /* 数据存储区 */
     
102. int dMem [DADDR_SIZE];
     
103. /* 寄存器 */
     
104. int reg [NO_REGS];
     
105. 
     
106. /* 指令列表，用于在stdout上打印出程序执行情况之用，与enum OPCODE对应,其中的"????"则与相应的LIM值对应，无意义 */
     
107. char *opCodeTab[] = {
     
108.          /* RR opcodes */
     
109.          "HALT","IN","OUT","ADD","SUB","MUL","DIV","????",
     
110.      /* RM opcodes */
     
111.          "LD","ST","????",
     
112.          /* RA opcodes */
     
113.          "LDA","LDC","JLT","JLE","JGT","JGE","JEQ","JNE","????"
     
114. };
     
115. 
     
116. /* 程序结果列表，用于在stdout上打印出程序执行情况之用，与enum STEPRESULT对应 */
     
117. char * stepResultTab[] =
     
118. {
     
119.          "OK",
     
120.          "Halted",
     
121.          "Instruction Memory Fault",
     
122.          "Data Memory Fault",
     
123.          "Division by 0"
     
124. };
     
125. 
     
126. /* 存储文件名 */
     
127. char pgmName[20];
     
128. /* 代码文件的FILE指针 */
     
129. FILE *pgm  ;
     
130. 
     
131. /* 文件的每一行都存在这个数组里 */
     
132. char in_Line[LINESIZE] ;
     
133. /* 读取到当前文件的行数记录 */
     
134. int lineLen;
     
135. /* in_Line数组中的下标 */
     
136. int inCol;
     
137. /* 存储getNum()函数的结果 */
     
138. int num  ;
     
139. /* 存储getWord()函数的结果 */
     
140. char word[WORDSIZE] ;
     
141. /* 存储getCh()函数的结果 */
     
142. char ch  ;
     
143. /* 存储docomand()函数的执行结果，用于表示程序是否结束 */
     
144. int done  ;
     
145. 
     
146. /*************************************************************************************
     
147. * int opClass( int c )：根据c的值在OPCODE枚举型中查找指令的类型,有RR,RM,RA三种指令
     
148. *************************************************************************************/
     
149. int opClass( int c )
     
150. {
     
151.          if ( c <= opRRLim)
     
152.                   return ( opclRR );
     
153.          else if ( c <= opRMLim)
     
154.                   return ( opclRM );
     
155.          else
     
156.                   return ( opclRA );
     
157. } /* opClass */
     
158. 
     
159. /**************************************************************************************
     
160. *void writeInstruction ( int loc ):向stdout上打印出程序的执行情况
     
161. **************************************************************************************/
     
162. void writeInstruction ( int loc )
     
163. {
     
164.          printf( "%5d: ", loc) ;
     
165.          if ( (loc >;= 0) && (loc < IADDR_SIZE) )
     
166.          {
     
167.                   printf("%6s%3d,", opCodeTab[iMem[loc].iop], iMem[loc].iarg1);
     
168.                   switch ( opClass(iMem[loc].iop) )
     
169.                   {
     
170.                   case opclRR:
     
171.                            printf("%1d,%1d", iMem[loc].iarg2, iMem[loc].iarg3);
     
172.                            break;
     
173.                   case opclRM:
     
174.                   case opclRA:
     
175.                            printf("%3d(%1d)", iMem[loc].iarg2, iMem[loc].iarg3);
     
176.                            break;
     
177.                   }
     
178.                   printf ("\n") ;
     
179.          }
     
180. } /* writeInstruction */
     
181. 
     
182. /*************************************************************************************
     
183. * void getCh (void):在in_line数组中读取字符，如果到文件尾，就返回空字符,并且将结果存入ch中
     
184. **************************************************************************************/
     
185. void getCh (void)
     
186. {
     
187.          if (++inCol < lineLen)
     
188.                   ch = in_Line[inCol] ;
     
189.          else ch = ' ' ;
     
190. } /* getCh */
     
191. 
     
192. /**************************************************************************************
     
193. * int nonBlank (void): 查找某行文件后面是否都是空格，如果是则设置ch=' '并且返回false，
     
194. *                      否则设置ch为第一个非空字符返回true
     
195. ***************************************************************************************/
     
196. int nonBlank (void)
     
197. {
     
198.          while ((inCol < lineLen)
     
199.                         && (in_Line[inCol] == ' ') )
     
200.                   inCol++ ;
     
201.          if (inCol < lineLen)
     
202.          {
     
203.                   ch = in_Line[inCol] ;
     
204.                   return TRUE ;
     
205.          }
     
206.          else
     
207.          {
     
208.                   ch = ' ' ;
     
209.                   return FALSE ;
     
210.          }
     
211. } /* nonBlank */
     
212. 
     
213. /***************************************************************************************
     
214. * int getNum (void):判断字符是否是数字,不是就返回false，否则返回true并且num中存储读入的数字
     
215. ****************************************************************************************/
     
216. int getNum (void)
     
217. {
     
218.          int sign;
     
219.          int term;
     
220.          int temp = FALSE;
     
221.          num = 0 ;
     
222. 
     
223.          do {
     
224.                   sign = 1;
     
225.                   while ( nonBlank() && ((ch == '+') || (ch == '-')) )
     
226.                   {
     
227.                            temp = FALSE ;
     
228.                            if (ch == '-')  
     
229.                                         sign = - sign ;
     
230.                            getCh();
     
231.                   }
     
232.                   term = 0 ;
     
233.                   nonBlank();
     
234.                   while (isdigit(ch))
     
235.                   {
     
236.                            temp = TRUE ;
     
237.                            term = term * 10 + ( ch - '0' ) ;
     
238.                            getCh();
     
239.                   }
     
240.                   num = num + (term * sign) ;
     
241.          } while ( (nonBlank()) && ((ch == '+') || (ch == '-')) ) ;
     
242. 
     
243.          return temp;
     
244. } /* getNum */
     
245. 
     
246. /****************************************************************************************
     
247. *int getWord (void):判断后面紧接着的是否是符号，就是以字母或者数字开头的符号，是就返回true
     
248. *                   并且将该符号存入word数组之中，否则返回false
     
249. ****************************************************************************************/
     
250. int getWord (void)
     
251. {
     
252.          int temp = FALSE;
     
253.          int length = 0;
     
254.          if (nonBlank ())
     
255.          {
     
256.                   while (isalnum(ch))
     
257.                   {
     
258.                            if (length < WORDSIZE-1)
     
259.                                         word [length++] =  ch ;
     
260.                            getCh() ;
     
261.                   }
     
262.                   word[length] = '\0';
     
263.                   temp = (length != 0);
     
264.          }
     
265. 
     
266.          return temp;
     
267. } /* getWord */
     
268. 
     
269. /*****************************************************************************************  
     
270. *int skipCh ( char c  ):略过指定的字符，如果找不到这个字符那么返回false，否则返回true
     
271. *****************************************************************************************/
     
272. int skipCh ( char c  )
     
273. {
     
274.          int temp = FALSE;
     
275.          if ( nonBlank() && (ch == c) )
     
276.          {
     
277.                   getCh();
     
278.                   temp = TRUE;
     
279.          }
     
280.          return temp;
     
281. } /* skipCh */
     
282. 
     
283. /******************************************************************************************   
     
284. *int atEOL(void):是否到达行尾，是就返回非零值，否则返回零值
     
285. ******************************************************************************************/
     
286. int atEOL(void)
     
287. {
     
288.          return ( ! nonBlank ());
     
289. } /* atEOL */
     
290. 
     
291. /*******************************************************************************************   
     
292. * int error( char * msg, int lineNo, int instNo):打印出错信息，其中msg是出错信息，
     
293. *                                                lineNo是行数，instNo是指令数
     
294. *******************************************************************************************/
     
295. int error( char * msg, int lineNo, int instNo)
     
296. {
     
297.          printf("Line %d",lineNo);
     
298.          if (instNo >;= 0)
     
299.                   printf(" (Instruction %d)",instNo);
     
300.          printf("   %s\n",msg);
     
301.          return FALSE;
     
302. } /* error */
     
303. 
     
304. /*******************************************************************************************   
     
305. * int readInstructions (void):读取代码文件进行处理
     
306. *******************************************************************************************/
     
307. int readInstructions (void)
     
308. {
     
309.          /* op存储指令 */
     
310.          OPCODE op;
     
311.          /* 存储r,s,t */
     
312.          int arg1, arg2, arg3;
     
313.          /* loc是指令的位置, regNO是寄存器的位置,lineNO是代码中的行数 */
     
314.          int loc, regNo, lineNo;
     
315. 
     
316.          /* 清空寄存器 */
     
317.          for (regNo = 0 ; regNo < NO_REGS ; regNo++)
     
318.                   reg[regNo] = 0 ;
     
319.          /* 不明白为什么这样做？ */
     
320.          dMem[0] = DADDR_SIZE - 1 ;
     
321.          /* 清空数据区 */
     
322.          for (loc = 1 ; loc < DADDR_SIZE ; loc++)
     
323.                   dMem[loc] = 0 ;
     
324.          /* 初始化指令存储区的OPCODE是opHALT */
     
325.          for (loc = 0 ; loc < IADDR_SIZE ; loc++)
     
326.          {
     
327.                   iMem[loc].iop = opHALT ;
     
328.                   iMem[loc].iarg1 = 0 ;
     
329.                   iMem[loc].iarg2 = 0 ;
     
330.                   iMem[loc].iarg3 = 0 ;
     
331.          }
     
332.          /* 初始化行数为0 */
     
333.          lineNo = 0 ;
     
334.          while (! feof(pgm))                /* 对文件进行逐行的读取操作，然后对每一行代码进行处理 */
     
335.          {
     
336.                   /* 读入一行代码 */
     
337.                   fgets( in_Line, LINESIZE-2, pgm  ) ;
     
338.                   /* 设置行的列号为0 */
     
339.                   inCol = 0 ;
     
340.                   /* 行数加一 */
     
341.                   lineNo++;
     
342.                   lineLen = strlen(in_Line)-1 ;
     
343.                   /* 把行尾置为'\0'，方便字符串操作 */
     
344.                   if (in_Line[lineLen]=='\n')
     
345.                            in_Line[lineLen] = '\0' ;
     
346.                   else
     
347.                            in_Line[++lineLen] = '\0';
     
348.                   /* 如果指令不是空格或者注释 */
     
349.                   if ( (nonBlank()) && (in_Line[inCol] != '*') )
     
350.                   {
     
351.                            /* 如果不是数字，就显示错误，因为指令都是以数字开始 */
     
352.                            if (! getNum())
     
353.                                         return error("Bad location", lineNo,-1);
     
354.                            /* 存储指令的位置 */
     
355.                            loc = num;
     
356.                            /* 大于指令存储区的大小 */
     
357.                            if (loc >; IADDR_SIZE)
     
358.                                         return error("Location too large",lineNo,loc);
     
359.                            /* 如果后面没有紧接着':'，则显示出错 */
     
360.                            if (! skipCh(':'))
     
361.                                         return error("Missing colon", lineNo,loc);
     
362.                            /* 如果后面紧接着的不是符号，则显示出错 */
     
363.                            if (! getWord ())
     
364.                                         return error("Missing opcode", lineNo,loc);
     
365.                            /* 初始化为HALT指令 */
     
366.                            op = opHALT ;
     
367.                            /* 循环查找word指令对应的OPCODE，op就是在opCodeTab中对应的指令的下标 */
     
368.                            while ((op < opRALim)
     
369.                                           && (strncmp(opCodeTab[op], word, 4) != 0) )
     
370.                                         op++ ;
     
371.                            /* 没有找到对应的OPCODE，显示出错 */
     
372.                            if (strncmp(opCodeTab[op], word, 4) != 0)
     
373.                                         return error("Illegal opcode", lineNo,loc);
     
374.                           
     
375.                            /* 调用opClass函数对指令进行分类，不同的指令处理不相同 */
     
376.                            switch ( opClass(op) )
     
377.                            {
     
378.                            case opclRR :        /* 处理RR指令，具体为什么会如下处理可以查看RR指令的格式 */
     
379.                                         /* 如果后面紧接着的不是数字或者数字是非法的就显示出错 */
     
380.                                         if ( (! getNum ()) || (num < 0) || (num >;= NO_REGS) )
     
381.                                                  return error("Bad first register", lineNo,loc);
     
382.                                         arg1 = num;
     
383.                                         /* 如果后面没有紧跟着','，就显示出错 */
     
384.                                         if ( ! skipCh(','))
     
385.                                                  return error("Missing comma", lineNo, loc);
     
386.                     /* 如果后面紧接着的不是数字或者数字是非法的就显示出错 */
     
387.                                         if ( (! getNum ()) || (num < 0) || (num >;= NO_REGS) )
     
388.                                                  return error("Bad second register", lineNo, loc);
     
389.                                         arg2 = num;
     
390.                                         /* 如果后面没有紧跟着','，就显示出错 */
     
391.                                         if ( ! skipCh(','))
     
392.                                                  return error("Missing comma", lineNo,loc);
     
393.                                         /* 如果后面紧接着的不是数字或者数字对于RR命令是非法的就显示出错 */
     
394.                                         if ( (! getNum ()) || (num < 0) || (num >;= NO_REGS) )
     
395.                                                  return error("Bad third register", lineNo,loc);
     
396.                                         arg3 = num;
     
397.                                         break;
     
398. 
     
399.                            case opclRM :        /* 处理RM指令，具体为什么会如下处理可以查看RM指令的格式 */
     
400.                            case opclRA :        /* 处理RA指令，具体为什么会如下处理可以查看RA指令的格式 */
     
401.                                         /* 如果后面紧接着的不是数字或者数字是非法的就显示出错 */
     
402.                                         if ( (! getNum ()) || (num < 0) || (num >;= NO_REGS) )
     
403.                                                  return error("Bad first register", lineNo,loc);
     
404.                                         arg1 = num;
     
405.                                         /* 如果后面没有紧跟着','就显示出错 */
     
406.                                         if ( ! skipCh(','))
     
407.                                                  return error("Missing comma", lineNo,loc);
     
408.                                         /* 如果后面没有紧跟着数字就显示出错 */
     
409.                                         if (! getNum ())
     
410.                                                  return error("Bad displacement", lineNo,loc);
     
411.                                         arg2 = num;
     
412.                                         /* 如果后面没有紧跟着'('或者是','就显示出错 */
     
413.                                         if ( ! skipCh('(') && ! skipCh(',') )
     
414.                                                  return error("Missing LParen", lineNo,loc);
     
415.                                         /* 如果紧跟的不是数字或者数字是非法的就显示出错 */
     
416.                                         if ( (! getNum ()) || (num < 0) || (num >;= NO_REGS))
     
417.                                                  return error("Bad second register", lineNo,loc);
     
418.                                         arg3 = num;
     
419.                                         break;
     
420.                            } /* switch ( opClass(op) ) */
     
421.                            /* OK，读取一行代码结束，把指令存入指令存储区 */
     
422.                            iMem[loc].iop = op;
     
423.                            iMem[loc].iarg1 = arg1;
     
424.                            iMem[loc].iarg2 = arg2;
     
425.                            iMem[loc].iarg3 = arg3;
     
426.                   }        /* if ( (nonBlank()) && (in_Line[inCol] != '*') ) */
     
427.          }                /* while (! feof(pgm)) */
     
428. 
     
429.          return TRUE;
     
430. } /* readInstructions */
     
431. 
     
432. /********************************************************************************************
     
433. * STEPRESULT stepTM (void):根据指令内存区中的存储的指令逐步执行指令，并且返回执行结果
     
434. ********************************************************************************************/
     
435. STEPRESULT stepTM (void)
     
436. {
     
437.          INSTRUCTION currentinstruction  ;
     
438.          int pc  ;
     
439.          int r,s,t,m  ;
     
440.          int ok ;
     
441. 
     
442.          /* 从PC寄存器中读取下一条指令地址 */
     
443.          pc = reg[PC_REG] ;
     
444.          /* 如果小于零或者大于IADDR_SIZE，就是超过指令内存大小，就返回srIMEM_ERR错误 */
     
445.          if ( (pc < 0) || (pc >; IADDR_SIZE)  )
     
446.                   return srIMEM_ERR ;
     
447.          /* PC加一 */
     
448.          reg[PC_REG] = pc + 1 ;
     
449.          /* 从内存中根据PC地址值读取当前要执行的指令 */
     
450.          currentinstruction = iMem[ pc ] ;
     
451.          
     
452.      /*  调用opClass函数确定opcode的类型 */
     
453.          switch (opClass(currentinstruction.iop) )
     
454.          {
     
455.          case opclRR :                                /* 对于RR指令而言，opcode格式是opcode r, s, t */
     
456.                   r = currentinstruction.iarg1 ;
     
457.                   s = currentinstruction.iarg2 ;
     
458.                   t = currentinstruction.iarg3 ;
     
459.                   break;
     
460.                   
     
461.          case opclRM :                                 /* 对于RM指令而言，opcode格式是opcode r, d(s)，而m = d + reg(s) */
     
462.                   r = currentinstruction.iarg1 ;
     
463.                   s = currentinstruction.iarg3 ;
     
464.                   /* 对应RM指令中的m = d + reg[s]，相当于变址寻址,这个地址用于访问数据区 */
     
465.                   m = currentinstruction.iarg2 + reg[s] ;
     
466.                   /* 如果地址是非法的(对于数据存储区而言)，就返回一个srDMEM_ERR错误 */
     
467.                   if ( (m < 0) || (m >; DADDR_SIZE))
     
468.                            return srDMEM_ERR ;
     
469.                   break;
     
470. 
     
471.          case opclRA :                                /* 对于RA指令而言，opcode格式是opcode r, d(s),而m = d + reg(s)，m值最后存入相应的寄存器 */
     
472.                   r = currentinstruction.iarg1 ;
     
473.                   s = currentinstruction.iarg3 ;
     
474.                   m = currentinstruction.iarg2 + reg[s] ;
     
475.                   break;
     
476.          } /* case */
     
477. 
     
478.          /* 根据iop中存储的OPCODE来执行指令，每个case右边是指令的执行情况 */
     
479.          switch ( currentinstruction.iop)
     
480.          {
     
481.          case opHALT :                                /* RR     halt, operands are ignored */
     
482.                   printf("HALT: %1d,%1d,%1d\n",r,s,t);
     
483.                   return srHALT ;
     
484.                   /* break; */
     
485. 
     
486.          case opIN :                                /* RR     read into reg(r); s and t are ignored */
     
487.                   do{
     
488.                            printf("Enter value for IN instruction: ") ;
     
489.                            fflush (stdin);
     
490.                            fflush (stdout);
     
491.                            gets(in_Line);
     
492.                            lineLen = strlen(in_Line) ;
     
493.                            inCol = 0;
     
494.                            ok = getNum();
     
495.                            if ( ! ok )
     
496.                                         printf ("Illegal value\n");
     
497.                            else
     
498.                                         reg[r] = num;
     
499.                   } while (! ok);
     
500.                   break;
     
501. 
     
502.          case opOUT :                                  /* RR     write from reg(r), s and t are ignored */
     
503.                   printf ("OUT instruction prints: %d\n", reg[r] ) ;
     
504.                   break;
     
505.          case opADD :                                  /* RR     reg(r) = reg(s)+reg(t) */
     
506.                   reg[r] = reg[s] + reg[t] ;  
     
507.                   break;
     
508.          case opSUB :                                  /* RR     reg(r) = reg(s)-reg(t) */
     
509.                   reg[r] = reg[s] - reg[t] ;  
     
510.                   break;
     
511.          case opMUL :                                  /* RR     reg(r) = reg(s)*reg(t) */
     
512.                   reg[r] = reg[s] * reg[t] ;  
     
513.                   break;
     
514. 
     
515.          case opDIV :                                /* RR     reg(r) = reg(s)/reg(t) */
     
516.                   if ( reg[t] != 0 )
     
517.                            reg[r] = reg[s] / reg[t];
     
518.                   else
     
519.                            return srZERODIVIDE ;
     
520.                   break;
     
521. 
     
522.      /*************** RM instructions ********************/
     
523.          case opLD :                            /* RM     reg(r) = mem(d+reg(s)) */
     
524.                   reg[r] = dMem[m] ;  
     
525.                   break;
     
526.          case opST :                            /* RM     mem(d+reg(s)) = reg(r) */
     
527.                   dMem[m] = reg[r] ;  
     
528.                   break;
     
529. 
     
530.          /*************** RA instructions ********************/
     
531.          case opLDA :                            /* RA     reg(r) = d+reg(s) */
     
532.                   reg[r] = m ;
     
533.                   break;
     
534.          case opLDC :                            /* RA     reg(r) = d ; reg(s) is ignored */
     
535.                   reg[r] = currentinstruction.iarg2 ;   
     
536.                   break;
     
537.          case opJLT :                            /* RA     if reg(r)<0 then reg(7) = d+reg(s) */
     
538.                   if ( reg[r] <  0 )
     
539.                            reg[PC_REG] = m ;
     
540.                   break;
     
541.          case opJLE :                            /* RA     if reg(r)<=0 then reg(7) = d+reg(s) */
     
542.                   if ( reg[r] <=  0 )
     
543.                            reg[PC_REG] = m ;
     
544.                   break;
     
545.          case opJGT :                            /* RA     if reg(r)>;0 then reg(7) = d+reg(s) */
     
546.                   if ( reg[r] >;  0 )
     
547.                            reg[PC_REG] = m ;
     
548.                   break;
     
549.          case opJGE :                            /* RA     if reg(r)>;=0 then reg(7) = d+reg(s) */
     
550.                   if ( reg[r] >;=  0 )
     
551.                            reg[PC_REG] = m ;
     
552.                   break;
     
553.          case opJEQ :                            /* RA     if reg(r)==0 then reg(7) = d+reg(s) */
     
554.                   if ( reg[r] == 0 )
     
555.                            reg[PC_REG] = m ;
     
556.                   break;
     
557.          case opJNE :                            /* RA     if reg(r)!=0 then reg(7) = d+reg(s) */
     
558.                   if ( reg[r] != 0 )
     
559.                            reg[PC_REG] = m ;
     
560.                   break;
     
561. 
     
562.                   /* end of legal instructions */
     
563.          } /* case */
     
564.          
     
565.      /* 如果程序能够正常执行到这里，就返回执行正确的信息 */
     
566.          return srOKAY ;
     
567. } /* stepTM */
     
568. 
     
569. /********************************************************************************************
     
570. *int doCommand (void):执行指令
     
571. * *******************************************************************************************/
     
572. int doCommand (void)
     
573. {
     
574.          char cmd;
     
575.          int stepcnt=0, i;
     
576.          int printcnt;
     
577.          int stepResult;
     
578.          int regNo, loc;
     
579. 
     
580.          do {                                                 /* 读入执行虚拟机的命令行参数 */
     
581.                   printf ("Enter command: ");
     
582.                   fflush (stdin);
     
583.                   fflush (stdout);
     
584.                   gets(in_Line);
     
585.                   lineLen = strlen(in_Line);
     
586.                   inCol = 0;
     
587.          } while (! getWord ());
     
588. 
     
589.          cmd = word[0] ;
     
590.          switch ( cmd )
     
591.          {
     
592.          case 't' :                                        /* 是否跟踪调试 */
     
593.                   traceflag = ! traceflag ;
     
594.                   printf("Tracing now ");
     
595.                   if ( traceflag )
     
596.                            printf("on.\n");
     
597.                   else
     
598.                            printf("off.\n");
     
599.                   break;
     
600. 
     
601.          case 'h' :                                        /* 打印出命令及相应功能列表 */
     
602.                   printf("Commands are:\n");
     
603.                   printf("   s(tep <n>;      "\
     
604.                                  "Execute n (default 1) TM instructions\n");
     
605.                   printf("   g(o            "\
     
606.                                  "Execute TM instructions until HALT\n");
     
607.                   printf("   r(egs          "\
     
608.                                  "Print the contents of the registers\n");
     
609.                   printf("   i(Mem <b <n>;>;  "\
     
610.                                  "Print n iMem locations starting at b\n");
     
611.                   printf("   d(Mem <b <n>;>;  "\
     
612.                                  "Print n dMem locations starting at b\n");
     
613.                   printf("   t(race         "\
     
614.                                  "Toggle instruction trace\n");
     
615.                   printf("   p(rint         "\
     
616.                                  "Toggle print of total instructions executed"\
     
617.                                  " ('go' only)\n");
     
618.                   printf("   c(lear         "\
     
619.                                  "Reset simulator for new execution of program\n");
     
620.                   printf("   h(elp          "\
     
621.                                  "Cause this list of commands to be printed\n");
     
622.                   printf("   q(uit          "\
     
623.                                  "Terminate the simulation\n");
     
624.                   break;
     
625. 
     
626.          case 'p' :                                        /* 是否打印出执行的指令的步数 */
     
627.                   icountflag = ! icountflag ;
     
628.                   printf("Printing instruction count now ");
     
629.                   if ( icountflag )
     
630.                            printf("on.\n");
     
631.                   else
     
632.                            printf("off.\n");
     
633.                   break;
     
634. 
     
635.          case 's' :                                        /* 指定执行的步数 */
     
636.                   if ( atEOL ())  
     
637.                            stepcnt = 1;
     
638.                   else if ( getNum ())  
     
639.                            stepcnt = abs(num);
     
640.                   else
     
641.                            printf("Step count?\n");
     
642.                   break;
     
643. 
     
644.          case 'g' :                                   /* 执行指令一直到HALT */
     
645.                   stepcnt = 1 ;     
     
646.                   break;
     
647. 
     
648.          case 'r' :                                        /* 打印出寄存器中的内容 */
     
649.                   for (i = 0; i < NO_REGS; i++)
     
650.                   {
     
651.                            printf("%1d: %4d    ", i,reg[i]);
     
652.                            if ( (i % 4) == 3 )
     
653.                                         printf ("\n");
     
654.                   }
     
655.                   break;
     
656. 
     
657.          case 'i' :                                        /* 打印出只读指令存储区的内容（指令），也可以自己指定存储区的位置 */
     
658.                   printcnt = 1 ;
     
659.                   /* printcnt用于计数，计算总共要打印出多少行的内容，而iloc是指向这一段内存的指针 */
     
660.                   if ( getNum ())
     
661.                   {
     
662.                            iloc = num ;
     
663.                            if ( getNum ())
     
664.                                         printcnt = num ;
     
665.                   }
     
666.                   if ( ! atEOL ())
     
667.                            printf ("Instruction locations?\n");
     
668.                   else
     
669.                   {
     
670.                            while ((iloc >;= 0) && (iloc < IADDR_SIZE)
     
671.                                           && (printcnt >; 0) )
     
672.                            {
     
673.                                         writeInstruction(iloc);
     
674.                                         iloc++ ;
     
675.                                         printcnt-- ;
     
676.                            }
     
677.                   }
     
678.                   break;
     
679. 
     
680.          case 'd' :                                        /* 打印出数据存储区的内容（指令），也可以自己指定存储区的位置 */
     
681.                   printcnt = 1 ;
     
682.                   /* printcnt用于计数，计算总共要打印出多少行的内容，而dloc是指向这一段内存的指针 */
     
683.                   if ( getNum  ())
     
684.                   {
     
685.                            dloc = num ;
     
686.                            if ( getNum ())
     
687.                                         printcnt = num ;
     
688.                   }
     
689.                   if ( ! atEOL ())               
     
690.                            printf("Data locations?\n");
     
691.                   else
     
692.                   {
     
693.                            while ((dloc >;= 0) && (dloc < DADDR_SIZE)
     
694.                                           && (printcnt >; 0))
     
695.                            {
     
696.                                         printf("%5d: %5d\n",dloc,dMem[dloc]);
     
697.                                         dloc++;
     
698.                                         printcnt--;
     
699.                            }
     
700.                   }
     
701.                   break;
     
702. 
     
703.          case 'c' :                                        /* 清空虚拟机所有状态 */
     
704.                   iloc = 0;
     
705.                   dloc = 0;
     
706.                   stepcnt = 0;
     
707.                   for (regNo = 0;  regNo < NO_REGS ; regNo++)
     
708.                            reg[regNo] = 0 ;
     
709.                   dMem[0] = DADDR_SIZE - 1 ;
     
710.                   for (loc = 1 ; loc < DADDR_SIZE ; loc++)
     
711.                            dMem[loc] = 0 ;
     
712.                   break;
     
713. 
     
714.          case 'q' :                                 /* 退出 */
     
715.                   return FALSE;  
     
716. 
     
717.          default :                                         /* 未知命令 */
     
718.                   printf("Command %c unknown.\n", cmd);
     
719.                   break;
     
720.          }  /* case */
     
721.          stepResult = srOKAY;
     
722.          if ( stepcnt >; 0 )
     
723.          {
     
724.                   if ( cmd == 'g' )
     
725.                   {
     
726.                            stepcnt = 0;
     
727.                            /* 当命令行参数是g的时候，就一直执行程序 */
     
728.                            while (stepResult == srOKAY)
     
729.                            {
     
730.                                         iloc = reg[PC_REG] ;
     
731.                                         /* 如果设置了跟踪标志，那么在stdout上打印出执行的指令 */
     
732.                                         if ( traceflag )
     
733.                                                  writeInstruction( iloc ) ;
     
734.                                         stepResult = stepTM ();
     
735.                                         stepcnt++;
     
736.                            }
     
737.                            /* 打印出执行的指令数量 */
     
738.                            if ( icountflag )
     
739.                                         printf("Number of instructions executed = %d\n",stepcnt);
     
740.                   }
     
741.                   else                                        /* 否则根据stepResult中指定的步长执行指令 */
     
742.                   {
     
743.                            while ((stepcnt >; 0) && (stepResult == srOKAY))
     
744.                            {
     
745.                                         iloc = reg[PC_REG] ;
     
746.                                         if ( traceflag )
     
747.                                                  writeInstruction( iloc ) ;
     
748.                                         stepResult = stepTM ();
     
749.                                         stepcnt-- ;
     
750.                            }
     
751.                   }
     
752.                   printf( "%s\n",stepResultTab[stepResult] );
     
753.          }
     
754.          return TRUE;
     
755. } /* doCommand */
     
756. 
     
757. /********************************************************************************************
     
758. *int main( int argc, char * argv[] ):主函数
     
759. ********************************************************************************************/
     
760. int main( int argc, char * argv[] )
     
761. {
     
762.          if (argc != 2)
     
763.          { printf("usage: %s <filename>;\n",argv[0]);
     
764.                   exit(1);
     
765.          }
     
766.          strcpy(pgmName,argv[1]) ;
     
767.          if (strchr (pgmName, '.') == NULL)
     
768.                   strcat(pgmName,".tm");
     
769.          pgm = fopen(pgmName,"r");
     
770.          if (pgm == NULL)
     
771.          { printf("file '%s' not found\n",pgmName);
     
772.                   exit(1);
     
773.          }
     
774. 
     
775.          /* read the program */
     
776.          if ( ! readInstructions ())
     
777.                   exit(1) ;
     
778.          /* switch input file to terminal */
     
779.          /* reset( input ); */
     
780.          /* read-eval-print */
     
781.          printf("TM  simulation (enter h for help)...\n");
     
782.          do
     
783.                   done = ! doCommand ();
     
784.          while (! done );
     
785.          printf("Simulation done.\n");
     
786. 
     
787.          return 0;
     
788. }
     
789. 
     

复制代码

benlan

学习
混一贴先