mirror of
https://github.com/makarcz/vm6502.git
synced 2024-12-28 05:29:47 +00:00
67f1a62596
Version 2.0, full emulation of 6502 op-codes, fully tested and functional. Extended description in ReadMe file. Bin2Hex tool to convert binary images to memory definition format. Microchess, EhBasic added.
944 lines
23 KiB
C++
944 lines
23 KiB
C++
|
|
#include <stdio.h>
|
|
#include <iostream>
|
|
#include <string.h>
|
|
#include "system.h"
|
|
#include "VMachine.h"
|
|
#include "MKGenException.h"
|
|
|
|
#if defined(WINDOWS)
|
|
#include <conio.h>
|
|
#endif
|
|
|
|
using namespace std;
|
|
|
|
namespace MKBasic {
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method:
|
|
* Purpose:
|
|
* Arguments:
|
|
* Returns:
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: VMachine()
|
|
* Purpose: Default class constructor.
|
|
* Arguments: n/a
|
|
* Returns: n/a
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
VMachine::VMachine()
|
|
{
|
|
InitVM();
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: VMachine()
|
|
* Purpose: Custom class constructor.
|
|
* Arguments: romfname - name of the ROM definition file
|
|
* ramfname - name of the RAM definition file
|
|
* Returns: n/a
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
VMachine::VMachine(string romfname, string ramfname)
|
|
{
|
|
InitVM();
|
|
LoadROM(romfname);
|
|
LoadRAM(ramfname);
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: ~VMachine()
|
|
* Purpose: Class destructor.
|
|
* Arguments: n/a
|
|
* Returns: n/a
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
VMachine::~VMachine()
|
|
{
|
|
delete mpDisp;
|
|
delete mpCPU;
|
|
delete mpROM;
|
|
delete mpRAM;
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: InitVM()
|
|
* Purpose: Initialize class.
|
|
* Arguments: n/a
|
|
* Returns: n/a
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
void VMachine::InitVM()
|
|
{
|
|
mOpInterrupt = false;
|
|
mpRAM = new Memory();
|
|
|
|
mAutoExec = false;
|
|
mCharIOAddr = CHARIO_ADDR;
|
|
mCharIOActive = mCharIO = false;
|
|
if (NULL == mpRAM) {
|
|
throw MKGenException("Unable to initialize VM (RAM).");
|
|
}
|
|
mRunAddr = mpRAM->Peek16bit(0xFFFC); // address under RESET vector
|
|
mpROM = new Memory();
|
|
if (NULL == mpROM) {
|
|
throw MKGenException("Unable to initialize VM (ROM).");
|
|
}
|
|
mpCPU = new MKCpu(mpRAM);
|
|
if (NULL == mpCPU) {
|
|
throw MKGenException("Unable to initialize VM (CPU).");
|
|
}
|
|
mpDisp = new Display();
|
|
if (NULL == mpDisp) {
|
|
throw MKGenException("Unable to initialize VM (Display).");
|
|
}
|
|
}
|
|
|
|
#if defined(WINDOWS)
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method:
|
|
* Purpose:
|
|
* Arguments:
|
|
* Returns:
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
void VMachine::ClearScreen()
|
|
{
|
|
HANDLE hStdOut;
|
|
CONSOLE_SCREEN_BUFFER_INFO csbi;
|
|
DWORD count;
|
|
DWORD cellCount;
|
|
COORD homeCoords = { 0, 0 };
|
|
|
|
hStdOut = GetStdHandle( STD_OUTPUT_HANDLE );
|
|
if (hStdOut == INVALID_HANDLE_VALUE) return;
|
|
|
|
/* Get the number of cells in the current buffer */
|
|
if (!GetConsoleScreenBufferInfo( hStdOut, &csbi )) return;
|
|
cellCount = csbi.dwSize.X *csbi.dwSize.Y;
|
|
|
|
/* Fill the entire buffer with spaces */
|
|
if (!FillConsoleOutputCharacter(
|
|
hStdOut,
|
|
(TCHAR) ' ',
|
|
cellCount,
|
|
homeCoords,
|
|
&count
|
|
)) return;
|
|
|
|
/* Fill the entire buffer with the current colors and attributes */
|
|
if (!FillConsoleOutputAttribute(
|
|
hStdOut,
|
|
csbi.wAttributes,
|
|
cellCount,
|
|
homeCoords,
|
|
&count
|
|
)) return;
|
|
|
|
/* Move the cursor home */
|
|
SetConsoleCursorPosition( hStdOut, homeCoords );
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method:
|
|
* Purpose:
|
|
* Arguments:
|
|
* Returns:
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
void VMachine::ScrHome()
|
|
{
|
|
HANDLE hStdOut;
|
|
COORD homeCoords = { 0, 0 };
|
|
|
|
hStdOut = GetStdHandle( STD_OUTPUT_HANDLE );
|
|
if (hStdOut == INVALID_HANDLE_VALUE) return;
|
|
|
|
/* Move the cursor home */
|
|
SetConsoleCursorPosition( hStdOut, homeCoords );
|
|
}
|
|
|
|
#endif
|
|
|
|
#if defined(LINUX)
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method:
|
|
* Purpose:
|
|
* Arguments:
|
|
* Returns:
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
void VMachine::ClearScreen()
|
|
{
|
|
system("clear");
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method:
|
|
* Purpose:
|
|
* Arguments:
|
|
* Returns:
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
void VMachine::ScrHome()
|
|
{
|
|
cout << "\033[1;1H";
|
|
}
|
|
|
|
#endif
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method:
|
|
* Purpose:
|
|
* Arguments:
|
|
* Returns:
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
void VMachine::ShowDisp()
|
|
{
|
|
if (mCharIOActive) {
|
|
ScrHome();
|
|
mpDisp->ShowScr();
|
|
}
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: Run()
|
|
* Purpose: Run VM until software break instruction.
|
|
* Arguments: n/a
|
|
* Returns: Pointer to CPU registers and flags.
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
Regs *VMachine::Run()
|
|
{
|
|
Regs *cpureg = NULL;
|
|
|
|
mOpInterrupt = false;
|
|
ClearScreen();
|
|
ShowDisp();
|
|
while (true) {
|
|
cpureg = Step();
|
|
if (mCharIO) {
|
|
ShowDisp();
|
|
}
|
|
if (cpureg->SoftIrq || mOpInterrupt)
|
|
break;
|
|
}
|
|
|
|
ShowDisp();
|
|
|
|
return cpureg;
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: Run()
|
|
* Purpose: Run VM from specified address until software break
|
|
* instruction.
|
|
* Arguments: addr - start execution address
|
|
* Returns: Pointer to CPU registers and flags.
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
Regs *VMachine::Run(unsigned short addr)
|
|
{
|
|
mRunAddr = addr;
|
|
return Run();
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: Exec()
|
|
* Purpose: Run VM from current address until last RTS.
|
|
* NOTE: Stack must be empty!
|
|
* Arguments: n/a
|
|
* Returns: Pointer to CPU registers and flags.
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
Regs *VMachine::Exec()
|
|
{
|
|
Regs *cpureg = NULL;
|
|
|
|
mOpInterrupt = false;
|
|
ClearScreen();
|
|
ShowDisp();
|
|
while (true) {
|
|
cpureg = Step();
|
|
if (mCharIO) {
|
|
ShowDisp();
|
|
}
|
|
if (cpureg->LastRTS || mOpInterrupt) break;
|
|
}
|
|
|
|
ShowDisp();
|
|
|
|
return cpureg;
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: Exec()
|
|
* Purpose: Run VM from specified address until RTS.
|
|
* Arguments: addr - start execution address
|
|
* Returns: Pointer to CPU registers and flags.
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
Regs *VMachine::Exec(unsigned short addr)
|
|
{
|
|
mRunAddr = addr;
|
|
return Exec();
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: Step()
|
|
* Purpose: Execute single opcode.
|
|
* Arguments: n/a
|
|
* Returns: Pointer to CPU registers and flags.
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
Regs *VMachine::Step()
|
|
{
|
|
unsigned short addr = mRunAddr;
|
|
Regs *cpureg = NULL;
|
|
|
|
cpureg = mpCPU->ExecOpcode(addr);
|
|
addr = cpureg->PtrAddr;
|
|
mRunAddr = addr;
|
|
|
|
if (mCharIOActive && !mOpInterrupt) {
|
|
char c = -1;
|
|
mCharIO = false;
|
|
while ((c = mpRAM->GetCharOut()) != -1) {
|
|
mOpInterrupt = (c == OPINTERRUPT);
|
|
if (!mOpInterrupt) {
|
|
mpDisp->PutChar(c);
|
|
mCharIO = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return cpureg;
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: Step()
|
|
* Purpose: Execute single opcode.
|
|
* Arguments: addr (unsigned short) - opcode address
|
|
* Returns: Pointer to CPU registers and flags.
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
Regs *VMachine::Step(unsigned short addr)
|
|
{
|
|
mRunAddr = addr;
|
|
return Step();
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: LoadROM()
|
|
* Purpose: Load data from memory definition file to the memory.
|
|
* Arguments: romfname - name of the ROM file definition
|
|
* Returns: n/a
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
void VMachine::LoadROM(string romfname)
|
|
{
|
|
LoadMEM(romfname, mpROM);
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: LoadRAM()
|
|
* Purpose: Load data from memory definition file to the memory.
|
|
* Arguments: ramfname - name of the RAM file definition
|
|
* Returns: n/a
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
void VMachine::LoadRAM(string ramfname)
|
|
{
|
|
LoadMEM(ramfname, mpRAM);
|
|
//mpRAM->EnableROM();
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: LoadRAMBin()
|
|
* Purpose: Load data from binary image file to the memory.
|
|
* Arguments: ramfname - name of the RAM file definition
|
|
* Returns: n/a
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
void VMachine::LoadRAMBin(string ramfname)
|
|
{
|
|
FILE *fp = NULL;
|
|
unsigned short addr = 0x0000;
|
|
int n = 0;
|
|
Memory *pm = mpRAM;
|
|
|
|
if ((fp = fopen(ramfname.c_str(), "rb")) != NULL) {
|
|
while (0 == feof(fp) && 0 == ferror(fp)) {
|
|
unsigned char val = fgetc(fp);
|
|
pm->Poke8bit(addr, val);
|
|
addr++; n++;
|
|
}
|
|
fclose(fp);
|
|
if (n <= 0xFFFF) {
|
|
cout << "WARNING: Unexpected EOF." << endl;
|
|
}
|
|
}
|
|
else {
|
|
cout << "WARNING: Unable to open memory image file: " << ramfname << endl;
|
|
cout << "Press [ENTER]...";
|
|
getchar();
|
|
}
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: LoadMEM()
|
|
* Purpose: Load data from memory definition file to the memory.
|
|
* Arguments: memfname - name of memory definition file
|
|
* pmem - pointer to memory object
|
|
* Returns: n/a
|
|
* Details:
|
|
* Format of the memory definition file:
|
|
* [; comment]
|
|
* [ADDR
|
|
* address]
|
|
* [data]
|
|
* [ORG
|
|
* address]
|
|
* [data]
|
|
* [IOADDR
|
|
* address]
|
|
* [ROMBEGIN
|
|
* address]
|
|
* [ROMEND
|
|
* address]
|
|
* [ENIO]
|
|
* [ENROM]
|
|
* [EXEC
|
|
* addrress]
|
|
*
|
|
* Where:
|
|
* [] - optional token
|
|
* ADDR - label indicating that starting address will follow in next
|
|
* line, it also defines run address
|
|
* ORG - label indicating that the address counter will change to the
|
|
* value provided in next line
|
|
* IOADDR - label indicating that char IO trap address will be defined
|
|
* in the next line
|
|
* ROMBEGIN - label indicating that ROM begin address will be defined
|
|
* in the next line
|
|
* ROMEND - label indicating that ROM end address will be defined
|
|
* in the next line
|
|
* ENIO - label enabling char IO emulation
|
|
* ENROM - label enabling ROM emulation
|
|
* EXEC - label enabling auto-execute of code, address follows in the
|
|
* next line
|
|
* address - decimal or hexadecimal (prefix $) address in memory
|
|
* E.g:
|
|
* ADDR
|
|
* $200
|
|
*
|
|
* or
|
|
*
|
|
* ADDR
|
|
* 512
|
|
*
|
|
* changes the default start address (256) to 512.
|
|
*
|
|
* ORG
|
|
* 49152
|
|
*
|
|
* moves address counter to address 49152, following data will be
|
|
* loaded from that address forward
|
|
*
|
|
* data - the multi-line stream of decimal of hexadecimal ($xx) values
|
|
* of size unsigned char (byte: 0-255) separated with spaces
|
|
* or commas.
|
|
* E.g.:
|
|
* $00 $00 $00 $00
|
|
* $00 $00 $00 $00
|
|
*
|
|
* or
|
|
*
|
|
* $00,$00,$00,$00
|
|
*
|
|
* or
|
|
*
|
|
* 0 0 0 0
|
|
*
|
|
* or
|
|
*
|
|
* 0,0,0,0
|
|
* 0 0 0 0
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
void VMachine::LoadMEM(string memfname, Memory *pmem)
|
|
{
|
|
FILE *fp = NULL;
|
|
char line[256] = "\0";
|
|
int lc = 0, errc = 0;
|
|
unsigned short addr = 0, rombegin = 0, romend = 0;
|
|
unsigned int nAddr;
|
|
bool enrom = false, enio = false, runset = false;
|
|
bool ioset = false, execset = false, rombegset = false;
|
|
bool romendset = false;
|
|
Memory *pm = pmem;
|
|
|
|
if ((fp = fopen(memfname.c_str(), "r")) != NULL) {
|
|
while (0 == feof(fp) && 0 == ferror(fp))
|
|
{
|
|
line[0] = '\0';
|
|
fgets(line, 256, fp);
|
|
lc++;
|
|
// change run address (can be done only once)
|
|
if (0 == strncmp(line, "ADDR", 4)) {
|
|
line[0] = '\0';
|
|
fgets(line, 256, fp);
|
|
lc++;
|
|
if (!runset) {
|
|
if (*line == '$') {
|
|
sscanf(line+1, "%04x", &nAddr);
|
|
addr = nAddr;
|
|
} else {
|
|
addr = (unsigned short) atoi(line);
|
|
}
|
|
mRunAddr = addr;
|
|
runset = true;
|
|
} else {
|
|
errc++;
|
|
cout << "LINE #" << dec << lc << " WARNING: Run address was already set. Ignoring..." << endl;
|
|
}
|
|
continue;
|
|
}
|
|
// change address counter
|
|
if (0 == strncmp(line, "ORG", 3)) {
|
|
line[0] = '\0';
|
|
fgets(line, 256, fp);
|
|
lc++;
|
|
if (*line == '$') {
|
|
sscanf(line+1, "%04x", &nAddr);
|
|
addr = nAddr;
|
|
} else {
|
|
addr = (unsigned short) atoi(line);
|
|
}
|
|
continue;
|
|
}
|
|
// define I/O emulation address (once)
|
|
if (0 == strncmp(line, "IOADDR", 6)) {
|
|
line[0] = '\0';
|
|
fgets(line, 256, fp);
|
|
lc++;
|
|
if (!ioset) {
|
|
if (*line == '$') {
|
|
sscanf(line+1, "%04x", &nAddr);
|
|
mCharIOAddr = nAddr;
|
|
} else {
|
|
mCharIOAddr = (unsigned short) atoi(line);
|
|
}
|
|
ioset = true;
|
|
} else {
|
|
errc++;
|
|
cout << "LINE #" << dec << lc << " WARNING: I/O address was already set. Ignoring..." << endl;
|
|
}
|
|
continue;
|
|
}
|
|
// enable character I/O emulation
|
|
if (0 == strncmp(line, "ENIO", 4)) {
|
|
enio = true;
|
|
continue;
|
|
}
|
|
// enable ROM emulation
|
|
if (0 == strncmp(line, "ENROM", 5)) {
|
|
enrom = true;
|
|
continue;
|
|
}
|
|
// auto execute from address
|
|
if (0 == strncmp(line, "EXEC", 4)) {
|
|
mAutoExec = true;
|
|
line[0] = '\0';
|
|
fgets(line, 256, fp);
|
|
lc++;
|
|
if (!execset) {
|
|
if (*line == '$') {
|
|
sscanf(line+1, "%04x", &nAddr);
|
|
mRunAddr = nAddr;
|
|
} else {
|
|
mRunAddr = (unsigned short) atoi(line);
|
|
}
|
|
execset = true;
|
|
} else {
|
|
errc++;
|
|
cout << "LINE #" << dec << lc << " WARNING: auto-exec address was already set. Ignoring..." << endl;
|
|
}
|
|
continue;
|
|
}
|
|
// define ROM begin address
|
|
if (0 == strncmp(line, "ROMBEGIN", 8)) {
|
|
line[0] = '\0';
|
|
fgets(line, 256, fp);
|
|
lc++;
|
|
if (!rombegset) {
|
|
if (*line == '$') {
|
|
sscanf(line+1, "%04x", &nAddr);
|
|
rombegin = nAddr;
|
|
} else {
|
|
rombegin = (unsigned short) atoi(line);
|
|
}
|
|
rombegset = true;
|
|
} else {
|
|
errc++;
|
|
cout << "LINE #" << dec << lc << " WARNING: ROM-begin address was already set. Ignoring..." << endl;
|
|
}
|
|
continue;
|
|
}
|
|
// define ROM end address
|
|
if (0 == strncmp(line, "ROMEND", 6)) {
|
|
line[0] = '\0';
|
|
fgets(line, 256, fp);
|
|
lc++;
|
|
if (!romendset) {
|
|
if (*line == '$') {
|
|
sscanf(line+1, "%04x", &nAddr);
|
|
romend = nAddr;
|
|
} else {
|
|
romend = (unsigned short) atoi(line);
|
|
}
|
|
romendset = true;
|
|
} else {
|
|
errc++;
|
|
cout << "LINE #" << dec << lc << " WARNING: ROM-end address was already set. Ignoring..." << endl;
|
|
}
|
|
continue;
|
|
}
|
|
if (';' == *line) continue; // skip comment lines
|
|
char *s = strtok (line, " ,");
|
|
while (NULL != s) {
|
|
unsigned int nVal;
|
|
if (*s == '$') {
|
|
sscanf(s+1, "%02x", &nVal);
|
|
pm->Poke8bit(addr++, (unsigned short)nVal);
|
|
} else {
|
|
pm->Poke8bit(addr++, (unsigned short)atoi(s));
|
|
}
|
|
s = strtok(NULL, " ,");
|
|
}
|
|
}
|
|
fclose(fp);
|
|
if (rombegin > MIN_ROM_BEGIN && romend > rombegin) {
|
|
if (enrom)
|
|
pm->EnableROM(rombegin, romend);
|
|
else
|
|
pm->SetROM(rombegin, romend);
|
|
} else {
|
|
if (enrom) pm->EnableROM();
|
|
}
|
|
if (enio) {
|
|
SetCharIO(mCharIOAddr, false);
|
|
}
|
|
}
|
|
else {
|
|
cout << "WARNING: Unable to open memory definition file: " << memfname << endl;
|
|
errc++;
|
|
}
|
|
if (errc) {
|
|
cout << "Found " << dec << errc << ((errc > 1) ? " problems." : " problem.") << endl;
|
|
cout << "Press [ENTER] to continue...";
|
|
getchar();
|
|
}
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: MemPeek8bit()
|
|
* Purpose: Read value from specified RAM address.
|
|
* Arguments: addr - RAM address (0..0xFFFF)
|
|
* Returns: unsigned short - value read from specified RAM address
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
unsigned short VMachine::MemPeek8bit(unsigned short addr)
|
|
{
|
|
unsigned short ret = 0;
|
|
|
|
ret = (unsigned short)mpRAM->Peek8bit(addr);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: MemPoke8bit()
|
|
* Purpose: Write value to specified RAM address.
|
|
* Arguments: addr - RAM address (0..0xFFFF)
|
|
* v - 8-bit byte value
|
|
* Returns: n/a
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
void VMachine::MemPoke8bit(unsigned short addr, unsigned char v)
|
|
{
|
|
mpRAM->Poke8bit(addr, v);
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: GetRegs()
|
|
* Purpose: Return pointer to CPU status register.
|
|
* Arguments: n/a
|
|
* Returns: pointer to status register
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
Regs *VMachine::GetRegs()
|
|
{
|
|
return mpCPU->GetRegs();
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: SetCharIO()
|
|
* Purpose: Activates and sets an address of basic character I/O
|
|
* emulation (console).
|
|
* Arguments: addr - address of I/O area (0x0000..0xFFFF)
|
|
* Returns: n/a
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
void VMachine::SetCharIO(unsigned short addr, bool echo)
|
|
{
|
|
mCharIOAddr = addr;
|
|
mCharIOActive = true;
|
|
mpRAM->SetCharIO(addr, echo);
|
|
mpDisp->ClrScr();
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: DisableCharIO()
|
|
* Purpose: Deactivates basic character I/O emulation (console).
|
|
* Arguments: n/a
|
|
* Returns: n/a
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
void VMachine::DisableCharIO()
|
|
{
|
|
mCharIOActive = false;
|
|
mpRAM->DisableCharIO();
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: GetCharIOAddr()
|
|
* Purpose: Returns current address of basic character I/O area.
|
|
* Arguments: n/a
|
|
* Returns: address of I/O area
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
unsigned short VMachine::GetCharIOAddr()
|
|
{
|
|
return mCharIOAddr;
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: GetCharIOActive()
|
|
* Purpose: Returns status of character I/O emulation.
|
|
* Arguments: n/a
|
|
* Returns: true if I/O emulation active
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
bool VMachine::GetCharIOActive()
|
|
{
|
|
return mCharIOActive;
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: ShowIO()
|
|
* Purpose: Show contents of emulated char I/O.
|
|
* Arguments: n/a
|
|
* Returns: n/a
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
void VMachine::ShowIO()
|
|
{
|
|
if (mCharIOActive)
|
|
mpDisp->ShowScr();
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: IsAutoExec()
|
|
* Purpose: Return status of auto-execute flag.
|
|
* Arguments: n/a
|
|
* Returns: bool - true if auto-exec flag is enabled.
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
bool VMachine::IsAutoExec()
|
|
{
|
|
return mAutoExec;
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method:
|
|
* Purpose:
|
|
* Arguments:
|
|
* Returns:
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
void VMachine::EnableROM()
|
|
{
|
|
mpRAM->EnableROM();
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method:
|
|
* Purpose:
|
|
* Arguments:
|
|
* Returns:
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
void VMachine::DisableROM()
|
|
{
|
|
mpRAM->DisableROM();
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method:
|
|
* Purpose:
|
|
* Arguments:
|
|
* Returns:
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
void VMachine::SetROM(unsigned short start, unsigned short end)
|
|
{
|
|
mpRAM->SetROM(start, end);
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method:
|
|
* Purpose:
|
|
* Arguments:
|
|
* Returns:
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
void VMachine::EnableROM(unsigned short start, unsigned short end)
|
|
{
|
|
mpRAM->EnableROM(start, end);
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method:
|
|
* Purpose:
|
|
* Arguments:
|
|
* Returns:
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
unsigned short VMachine::GetROMBegin()
|
|
{
|
|
return mpRAM->GetROMBegin();
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method:
|
|
* Purpose:
|
|
* Arguments:
|
|
* Returns:
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
unsigned short VMachine::GetROMEnd()
|
|
{
|
|
return mpRAM->GetROMEnd();
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method:
|
|
* Purpose:
|
|
* Arguments:
|
|
* Returns:
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
bool VMachine::IsROMEnabled()
|
|
{
|
|
return mpRAM->IsROMEnabled();
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method:
|
|
* Purpose:
|
|
* Arguments:
|
|
* Returns:
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
unsigned short VMachine::GetRunAddr()
|
|
{
|
|
return mRunAddr;
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: SetOpInterrupt()
|
|
* Purpose: Set the flag indicating operator interrupt.
|
|
* Arguments: n/a
|
|
* Returns: n/a
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
void VMachine::SetOpInterrupt()
|
|
{
|
|
mOpInterrupt = true;
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: GetExecHistory()
|
|
* Purpose: Return history of executed opcodes (last 20).
|
|
* Arguments: n/a
|
|
* Returns: queue<string>
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
queue<string> VMachine::GetExecHistory()
|
|
{
|
|
return mpCPU->GetExecHistory();
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: Disassemble()
|
|
* Purpose: Disassemble code in memory. Return next instruction
|
|
* address.
|
|
* Arguments: addr - address in memory
|
|
* buf - character buffer for disassembled instruction
|
|
* Returns: unsigned short - address of next instruction
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
unsigned short VMachine::Disassemble(unsigned short addr, char *buf)
|
|
{
|
|
return mpCPU->Disassemble(addr, buf);
|
|
}
|
|
|
|
} // namespace MKBasic
|