void Decompiler::writeBlock(Common::WriteStream &out, const Block *block, size_t indent) {
for (const auto instruction : block->instructions) {
writeInstruction(out, instruction, indent);
}
for (const auto &childType : block->childrenTypes) {
if (isSubRoutineCall(childType)) {
writeIndent(out, indent);
const Instruction *instruction = block->instructions.back();
out.writeString(formatJumpLabelName(*instruction->branches[0]));
out.writeString("(");
for (size_t i = 0; i < instruction->variables.size(); ++i) {
out.writeString(formatVariableName(instruction->variables[i]));
if (i < instruction->variables.size() - 1)
out.writeString(", ");
}
out.writeString(");\n");
writeBlock(out, block->children[1], indent);
}
}
for (const auto &control : block->controls) {
if (control.type == kControlTypeReturn) {
writeIndent(out, indent);
out.writeString("return;\n");
} else if (control.type == kControlTypeIfCond) {
writeIfControl(out, control, indent);
}
// TODO: while
// TODO: break
// TODO: continue
}
}
void main()
{
initialize();
writeInstruction(0xC0); //41
writeData(0x4A); //J
writeInstruction(0x81); //01
writeData(0x61); //a
writeInstruction(0x84); //04
writeData(0x6D); //m
writeInstruction(0xC3); //43
writeData(0x65); //e
writeInstruction(0x1C);
writeInstruction(0x1C);
writeInstruction(0x1C);
}
int doCommand (void)
{ char cmd;
int stepcnt=0, i;
int printcnt;
int stepResult;
int regNo, loc;
do
{ printf ("Enter command: ");
fflush (stdin);
fflush (stdout);
fgets(in_Line,200,stdin);
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 */
void next_line()
{
writeInstruction(0xC0);
}
void display_on()
{
writeInstruction(0x0F); //Blinking Cursor
}
void function_set()
{
writeInstruction(0x38);
}
void set_entry()
{
writeInstruction(0x06);
}
void clear_display()
{
writeInstruction(0x01);
}
