cgen.c

1.小型编译器 2。支持整数

			else if(s == StrCpyC){
				m = reg[ac];
				n = reg[ac1];
				for(;;){
					memcpy(&c,(BYTE*)&dMem[m],sizeofchar);
					printf("m:%d n:%d c:%c\n", m, n, c);
					memcpy((BYTE*)&dMem[n++],(BYTE*)&dMem[m++],sizeofchar);
					if(c == '\0')
						break;
				}			
			}
			break;

		case opPUSH:
			if(currentinstruction.isize == sizeofdouble){
				memcpy((BYTE*)&dNum,&dreg[r],sizeofdouble);
				printf("PUSH dNum:%f\n", dNum);
				mStack.PushD(dNum);
			} else if(currentinstruction.isize == sizeofint){
				memcpy((BYTE*)&iNum,&reg[r],sizeofint);
				printf("PUSH iNum:%d\n", iNum);
				mStack.Push(iNum);
			} else if(currentinstruction.isize == sizeofchar){
				memcpy((BYTE*)&c,&reg[r],sizeofchar);
				printf("PUSH char:%c\n", c);
				mStack.PushC(c);
			}					
			break;

		case opPOP:
			if(currentinstruction.isize == sizeofdouble){
				dNum = mStack.PopD();
				printf("POP dNum:%f\n", dNum);
				memcpy(&dreg[r],(BYTE*)&dNum,sizeofdouble);

				//浮点数转换成整数
				if(currentinstruction.itrans == 2){
					iNum = dNum;
					memcpy(&reg[r],(BYTE*)&iNum,sizeofint);
				}
			} else if(currentinstruction.isize == sizeofint){
				iNum = mStack.Pop();
				printf("POP iNum:%d\n", iNum);
				memcpy(&reg[r],(BYTE*)&iNum,sizeofint);
			} else if(currentinstruction.isize == sizeofchar){
				c = mStack.PopC();
				printf("POP char:%c\n", c);
				memcpy(&reg[r],(BYTE*)&c,sizeofchar);
			}
			break;

		case opCOPY:
			memcpy((BYTE*)&iNum,&reg[r],sizeofint);
			memcpy((BYTE*)&iNum2,&reg[s],sizeofint);
			printf("COPY reg[%d]:%d, reg[%d]:%d\n", r, iNum, s, iNum2);
			memcpy(&dMem[iNum], &dMem[iNum2],t);
			//memcpy(&dMem[reg[r]], &dMem[reg[s]],t);
			break;

		case opRET:
			if(r == 1)
				return srOver;
			break;

    	case opADD :  
			if(currentinstruction.isize == sizeofdouble){
				memcpy((BYTE*)&dNum,&dreg[s],sizeofdouble);
				memcpy((BYTE*)&dNum2,&dreg[t],sizeofdouble);
				dNum += dNum2;
				memcpy(&dreg[r],(BYTE*)&dNum,sizeofdouble);
			} else {
				memcpy((BYTE*)&iNum,&reg[s],sizeofint);
				memcpy((BYTE*)&iNum2,&reg[t],sizeofint);
				iNum += iNum2;
				memcpy(&reg[r],(BYTE*)&iNum,sizeofint);
				//reg[r] = reg[s] + reg[t] ;  
			}
			break;
    	case opSUB :
			if(currentinstruction.isize == sizeofdouble){
				memcpy((BYTE*)&dNum,&dreg[s],sizeofdouble);
				memcpy((BYTE*)&dNum2,&dreg[t],sizeofdouble);
				dNum -= dNum2;
				memcpy(&dreg[r],(BYTE*)&dNum,sizeofdouble);
			} else {
				memcpy((BYTE*)&iNum,&reg[s],sizeofint);
				memcpy((BYTE*)&iNum2,&reg[t],sizeofint);
				iNum -= iNum2;
				memcpy(&reg[r],(BYTE*)&iNum,sizeofint);
				//reg[r] = reg[s] - reg[t] ;  
			}
			break;
    	case opMUL : 
			if(currentinstruction.isize == sizeofdouble){
				memcpy((BYTE*)&dNum,&dreg[s],sizeofdouble);
				memcpy((BYTE*)&dNum2,&dreg[t],sizeofdouble);
				dNum *= dNum2;
				memcpy(&dreg[r],(BYTE*)&dNum,sizeofdouble);
			} else {
				memcpy((BYTE*)&iNum,&reg[s],sizeofint);
				memcpy((BYTE*)&iNum2,&reg[t],sizeofint);
				iNum *= iNum2;
				memcpy(&reg[r],(BYTE*)&iNum,sizeofint);
				//reg[r] = reg[s] * reg[t] ;  
			}
			break;

   		case opDIV :
    		/***********************************/
			if(currentinstruction.isize == sizeofdouble){
				memcpy((BYTE*)&dNum,&dreg[s],sizeofdouble);
				memcpy((BYTE*)&dNum2,&dreg[t],sizeofdouble);	
      			if ( dNum2 != 0 ){ 
					dNum = dNum/ dNum2;
      			} else 
					return srZERODIVIDE ;
				memcpy(&dreg[r],(BYTE*)&dNum,sizeofdouble);
			} else {
				memcpy((BYTE*)&iNum,&reg[s],sizeofint);
				memcpy((BYTE*)&iNum2,&reg[t],sizeofint);		
				//if ( reg[t] != 0 ) 
				//	reg[r] = reg[s] / reg[t];
				if(iNum2 != 0)
					iNum = iNum / iNum2;
      			else 
					return srZERODIVIDE ;
				memcpy(&reg[r],(BYTE*)&iNum,sizeofint);
			}
      		break;

    	/*************** RM instructions ********************/
    	case opLD :    
			//reg[r] = dMem[m] ;  
			if(currentinstruction.itrans == 1){
				//整数数转换成浮点数
				memcpy(&iNum, &dMem[m],sizeofint);
				dNum = iNum;
				memcpy(&dreg[r], &dNum,sizeofdouble);
			}else if(currentinstruction.itrans == 2){
				//浮点数转换成整数
				memcpy(&dNum, &dMem[m],sizeofdouble);
				iNum = dNum;
				memcpy(&reg[r], &iNum,sizeofint);
			}else if(currentinstruction.isize == sizeofdouble)
				memcpy(&dreg[r], &dMem[m],sizeofdouble);
			else if(currentinstruction.isize == sizeofint)
				memcpy(&reg[r], &dMem[m],sizeofint);
			else if(currentinstruction.isize == sizeofchar)
				memcpy(&reg[r], &dMem[m],sizeofchar);			

			if(currentinstruction.itrans == 1)
				printf("LDDTD m: %d dreg[%d]: %f\n",m, r,dreg[r]); 
			else if(currentinstruction.itrans == 2)
				printf("LDDTI m: %d dreg[%d]: %d\n",m, r,reg[r]); 
			else if(currentinstruction.isize == sizeofdouble)
				printf("LDD m: %d dreg[%d]: %f\n",m, r,dreg[r]); 
			else if(currentinstruction.isize == sizeofint){
				memcpy((BYTE*)&iNum,(BYTE*)&reg[r],sizeofint);
				printf("LDI m: %d reg[%d]: %d\n",m, r,iNum); 
			}else if(currentinstruction.isize == sizeofchar){
				memcpy((BYTE*)&c,(BYTE*)&reg[r],sizeofchar);
				printf("LDC m: %d reg[%d]: %c\n",m, r,c); 
			}
			break;
			
    	case opST :    
			//dMem[m] = reg[r] ; 
			if(currentinstruction.isize == sizeofdouble)
				memcpy((BYTE*)&dMem[m],(BYTE*)&dreg[r],sizeofdouble);
			else if(currentinstruction.isize == sizeofint)
				memcpy((BYTE*)&dMem[m],(BYTE*)&reg[r],sizeofint);
			else if(currentinstruction.isize == sizeofchar)
				memcpy((BYTE*)&dMem[m],(BYTE*)&reg[r],sizeofchar);
			
			if(currentinstruction.isize == sizeofdouble)
				printf("STD m: %d dreg[%d]: %f\n", m, r,dreg[r]); 
			else if(currentinstruction.isize == sizeofint){
				memcpy((BYTE*)&iNum,(BYTE*)&reg[r],sizeofint);
				printf("STI m: %d reg[%d]: %d\n", m, r, iNum); 
			}else if(currentinstruction.isize == sizeofchar){
				memcpy((BYTE*)&c,(BYTE*)&reg[r],sizeofchar);
				printf("STC m: %d reg[%d]: %c\n", m, r, c); 
			}
			break;

    	/*************** RA instructions ********************/
    	case opLDA :    
			reg[r] = m ; 
			memcpy(&reg[r], &m, sizeofint);
			memcpy(&iNum, &reg[r], sizeofint);
			printf("LDA m: %d %d\n", m, iNum);
			break;
    	case opLDC :    
			if(currentinstruction.isize == sizeofdouble){
				dNum = currentinstruction.darg2 ; 
				memcpy(&dreg[r], &dNum, sizeofdouble);
			} else if(currentinstruction.isize == sizeofint){
				iNum = currentinstruction.iarg2 ;
				memcpy(&reg[r], &iNum, sizeofint);	
				printf("LDCI reg[%d]: %d\n", r, iNum); 
			}else if(currentinstruction.isize == sizeofchar){
				c = currentinstruction.iarg2 ;
				memcpy(&reg[r], &c, sizeofchar);
				printf("LDCC reg[%d]: %c\n", r, c); 
			}
			break;
    	case opLT :   			
			if(currentinstruction.isize == sizeofdouble){
				memcpy((BYTE*)&dNum,&dreg[s],sizeofdouble);
				memcpy((BYTE*)&dNum2,&dreg[t],sizeofdouble);
				printf("LTD reg[%d]: %f reg[%d]:%f\n", s,dreg[s], t, dreg[t]);
				if (dNum < dNum2) 
					reg[r] = 1 ; 
				else
					reg[r] = 0 ; 
			}else if(currentinstruction.isize == sizeofint){
				memcpy((BYTE*)&iNum,&reg[s],sizeofint);
				memcpy((BYTE*)&iNum2,&reg[t],sizeofint);
				printf("LTI reg[%d]: %d reg[%d]:%d\n", s,iNum, t, iNum2);
				if(iNum < iNum2) 
				//if(reg[s] < reg[t])
					reg[r] = 1 ; 
				else
					reg[r] = 0 ; 
			}else if(currentinstruction.isize == sizeofchar){
				memcpy((BYTE*)&c,&reg[s],sizeofchar);
				memcpy((BYTE*)&c2,&reg[t],sizeofchar);
				printf("LTC reg[%d]: %c reg[%d]:%c\n", s,c, t, c2);
				if(c < c2) 
					reg[r] = 1 ; 
				else
					reg[r] = 0 ;
			}
			break;
    	case opLE :    
			if(currentinstruction.isize == sizeofdouble){
				memcpy((BYTE*)&dNum,&dreg[s],sizeofdouble);
				memcpy((BYTE*)&dNum2,&dreg[t],sizeofdouble);
				printf("LED reg[%d]: %f reg[%d]:%f\n", s,dreg[s], t, dreg[t]);
				if (dNum <= dNum2) 
					reg[r] = 1 ; 
				else
					reg[r] = 0 ; 
			}else if(currentinstruction.isize == sizeofint){
				memcpy((BYTE*)&iNum,&reg[s],sizeofint);
				memcpy((BYTE*)&iNum2,&reg[t],sizeofint);
				printf("LEI reg[%d]: %d reg[%d]:%d\n", s,iNum, t, iNum2);
				if(iNum <= iNum2) 
					reg[r] = 1 ; 
				else
					reg[r] = 0 ; 
			}else if(currentinstruction.isize == sizeofchar){
				memcpy((BYTE*)&c,&reg[s],sizeofchar);
				memcpy((BYTE*)&c2,&reg[t],sizeofchar);
				printf("LEC reg[%d]: %c reg[%d]:%c\n", s,c, t, c2);
				if(c <= c2) 
					reg[r] = 1 ; 
				else
					reg[r] = 0 ;
			}
			break;
    	case opGT :   			
			if(currentinstruction.isize == sizeofdouble){
				memcpy((BYTE*)&dNum,&dreg[s],sizeofdouble);
				memcpy((BYTE*)&dNum2,&dreg[t],sizeofdouble);
				printf("GTD reg[%d]: %f reg[%d]:%f\n", s,dreg[s], t, dreg[t]);
				if(dNum > dNum2) 
					reg[r] = 1 ; 
				else
					reg[r] = 0 ; 
			}else if(currentinstruction.isize == sizeofint){
				memcpy((BYTE*)&iNum,&reg[s],sizeofint);
				memcpy((BYTE*)&iNum2,&reg[t],sizeofint);
				printf("GTI reg[%d]: %d reg[%d]:%d\n", s,iNum, t, iNum2);
				if(iNum > iNum2) 
					reg[r] = 1 ; 
				else
					reg[r] = 0 ; 
			}else if(currentinstruction.isize == sizeofchar){
				memcpy((BYTE*)&c,&reg[s],sizeofchar);
				memcpy((BYTE*)&c2,&reg[t],sizeofchar);
				printf("GTC reg[%d]: %c reg[%d]:%c\n", s, c, t, c2);
				if(c > c2) 
					reg[r] = 1 ; 
				else
					reg[r] = 0 ;
			}
			break;
    	case opGE :    
			if(currentinstruction.isize == sizeofdouble){
				memcpy((BYTE*)&dNum,&dreg[s],sizeofdouble);
				memcpy((BYTE*)&dNum2,&dreg[t],sizeofdouble);
				printf("GED reg[%d]: %f reg[%d]:%f\n", s,dreg[s], t, dreg[t]);
				if(dNum >= dNum2) 
					reg[r] = 1 ; 
				else
					reg[r] = 0 ; 
			}else if(currentinstruction.isize == sizeofint){
				memcpy((BYTE*)&iNum,&reg[s],sizeofint);
				memcpy((BYTE*)&iNum2,&reg[t],sizeofint);
				printf("GEI reg[%d]: %d reg[%d]:%d\n", s,iNum, t, iNum2);
				if(iNum >= iNum2) 
					reg[r] = 1 ; 
				else
					reg[r] = 0 ; 
			}else if(currentinstruction.isize == sizeofchar){
				memcpy((BYTE*)&c,&reg[s],sizeofchar);
				memcpy((BYTE*)&c2,&reg[t],sizeofchar);
				printf("GEC reg[%d]: %c reg[%d]:%c\n", s,c, t, c2);
				if(c >= c2) 
					reg[r] = 1 ; 
				else
					reg[r] = 0 ;
			}
			break;
    	case opEQ :    
			if(currentinstruction.isize == sizeofdouble){
				memcpy((BYTE*)&dNum,&dreg[s],sizeofdouble);
				memcpy((BYTE*)&dNum2,&dreg[t],sizeofdouble);
				printf("EQD reg[%d]: %f reg[%d]:%f\n", s,dreg[s], t,dreg[t]);
				if(dNum == dNum2) 
					reg[r] = 1 ; 
				else
					reg[r] = 0 ; 
			}else if(currentinstruction.isize == sizeofint){
				memcpy((BYTE*)&iNum,&reg[s],sizeofint);
				memcpy((BYTE*)&iNum2,&reg[t],sizeofint);
				printf("EQI reg[%d]: %d reg[%d]:%d\n", s,iNum, t, iNum2);
				if(iNum == iNum2) 
					reg[r] = 1 ; 
				else
					reg[r] = 0 ; 
			}else if(currentinstruction.isize == sizeofchar){
				memcpy((BYTE*)&c,&reg[s],sizeofchar);
				memcpy((BYTE*)&c2,&reg[t],sizeofchar);
				printf("EQC reg[%d]: %c reg[%d]:%c\n", s,c, t, c2);
				if(c == c2) 
					reg[r] = 1 ; 
				else
					reg[r] = 0 ;
			}
			break;
    	case opNEQ :    
			if(currentinstruction.isize == sizeofdouble){
				memcpy((BYTE*)&dNum,&dreg[s],sizeofdouble);
				memcpy((BYTE*)&dNum2,&dreg[t],sizeofdouble);
				printf("NEQD reg[%d]: %f reg[%d]:%f\n", s,dreg[s], t, dreg[t]);
				if(dNum != dNum2) 
					reg[r] = 1 ; 
				else
					reg[r] = 0 ; 
			}else if(currentinstruction.isize == sizeofint){
				memcpy((BYTE*)&iNum,&reg[s],sizeofint);
				memcpy((BYTE*)&iNum2,&reg[t],sizeofint);
				printf("NEQI reg[%d]: %d reg[%d]:%d\n", s,iNum, t, iNum2);
				if(iNum != iNum2) 
					reg[r] = 1 ; 
				else
					reg[r] = 0 ; 
			}else if(currentinstruction.isize == sizeofchar){
				memcpy((BYTE*)&c,&reg[s],sizeofchar);
				memcpy((BYTE*)&c2,&reg[t],sizeofchar);
				printf("NEQCC reg[%d]: %c reg[%d]:%c\n", s,c, t, c2);
				if(c != c2) 
					reg[r] = 1 ; 
				else
					reg[r] = 0 ;
			}
			break;

		case opFJP:
			if(reg[ac] == 0){
				printf("FJP lable %d, index %d\n", currentinstruction.iarg1, mIndex[currentinstruction.iarg1]);
				reg[PC_REG] = mIndex[currentinstruction.iarg1];
			}
			break;
		case opUJP:
			printf("UJP lable %d, index %d\n", currentinstruction.iarg1, mIndex[currentinstruction.iarg1]);
			reg[PC_REG] = mIndex[currentinstruction.iarg1];
			break;

    /* end of legal instructions */
  	} /* case */
  	return srOKAY ;
} /* stepTM */

