Skip to content

T
TM
提交 84ad0238 创建 作者: 赵鹏翀's avatar 赵鹏翀
浏览文件
操作

init template

上级
隐藏空白字符变更
内嵌 并排
正在显示 包含 663 行增加 和 0 行删除
.gitignore 0 → 100644
浏览文件 @ 84ad0238
/Debug
/Release
TM.cplproj 0 → 100644
浏览文件 @ 84ad0238
<?xml version="1.0" encoding="gb2312"?>
<OSLProject Version="1.00" Name="TM">
<Configurations>
<Configuration Name="Debug" CommandArgument="sample.tm.txt">
<Tool Name="PreBuildEventTool"/>
<Tool Name="CustomBuildTool" CommandLine="&quot;$(TargetPath)&quot; sample.tm.txt&#xA;" AdditionalDependencies="&quot;$(TargetPath)&quot;;sample.tm.txt"/>
<Tool Name="GCCCompilerTool" PreprocessorDefinitions="_DEBUG" GenerateDebugInformation="-1"/>
<Tool Name="PreLinkEventTool"/>
<Tool Name="GCCLinkerTool" OutputFile="$(ProjectName).exe"/>
<Tool Name="PostBuildEventTool"/>
</Configuration>
<Configuration Name="Release" CommandArgument="sample.tm.txt">
<Tool Name="PreBuildEventTool"/>
<Tool Name="CustomBuildTool" CommandLine="&quot;$(TargetPath)&quot; sample.tm.txt&#xA;" AdditionalDependencies="&quot;$(TargetPath)&quot;;sample.tm.txt"/>
<Tool Name="GCCCompilerTool" PreprocessorDefinitions="NDEBUG"/>
<Tool Name="PreLinkEventTool"/>
<Tool Name="GCCLinkerTool"/>
<Tool Name="PostBuildEventTool"/>
</Configuration>
</Configurations>
<Files>
<Filter Name="ִļ">
<File RelativePath=".\sample.tm.txt">
</File>
</Filter>
<Filter Name="Դļ" Filter="cpp;c;cc;cxx">
<File RelativePath=".\tm.c">
</File>
</Filter>
</Files>
</OSLProject>
TM.puo 0 → 100644
浏览文件 @ 84ad0238
添加文件
sample.tm.txt 0 → 100644
浏览文件 @ 84ad0238
0: LD 6,0(0)
1: ST 0,0(0)
2: IN 0,0,0
3: ST 0,0(5)
4: LDC 0,0(0)
5: ST 0,0(6)
6: LD 0,0(5)
7: LD 1,0(6)
8: SUB 0,1,0
9: JLT 0,2(7)
10: LDC 0,0(0)
11: LDA 7,1(7)
12: LDC 0,1(0)
14: LDC 0,1(0)
15: ST 0,1(5)
16: LD 0,1(5)
17: ST 0,0(6)
18: LD 0,0(5)
19: LD 1,0(6)
20: MUL 0,1,0
21: ST 0,1(5)
22: LD 0,0(5)
23: ST 0,0(6)
24: LDC 0,1(0)
25: LD 1,0(6)
26: SUB 0,1,0
27: ST 0,0(5)
28: LD 0,0(5)
29: ST 0,0(6)
30: LDC 0,0(0)
31: LD 1,0(6)
32: SUB 0,1,0
33: JEQ 0,2(7)
34: LDC 0,0(0)
35: LDA 7,1(7)
36: LDC 0,1(0)
37: JEQ 0,-22(7)
38: LD 0,1(5)
39: OUT 0,0,0
13: JEQ 0,27(7)
40: LDA 7,0(7)
41: HALT 0,0,0
tm.c 0 → 100644
浏览文件 @ 84ad0238
/****************************************************/
/* File: tm.c */
/* The TM ("Tiny Machine") computer */
/* Compiler Construction: Principles and Practice */
/* Kenneth C. Louden */
/****************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#ifndef TRUE
#define TRUE 1
#endif
#ifndef FALSE
#define FALSE 0
#endif
/******* const *******/
#define IADDR_SIZE 1024 /* increase for large programs */
#define DADDR_SIZE 1024 /* increase for large programs */
#define NO_REGS 8
#define PC_REG 7
#define LINESIZE 121
#define WORDSIZE 20
/******* type *******/
typedef enum {
opclRR, /* reg operands r,s,t */
opclRM, /* reg r, mem d+s */
opclRA /* reg r, int d+s */
} OPCLASS;
typedef enum {
/* RR instructions */
opHALT, /* RR halt, operands are ignored */
opIN, /* RR read into reg(r); s and t are ignored */
opOUT, /* RR write from reg(r), s and t are ignored */
opADD, /* RR reg(r) = reg(s)+reg(t) */
opSUB, /* RR reg(r) = reg(s)-reg(t) */
opMUL, /* RR reg(r) = reg(s)*reg(t) */
opDIV, /* RR reg(r) = reg(s)/reg(t) */
opRRLim, /* limit of RR opcodes */
/* RM instructions */
opLD, /* RM reg(r) = mem(d+reg(s)) */
opST, /* RM mem(d+reg(s)) = reg(r) */
opRMLim, /* Limit of RM opcodes */
/* RA instructions */
opLDA, /* RA reg(r) = d+reg(s) */
opLDC, /* RA reg(r) = d ; reg(s) is ignored */
opJLT, /* RA if reg(r)<0 then reg(7) = d+reg(s) */
opJLE, /* RA if reg(r)<=0 then reg(7) = d+reg(s) */
opJGT, /* RA if reg(r)>0 then reg(7) = d+reg(s) */
opJGE, /* RA if reg(r)>=0 then reg(7) = d+reg(s) */
opJEQ, /* RA if reg(r)==0 then reg(7) = d+reg(s) */
opJNE, /* RA if reg(r)!=0 then reg(7) = d+reg(s) */
opRALim /* Limit of RA opcodes */
} OPCODE;
typedef enum {
srOKAY,
srHALT,
srIMEM_ERR,
srDMEM_ERR,
srZERODIVIDE
} STEPRESULT;
typedef struct {
int iop ;
int iarg1 ;
int iarg2 ;
int iarg3 ;
} INSTRUCTION;
/******** vars ********/
int iloc = 0 ;
int dloc = 0 ;
int traceflag = FALSE;
int icountflag = FALSE;
INSTRUCTION iMem [IADDR_SIZE];
int dMem [DADDR_SIZE];
int reg [NO_REGS];
char * opCodeTab[]
= {"HALT","IN","OUT","ADD","SUB","MUL","DIV","????",
/* RR opcodes */
"LD","ST","????", /* RM opcodes */
"LDA","LDC","JLT","JLE","JGT","JGE","JEQ","JNE","????"
/* RA opcodes */
};
char * stepResultTab[]
= {"OK","Halted","Instruction Memory Fault",
"Data Memory Fault","Division by 0"
};
char pgmName[20];
FILE *pgm ;
char in_Line[LINESIZE] ;
int lineLen ;
int inCol ;
int num ;
char word[WORDSIZE] ;
char ch ;
int done ;
/********************************************/
int opClass( int c )
{ if ( c <= opRRLim) return ( opclRR );
else if ( c <= opRMLim) return ( opclRM );
else return ( opclRA );
} /* opClass */
/********************************************/
void writeInstruction ( int loc )
{ printf( "%5d: ", loc) ;
if ( (loc >= 0) && (loc < IADDR_SIZE) )
{ printf("%6s%3d,", opCodeTab[iMem[loc].iop], iMem[loc].iarg1);
switch ( opClass(iMem[loc].iop) )
{ case opclRR: printf("%1d,%1d", iMem[loc].iarg2, iMem[loc].iarg3);
break;
case opclRM:
case opclRA: printf("%3d(%1d)", iMem[loc].iarg2, iMem[loc].iarg3);
break;
}
printf ("\n") ;
}
} /* writeInstruction */
/********************************************/
void getCh (void)
{ if (++inCol < lineLen)
ch = in_Line[inCol] ;
else ch = ' ' ;
} /* getCh */
/********************************************/
int nonBlank (void)
{ while ((inCol < lineLen)
&& (in_Line[inCol] == ' ') )
inCol++ ;
if (inCol < lineLen)
{ ch = in_Line[inCol] ;
return TRUE ; }
else
{ ch = ' ' ;
return FALSE ; }
} /* nonBlank */
/********************************************/
int getNum (void)
{ int sign;
int term;
int temp = FALSE;
num = 0 ;
do
{ sign = 1;
while ( nonBlank() && ((ch == '+') || (ch == '-')) )
{ temp = FALSE ;
if (ch == '-') sign = - sign ;
getCh();
}
term = 0 ;
nonBlank();
while (isdigit(ch))
{ temp = TRUE ;
term = term * 10 + ( ch - '0' ) ;
getCh();
}
num = num + (term * sign) ;
} while ( (nonBlank()) && ((ch == '+') || (ch == '-')) ) ;
return temp;
} /* getNum */
/********************************************/
int getWord (void)
{ int temp = FALSE;
int length = 0;
if (nonBlank ())
{ while (isalnum(ch))
{ if (length < WORDSIZE-1) word [length++] = ch ;
getCh() ;
}
word[length] = '\0';
temp = (length != 0);
}
return temp;
} /* getWord */
/********************************************/
int skipCh ( char c )
{ int temp = FALSE;
if ( nonBlank() && (ch == c) )
{ getCh();
temp = TRUE;
}
return temp;
} /* skipCh */
/********************************************/
int atEOL(void)
{ return ( ! nonBlank ());
} /* atEOL */
/********************************************/
int error( char * msg, int lineNo, int instNo)
{ printf("Line %d",lineNo);
if (instNo >= 0) printf(" (Instruction %d)",instNo);
printf(" %s\n",msg);
return FALSE;
} /* error */
/********************************************/
int readInstructions (void)
{ OPCODE op;
int arg1, arg2, arg3;
int loc, regNo, lineNo;
for (regNo = 0 ; regNo < NO_REGS ; regNo++)
reg[regNo] = 0 ;
dMem[0] = DADDR_SIZE - 1 ;
for (loc = 1 ; loc < DADDR_SIZE ; loc++)
dMem[loc] = 0 ;
for (loc = 0 ; loc < IADDR_SIZE ; loc++)
{ iMem[loc].iop = opHALT ;
iMem[loc].iarg1 = 0 ;
iMem[loc].iarg2 = 0 ;
iMem[loc].iarg3 = 0 ;
}
lineNo = 0 ;
while (! feof(pgm))
{ fgets( in_Line, LINESIZE-2, pgm ) ;
inCol = 0 ;
lineNo++;
lineLen = strlen(in_Line)-1 ;
if (in_Line[lineLen]=='\n') in_Line[lineLen] = '\0' ;
else in_Line[++lineLen] = '\0';
if ( (nonBlank()) && (in_Line[inCol] != '*') )
{ if (! getNum())
return error("Bad location", lineNo,-1);
loc = num;
if (loc > IADDR_SIZE)
return error("Location too large",lineNo,loc);
if (! skipCh(':'))
return error("Missing colon", lineNo,loc);
if (! getWord ())
return error("Missing opcode", lineNo,loc);
op = opHALT ;
while ((op < opRALim)
&& (strncmp(opCodeTab[op], word, 4) != 0) )
op++ ;
if (strncmp(opCodeTab[op], word, 4) != 0)
return error("Illegal opcode", lineNo,loc);
switch ( opClass(op) )
{ case opclRR :
/***********************************/
if ( (! getNum ()) || (num < 0) || (num >= NO_REGS) )
return error("Bad first register", lineNo,loc);
arg1 = num;
if ( ! skipCh(','))
return error("Missing comma", lineNo, loc);
if ( (! getNum ()) || (num < 0) || (num >= NO_REGS) )
return error("Bad second register", lineNo, loc);
arg2 = num;
if ( ! skipCh(','))
return error("Missing comma", lineNo,loc);
if ( (! getNum ()) || (num < 0) || (num >= NO_REGS) )
return error("Bad third register", lineNo,loc);
arg3 = num;
break;
case opclRM :
case opclRA :
/***********************************/
if ( (! getNum ()) || (num < 0) || (num >= NO_REGS) )
return error("Bad first register", lineNo,loc);
arg1 = num;
if ( ! skipCh(','))
return error("Missing comma", lineNo,loc);
if (! getNum ())
return error("Bad displacement", lineNo,loc);
arg2 = num;
if ( ! skipCh('(') && ! skipCh(',') )
return error("Missing LParen", lineNo,loc);
if ( (! getNum ()) || (num < 0) || (num >= NO_REGS))
return error("Bad second register", lineNo,loc);
arg3 = num;
break;
}
iMem[loc].iop = op;
iMem[loc].iarg1 = arg1;
iMem[loc].iarg2 = arg2;
iMem[loc].iarg3 = arg3;
}
}
return TRUE;
} /* readInstructions */
/********************************************/
STEPRESULT stepTM (void)
{ INSTRUCTION currentinstruction ;
int pc ;
int r,s,t,m ;
int ok ;
pc = reg[PC_REG] ;
if ( (pc < 0) || (pc > IADDR_SIZE) )
return srIMEM_ERR ;
reg[PC_REG] = pc + 1 ;
currentinstruction = iMem[ pc ] ;
switch (opClass(currentinstruction.iop) )
{ case opclRR :
/***********************************/
r = currentinstruction.iarg1 ;
s = currentinstruction.iarg2 ;
t = currentinstruction.iarg3 ;
break;
case opclRM :
/***********************************/
r = currentinstruction.iarg1 ;
s = currentinstruction.iarg3 ;
m = currentinstruction.iarg2 + reg[s] ;
if ( (m < 0) || (m > DADDR_SIZE))
return srDMEM_ERR ;
break;
case opclRA :
/***********************************/
r = currentinstruction.iarg1 ;
s = currentinstruction.iarg3 ;
m = currentinstruction.iarg2 + reg[s] ;
break;
} /* case */
switch ( currentinstruction.iop)
{ /* RR instructions */
case opHALT :
/***********************************/
printf("HALT: %1d,%1d,%1d\n",r,s,t);
return srHALT ;
/* break; */
case opIN :
/***********************************/
do
{ printf("Enter value for IN instruction: ") ;
fflush (stdin);
fflush (stdout);
gets(in_Line);
lineLen = strlen(in_Line) ;
inCol = 0;
ok = getNum();
if ( ! ok ) printf ("Illegal value\n");
else reg[r] = num;
}
while (! ok);
break;
case opOUT :
printf ("OUT instruction prints: %d\n", reg[r] ) ;
break;
case opADD : reg[r] = reg[s] + reg[t] ; break;
case opSUB : reg[r] = reg[s] - reg[t] ; break;
case opMUL : reg[r] = reg[s] * reg[t] ; break;
case opDIV :
/***********************************/
if ( reg[t] != 0 ) reg[r] = reg[s] / reg[t];
else return srZERODIVIDE ;
break;
/*************** RM instructions ********************/
case opLD : reg[r] = dMem[m] ; break;
case opST : dMem[m] = reg[r] ; break;
/*************** RA instructions ********************/
case opLDA : reg[r] = m ; break;
case opLDC : reg[r] = currentinstruction.iarg2 ; break;
case opJLT : if ( reg[r] < 0 ) reg[PC_REG] = m ; break;
case opJLE : if ( reg[r] <= 0 ) reg[PC_REG] = m ; break;
case opJGT : if ( reg[r] > 0 ) reg[PC_REG] = m ; break;
case opJGE : if ( reg[r] >= 0 ) reg[PC_REG] = m ; break;
case opJEQ : if ( reg[r] == 0 ) reg[PC_REG] = m ; break;
case opJNE : if ( reg[r] != 0 ) reg[PC_REG] = m ; break;
/* end of legal instructions */
} /* case */
return srOKAY ;
} /* stepTM */
/********************************************/
int doCommand (void)
{ char cmd;
int stepcnt=0, i;
int printcnt;
int stepResult;
int regNo, loc;
do
{ printf ("Enter command: ");
fflush (stdin);
fflush (stdout);
gets(in_Line);
lineLen = strlen(in_Line);
inCol = 0;
}
while (! getWord ());
cmd = word[0] ;
switch ( cmd )
{ case 't' :
/***********************************/
traceflag = ! traceflag ;
printf("Tracing now ");
if ( traceflag ) printf("on.\n"); else printf("off.\n");
break;
case 'h' :
/***********************************/
printf("Commands are:\n");
printf(" s(tep <n> "\
"Execute n (default 1) TM instructions\n");
printf(" g(o "\
"Execute TM instructions until HALT\n");
printf(" r(egs "\
"Print the contents of the registers\n");
printf(" i(Mem <b <n>> "\
"Print n iMem locations starting at b\n");
printf(" d(Mem <b <n>> "\
"Print n dMem locations starting at b\n");
printf(" t(race "\
"Toggle instruction trace\n");
printf(" p(rint "\
"Toggle print of total instructions executed"\
" ('go' only)\n");
printf(" c(lear "\
"Reset simulator for new execution of program\n");
printf(" h(elp "\
"Cause this list of commands to be printed\n");
printf(" q(uit "\
"Terminate the simulation\n");
break;
case 'p' :
/***********************************/
icountflag = ! icountflag ;
printf("Printing instruction count now ");
if ( icountflag ) printf("on.\n"); else printf("off.\n");
break;
case 's' :
/***********************************/
if ( atEOL ()) stepcnt = 1;
else if ( getNum ()) stepcnt = abs(num);
else printf("Step count?\n");
break;
case 'g' : stepcnt = 1 ; break;
case 'r' :
/***********************************/
for (i = 0; i < NO_REGS; i++)
{ printf("%1d: %4d ", i,reg[i]);
if ( (i % 4) == 3 ) printf ("\n");
}
break;
case 'i' :
/***********************************/
printcnt = 1 ;
if ( getNum ())
{ iloc = num ;
if ( getNum ()) printcnt = num ;
}
if ( ! atEOL ())
printf ("Instruction locations?\n");
else
{ while ((iloc >= 0) && (iloc < IADDR_SIZE)
&& (printcnt > 0) )
{ writeInstruction(iloc);
iloc++ ;
printcnt-- ;
}
}
break;
case 'd' :
/***********************************/
printcnt = 1 ;
if ( getNum ())
{ dloc = num ;
if ( getNum ()) printcnt = num ;
}
if ( ! atEOL ())
printf("Data locations?\n");
else
{ while ((dloc >= 0) && (dloc < DADDR_SIZE)
&& (printcnt > 0))
{ printf("%5d: %5d\n",dloc,dMem[dloc]);
dloc++;
printcnt--;
}
}
break;
case 'c' :
/***********************************/
iloc = 0;
dloc = 0;
stepcnt = 0;
for (regNo = 0; regNo < NO_REGS ; regNo++)
reg[regNo] = 0 ;
dMem[0] = DADDR_SIZE - 1 ;
for (loc = 1 ; loc < DADDR_SIZE ; loc++)
dMem[loc] = 0 ;
break;
case 'q' : return FALSE; /* break; */
default : printf("Command %c unknown.\n", cmd); break;
} /* case */
stepResult = srOKAY;
if ( stepcnt > 0 )
{ if ( cmd == 'g' )
{ stepcnt = 0;
while (stepResult == srOKAY)
{ iloc = reg[PC_REG] ;
if ( traceflag ) writeInstruction( iloc ) ;
stepResult = stepTM ();
stepcnt++;
}
if ( icountflag )
printf("Number of instructions executed = %d\n",stepcnt);
}
else
{ while ((stepcnt > 0) && (stepResult == srOKAY))
{ iloc = reg[PC_REG] ;
if ( traceflag ) writeInstruction( iloc ) ;
stepResult = stepTM ();
stepcnt-- ;
}
}
printf( "%s\n",stepResultTab[stepResult] );
}
return TRUE;
} /* doCommand */
/********************************************/
/* E X E C U T I O N B E G I N S H E R E */
/********************************************/
main( int argc, char * argv[] )
{ if (argc != 2)
{ printf("usage: %s <filename>\n",argv[0]);
exit(1);
}
strcpy(pgmName,argv[1]) ;
if (strchr (pgmName, '.') == NULL)
strcat(pgmName,".tm");
pgm = fopen(pgmName,"r");
if (pgm == NULL)
{ printf("file '%s' not found\n",pgmName);
exit(1);
}
/* read the program */
if ( ! readInstructions ())
exit(1) ;
/* switch input file to terminal */
/* reset( input ); */
/* read-eval-print */
printf("TM simulation (enter h for help)...\n");
do
done = ! doCommand ();
while (! done );
printf("Simulation done.\n");
return 0;
}
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑！
请 注册 或者 后发表评论