translator.java

该文件为编译器解释器的代码

	/* 输出数据(dMem)命令:可输入"d(Mem<b<n>>"来执行,*
	 * 从地址b处输出n跳数据				*/
        hel=hel+"   d(Mem <b <n>>	:Print n dMem locations starting at b\n";

	/* 跟踪(trace)命令:可输入"t(race"来执行,	*
	 * 反置追踪标志traceflag,如果traceflag为TRUE,	*
	 * 则执行每条指令时候显示指令			*/
        hel=hel+"   t(race	:Toggle instruction trace\n";

	  /* 显示执行指令数量(print)命令:可输入"p(rint)"来执行,	*
	   * 反置追踪标志icountflag,如果icountflag为TRUE,	*
	   * 则显示已经执行过的指令数量.只在执行"go"命令时有效	*/
        hel=hel+"   p(rint	:Toggle print of total instructions executed"+"(go  only)"+"\n";

	  /* 重置tm机用(clear)命令:可输入"c(lear"来执行,	*
	   * 重新设置tm虚拟机,用以执行新的程序.			*/
        hel=hel+"   c(lear	:Reset simulator for new execution of program\n";

	  /* 帮助(help)命令:可输入"h(elp"来执行,显示命令列表 */
        hel=hel+"   h(elp	:Cause this list of commands to be printed\n";

	  /* 终止(quit)命令,可输入"q(uit"来执行,结束虚拟机的执行 */
        hel=hel+"   q(uit	:Terminate the simulation\n";

        name="显示命令及其功能";
        expr=hel;

        break;
        /**************************************************************/

	/* 跟踪显示所有执行过指令的p命令 */
        case 'p' :

        icountflag = !icountflag;		/* 设置执行指令计数标志 */

	/* 输出p命令执行的结果信息 */
        String pstr="Printing instruction count now ";
        if (icountflag) 
            pstr=pstr+"on.\n"; 
        else
            pstr=pstr+"off.\n";

        name="显示所有执行过指令";
        expr=pstr;

        break;
        /**************************************************************/

	/* 按步执行s命令 */
        case 's' :

	/* 缺省的命令模式,不带命令参数,单步执行 */
        if (atEOL())  
            stepcnt = 1;
	/* 带有命令参数的命令模式,取得参数stepcnt,取绝对值 */
        else if (getNum()) 
        { 
            if(num>0)
                stepcnt = num;
            else 
                stepcnt = -num;
        }
	/* 输出未知命令执行步数信息 */
        else 
        { 
            name="未知命令执行步";
            expr="Step count?\n";
	}
        break;
        /**************************************************************/


	/* 执行到结束g命令 */
        case 'g' :   
         
        stepcnt = 1;    
        break;
        /**************************************************************/

        /* 显示寄存器内容(regs)命令 */
        case 'r' :

  	/* 格式化显示所有寄存器内容 */
        String rstr="\n";
        for (i = 0;i < NO_REGS;i++)
            rstr=rstr+String.valueOf(i)+":"+String.valueOf(reg[i])+"\n";

        name="显示寄存器内容";
        expr=rstr;
        break;
        /**************************************************************/

	/* 输出指令存储区iMem中指令的i命令 */
        case 'i' :

	/* 初始化输出指令数printcnt为1 */
	printcnt = 1;

        if(getNum())
        { 
	    /* 得到命令的第一个执行参数,iloc指定输出指令的开始地址 */
	    iloc = num;
		
	    /* 得到命令的第二个执行参数,printcnt指定输出指令的数量 */
            if (getNum()) 
                printcnt = num;
             
	    /* 指令地址iloc在指令存储区iMem地址范围中,			*
             * 且指令输出数量printcnt大于0,从iloc指定地址输出指定数量指令*/
            if((iloc >= 0) && (iloc < IADDR_SIZE) && (printcnt > 0))
                name="指令存储区中指令";
	    while((iloc >= 0) && (iloc < IADDR_SIZE) && (printcnt > 0))
            { 
                writeInstruction(iloc);
                iloc++;
                printcnt--;
            }
        }
	/* 未给定指令开始地址和输出指令数量 */
        else
        {
            name="未给定指令开始地址和输出指令数量";
            expr="Instruction locations?\n";
        }
        break;
        /**************************************************************/

	/* 输出数据存储区dMem中的数据的d命令 */
        case 'd' :

	printcnt = 1;
        if(getNum())
        { 
	    /* 取得命令的第一执行参数,数据存储的开始地址dloc */
	    dloc = num;

		/* 取得命令的第二执行参数,输出数据的数量printcnt */
            if(getNum()) 
                printcnt = num;
   
            String dstr="\n";
  	    /* 给定数据地址dloc在数据存储区dMen地址范围内,		*
	     * 且数据输出数量printcnt大于0,从dloc指定地址输出指定数量的数据 */
	    while((dloc >= 0) && (dloc < DADDR_SIZE) && (printcnt > 0))
            { 
                dstr=dstr+String.valueOf(dloc)+"  "+String.valueOf(dMem[dloc])+"\n";
                dloc++;
                printcnt--;
            }
            name="未给定数据存储区中的数据开始地址和数量";
            expr=dstr;
        }
	/* 未给定数据存储区中的数据开始地址和数量 */
        else
	{
            name="未给定数据存储区中的数据开始地址和数量";
            expr="Data locations?\n";
	}
        break;
        /**************************************************************/

        /* 重置tm机用以执行新的程序(clear)指令 */
        case 'c' :

        iloc = 0;		/* 指令存储地址,初始为0 */
        dloc = 0;		/* 数据存储地址,初始为0 */
        stepcnt = 0;		/* 指令执行步数,初始为0 */

	/* 初始化各寄存器reg[]为0 */
        for(regNo = 0;regNo < NO_REGS;regNo++)
            reg[regNo] = 0;			

	/* 数据存储区0地址单元用于记录数据存储区dMem的高端地址 */
        dMem[0] = DADDR_SIZE - 1;

	/* 初始化其它数据存储区单元为0 */
        for(loc = 1;loc < DADDR_SIZE;loc++)
            dMem[loc] = 0;				
        break;
        /**************************************************************/

        case 'q' : 

        do_com=false;		/* 停止执行并退出命令 */
        return;
        /**************************************************************/

	/* 其它未定义命令,输出错误信息 */
        default : 
        {
            name="未定义命令";
            expr="Command "+cmd+" unknown.\n";
        }
        break;
    }  /* case */

    /******************** 命令的后续处理 **********************/
    stepResult = "OKAY";		/* 命令执行结果为OKAY */

    if (stepcnt > 0)
    {
        if (cmd == 'g')
        { 
            /* 此处stepcnt作为已经执行过的指令数目 */
            stepcnt = 0;
            /* 根据执行指令追踪标志traceflag,将当前地址iloc上指令输出到屏幕 */
            iloc = reg[PC_REG];
            if(traceflag) 
            {
       		name=" ";
        	writeInstruction(iloc);
            }

            /* 单步执行当前指令,结果返回stepResult */
            stepTM();
        }
        else 
        {
   	    /* 取得程序计数器reg[PC_REG]中当前指令地址 */
    	    iloc = reg[PC_REG];

    	    /* 根据执行指令追踪标志traceflag,将当前指令地址iloc上指令输出到屏幕 */
    	    if(traceflag) 
    	    {
        	name=" ";
        	writeInstruction(iloc);
    	    }

    	    /* 执行当前指令,结果返回stepResult */
    	    stepTM();
        }
    } 
    else
        step0(); 
}