int	doRun(){
	//初始化
	int stepResult, regNo, loc, stepTotal, i;
	int stepcnt=0;
	bool	bMain = false;
	
	iloc = 0;
  	dloc = 0;
  	for (regNo = 0;  regNo < NO_REGS ; regNo++)
    	reg[regNo] = 0 ;
	for (loc = 2 ; loc < DADDR_SIZE ; loc++)
    	dMem[loc] = 0 ;
	WORD	maxSize = DADDR_SIZE;
	memcpy(&dMem[0], &maxSize, sizeof(WORD));

/*
	int k, b, a = 8;
	double j, f, e = 2.2;
	char d, i, o, c = 'e';
	reg[0] = 'f';
	printf("reg[0]:%c\n", reg[0]);
	memcpy(&dMem[0], &c, sizeofchar);
	memcpy(&dMem[1], &a, sizeofint);
	memcpy(&dMem[5], &e, sizeofdouble);
	memcpy(&reg[0], &dMem[0], sizeofchar);
	memcpy(&d, &dMem[0], sizeofchar);
	memcpy(&i, &reg[0], sizeofchar);
	o = reg[0];
	printf("reg[0]:%c %c %c %c\n",reg[0],d, i, o);
	memcpy(&reg[0], &dMem[1], sizeofint);
	memcpy(&b, &dMem[1], sizeofint);
	printf("reg[0]:%c %d\n",reg[0],b);

	memcpy(&reg[0], &dMem[5], sizeofdouble);
	memcpy(&f, &dMem[5], sizeofdouble);
	printf("reg[0]:%f %f\n",reg[0], f);
	exit(0);
*/

	printf("\nInstucation Begin: \n");
	for(loc = 0; loc < emitLoc; loc++)
		writeInstruction( loc ) ;
	printf("Instucation End: \n\n");

	//return 0;

	//确定标号的位置
	mIndex.clear();
	for(loc = 0; loc < emitLoc; loc++){
		if(iMem[loc].iop == opLAB){
			printf("lab%d loc: %d\n", iMem[loc].iarg1, loc);
			mIndex[iMem[loc].iarg1] = loc;
		}
	}
	
	stepResult = srOKAY;
	stepTotal = 0;
	while (stepResult == srOKAY)
    { 
    	if(stepTotal > 200)
			break;
		
    	iloc = reg[PC_REG] ;
        if ( traceflag ) 
			writeInstruction( iloc ) ;
		stepcnt++;

		if(iloc == mStart["main"])
			bMain = true;

		if(!bMain && (iMem[iloc].iop == opENT))
		{
			while(iMem[iloc].iop != opRET)
				iloc++;
			iloc++;
			reg[PC_REG] = iloc;
			continue;
		}			
        stepResult = stepTM ();
		
		stepTotal++;
		
    }
	if((stepResult != srOKAY)&&(stepResult != srHALT)&&(stepResult != srOver))
		printf("Run Error !\n");
    if ( icountflag )
    	printf("Number of instructions executed = %d\n",stepcnt);

	return 0;
}