/************************************************/
/* 函数名 step0				        */
/* 功  能 			                */
/* 说  明 命令执行完毕,输出结果	                */
/************************************************/
void step0()
{
    /* 根据执行结果的枚举值,查执行结果状态表,显示结果状态 */
    if(name==null)
    {
        name="结果状态";
        expr=expr+"\n"+"结果状态"+String.valueOf(stepResult)+"\n";
    }
    else
       expr=expr+"\n"+"结果状态"+":"+String.valueOf(stepResult)+"\n";
    xwin=new XWindow(name,expr);
    xwin.setVisible(true);

    expr="\n";
    do_com=true;
    enterCom();
}

/************************************************/
/* 函数名 stepTM				*/
/* 功  能 TM机单步执行函数			*/
/* 说  明 函数为一条指令解释执行,完成指令动作.	*/
/************************************************/
void stepTM()
{ 
    /* currentinstruction 用于存储当前将执行的指令 */
    Instruction currentinstruction;		

    int pc;			/* 程序计数器 */
    int r=0,s=0,t=0,m=0;	/* 指令操作数 */  
    boolean ok;	
    String ssiop;		

    do
    {
        r=0;
        s=0;
        t=0;
        m=0;

        /* pc设置为第7个寄存器reg[7]的值,为程序计数器 */
        pc = reg[PC_REG];						

        if((pc < 0) || (pc > IADDR_SIZE))
        {
            /* pc的值不是指令存储区的有效地址,报指令存储错,函数返回IMEM_ERR */
            stepResult="IMEM_ERR";
            return;
        }

        /* pc的值为有效指令地址,将程序计数器reg[PC_REG]的值加1 */
        reg[PC_REG] = pc + 1;

        /* 从指令存储区iMem之中取出当前指令 */
        currentinstruction = iMem[pc];

        /* 对取出的指令的寻址模式分类处理,初始化各个指令操作数变量 */
        String siop=opClass(opNum(currentinstruction.iop));
        if(siop.equals("opclRR"))
        { 
            /* 寄存器寻址模式 */
            r = currentinstruction.iarg1;
            s = currentinstruction.iarg2;
            t = currentinstruction.iarg3;
        }
        else if(siop.equals("opclRM"))
        {		
            /* 寄存器-内存寻址模式 */
	    r = currentinstruction.iarg1;
            s = currentinstruction.iarg3;
            m = currentinstruction.iarg2 + reg[s];
      
	    /* 操作数m非数据存储区有效地址,报数据存储错,函数返回DMEM_ERR */
	    if((m < 0) || (m > DADDR_SIZE))
           {
                stepResult="DMEM_ERR";
                return;
           }
        }
        else if(siop.equals("opclRA"))
        {		
            /* 寄存器-立即数寻址模式 */
            r = currentinstruction.iarg1;
            s = currentinstruction.iarg3;
            m = currentinstruction.iarg2 + reg[s];
        }

        /* 对将执行指令的操作码值进行分类处理,输出指令信息,	*
         * 完成指令动作,返回相应结果状态		*/
        ssiop=currentinstruction.iop;
        /******************** RR指令 ******************/
        /**********************************************/
        /**********************************************/
        if(ssiop.equals("IN")) 
        {
             in_s=r;
             break;
        }
        else 
    	{
    	    if(ssiop.equals("HALT"))
    	    {
           	 /* 格式化屏幕显示HALT(停止)指令,返回状态HALT(停止) */
          	 expr=expr+"HALT: "+String.valueOf(r)+","+String.valueOf(s)+","+String.valueOf(t)+"\n";
        	 stepResult="HALT";
    	    }

    	    /**********************************************/
    	    else if(ssiop.equals("OUT")) 
       	    /* 屏幕显示OUT指令执行的结果信息 */ 
        	expr=expr+"OUT instruction prints: "+String.valueOf(reg[r])+"\n";

            /**********************************************/
    	    else if(ssiop.equals("ADD")) 
	 	/* 完成ADD指令操作 */
        	reg[r] = reg[s] + reg[t]; 

    	    /**********************************************/
            else if(ssiop.equals("SUB")) 
		/* 完成SUB指令操作 */
        	reg[r] = reg[s] - reg[t]; 

    	    /**********************************************/
   	    else if(ssiop.equals("MUL")) 
		/* 完成MUL指令操作 */
        	reg[r] = reg[s] * reg[t]; 

    	    /**********************************************/
    	    else if(ssiop.equals("DIV")) 
            {
		/* 对于除法指令,若除数为0,则报除零错误, *
	 	* 并返回ZERODIVIDE;否则,完成除法操作 */
		if(reg[t] != 0) 
            	    reg[r] = reg[s] / reg[t];
        	else 
           	    stepResult="ZERODIVIDE";
    	    }

   	    /***************** RM 指令 ********************/
    	    /**********************************************/
    	    else if(ssiop.equals("LD")) 
		/* 将数据存储区dMem中的数据载入到寄存器reg[r] */
       		 reg[r] = dMem[m]; 
 
    	    /**********************************************/
   	    else if(ssiop.equals("ST")) 
		/* 将寄存器reg[r]中的数据写入到数据存储区dMem */
        	dMem[m] = reg[r];  
		
    	    /***************** RA 指令 ********************/
    	    /**********************************************/
    	    else if(ssiop.equals("LDA"))