mirror of https://github.com/makarcz/vm6502.git
703 lines
20 KiB
C++
703 lines
20 KiB
C++
/*
|
|
*--------------------------------------------------------------------
|
|
* Project: VM65 - Virtual Machine/CPU emulator programming
|
|
* framework.
|
|
*
|
|
* File: Memory.cpp.
|
|
*
|
|
* Purpose: Implementation of class Memory.
|
|
* The Memory class implements the highest abstraction
|
|
* layer of Visrtual Machine's memory. in this particular
|
|
* case the Virtual Machine emulates a computer system
|
|
* based on a 8-bit microprocessor. Therefore it
|
|
* implements image size and addressing space adequate
|
|
* for the specific architecture of such microprocessor.
|
|
* The Memory class also interfaces with the MemMapDev
|
|
* API (Memory Mapped Devices).
|
|
*
|
|
* Date:
|
|
*
|
|
* Copyright: (C) by Marek Karcz 2016. All rights reserved.
|
|
*
|
|
* Contact: makarcz@yahoo.com
|
|
*
|
|
* License Agreement and Warranty:
|
|
|
|
This software is provided with No Warranty.
|
|
I (Marek Karcz) will not be held responsible for any damage to
|
|
computer systems, data or user's health resulting from use.
|
|
Please proceed responsibly and apply common sense.
|
|
This software is provided in hope that it will be useful.
|
|
It is free of charge for non-commercial and educational use.
|
|
Distribution of this software in non-commercial and educational
|
|
derivative work is permitted under condition that original
|
|
copyright notices and comments are preserved. Some 3-rd party work
|
|
included with this project may require separate application for
|
|
permission from their respective authors/copyright owners.
|
|
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
#include "Memory.h"
|
|
#include "MKGenException.h"
|
|
|
|
//#define DBG 1
|
|
#if defined (DBG)
|
|
#include <iostream>
|
|
using namespace std;
|
|
#endif
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method:
|
|
* Purpose:
|
|
* Arguments:
|
|
* Returns:
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
|
|
namespace MKBasic {
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method:
|
|
* Purpose:
|
|
* Arguments:
|
|
* Returns:
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
Memory::Memory()
|
|
{
|
|
Initialize();
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method:
|
|
* Purpose:
|
|
* Arguments:
|
|
* Returns:
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
Memory::~Memory()
|
|
{
|
|
if (NULL != mpMemMapDev) delete mpMemMapDev;
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method:
|
|
* Purpose:
|
|
* Arguments:
|
|
* Returns:
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
void Memory::Initialize()
|
|
{
|
|
unsigned short addr = 0;
|
|
for (int i=0; i < 0xFFFF; i++) {
|
|
m8bitMem[addr++] = 0;
|
|
}
|
|
for (int i=0; i < MEM_PAGE_SIZE; i++) {
|
|
mMemPageDev[i] = -1;
|
|
}
|
|
mCharIOAddr = CHARIO_ADDR;
|
|
mCharIOActive = false;
|
|
mIOEcho = false;
|
|
mROMBegin = ROM_BEGIN;
|
|
mROMEnd = ROM_END;
|
|
mROMActive = false;
|
|
mpMemMapDev = new MemMapDev(this);
|
|
mGraphDispActive = false;
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method:
|
|
* Purpose:
|
|
* Arguments:
|
|
* Returns:
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
void Memory::EnableROM()
|
|
{
|
|
mROMActive = true;
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method:
|
|
* Purpose:
|
|
* Arguments:
|
|
* Returns:
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
void Memory::DisableROM()
|
|
{
|
|
mROMActive = false;
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method:
|
|
* Purpose:
|
|
* Arguments:
|
|
* Returns:
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
void Memory::SetROM(unsigned short start, unsigned short end)
|
|
{
|
|
if (mROMEnd > mROMBegin) {
|
|
mROMBegin = start;
|
|
mROMEnd = end;
|
|
}
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method:
|
|
* Purpose:
|
|
* Arguments:
|
|
* Returns:
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
void Memory::EnableROM(unsigned short start, unsigned short end)
|
|
{
|
|
SetROM(start,end);
|
|
EnableROM();
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: Peek8bit()
|
|
* Purpose: Get/read 8-bit value from memory. If the memory address
|
|
* is within the range of any active devices, call
|
|
* handling method for this device.
|
|
* Arguments: addr - memory address
|
|
* Returns: unsigned char value read from specified memory address
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
unsigned char Memory::Peek8bit(unsigned short addr)
|
|
{
|
|
// if memory address is in range of any active memory mapped
|
|
// devices, call corresponding device handling function
|
|
int mempg = addr / MEM_PAGE_SIZE;
|
|
if (mMemPageDev[mempg] >= 0) {
|
|
bool cont_loop = true;
|
|
for (vector<Device>::iterator devit = mActiveDeviceVec.begin();
|
|
devit != mActiveDeviceVec.end() && cont_loop;
|
|
++devit
|
|
) {
|
|
|
|
if (devit->num >= 0) {
|
|
for (MemAddrRanges::iterator memrangeit = devit->addr_ranges.begin();
|
|
memrangeit != devit->addr_ranges.end();
|
|
++memrangeit
|
|
) {
|
|
if (addr >= memrangeit->start_addr && addr <= memrangeit->end_addr) {
|
|
ReadFunPtr pfun = devit->read_fun_ptr;
|
|
if (pfun != NULL) {
|
|
cont_loop = false;
|
|
(mpMemMapDev->*pfun)((int)addr);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
mDispOp = (DEVNUM_GRDISP == devit->num);
|
|
}
|
|
}
|
|
}
|
|
|
|
return m8bitMem[addr];
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: Peek8bitImg()
|
|
* Purpose: Get/read 8-bit value from memory image only.
|
|
* Memory mapped devices are not affected.
|
|
* Arguments: addr - memory address
|
|
* Returns: unsigned char value read from specified memory address
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
unsigned char Memory::Peek8bitImg(unsigned short addr)
|
|
{
|
|
return m8bitMem[addr];
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: Peek16bit()
|
|
* Purpose: Get/read 16-bit value from memory. If the memory address
|
|
* is within the range of any active devices, call
|
|
* handling method for this device.
|
|
* Arguments: addr - memory address
|
|
* Returns: unsigned short value read secified from memory address
|
|
* and next memory address (16-bit, little endian)
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
unsigned short Memory::Peek16bit(unsigned short addr)
|
|
{
|
|
unsigned short ret = 0;
|
|
|
|
// if memory address is in range of any active memory mapped
|
|
// devices, call corresponding device handling function
|
|
int mempg = addr / MEM_PAGE_SIZE;
|
|
if (mMemPageDev[mempg] >= 0) {
|
|
bool cont_loop = true;
|
|
for (vector<Device>::iterator devit = mActiveDeviceVec.begin();
|
|
devit != mActiveDeviceVec.end() && cont_loop;
|
|
++devit
|
|
) {
|
|
if (devit->num >= 0) {
|
|
for (MemAddrRanges::iterator memrangeit = devit->addr_ranges.begin();
|
|
memrangeit != devit->addr_ranges.end();
|
|
++memrangeit
|
|
) {
|
|
if (addr >= memrangeit->start_addr && addr <= memrangeit->end_addr) {
|
|
ReadFunPtr pfun = devit->read_fun_ptr;
|
|
if (pfun != NULL) {
|
|
cont_loop = false;
|
|
(mpMemMapDev->*pfun)((int)addr);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
mDispOp = (DEVNUM_GRDISP == devit->num);
|
|
}
|
|
}
|
|
}
|
|
|
|
ret = m8bitMem[addr++];
|
|
ret += m8bitMem[addr] * 256;
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: Poke8bit()
|
|
* Purpose: Write byte to specified memory location.
|
|
* If the memory location is mapped to an active device,
|
|
* call corresponding handling function.
|
|
* If the memory location is protected (ROM), do not
|
|
* write the value.
|
|
* Arguments: addr - (0x0000..0xffff) memory address,
|
|
* val - value (0x00..0xff)
|
|
* Returns: n/a
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
void Memory::Poke8bit(unsigned short addr, unsigned char val)
|
|
{
|
|
// if memory address is in range of any active memory mapped
|
|
// devices, call corresponding device handling function
|
|
int mempg = addr / MEM_PAGE_SIZE;
|
|
if (mMemPageDev[mempg] >= 0) {
|
|
bool cont_loop = true;
|
|
for (vector<Device>::iterator devit = mActiveDeviceVec.begin();
|
|
devit != mActiveDeviceVec.end() && cont_loop;
|
|
++devit
|
|
) {
|
|
if (devit->num >= 0) {
|
|
for (MemAddrRanges::iterator memrangeit = devit->addr_ranges.begin();
|
|
memrangeit != devit->addr_ranges.end();
|
|
++memrangeit
|
|
) {
|
|
if (addr >= memrangeit->start_addr && addr <= memrangeit->end_addr) {
|
|
WriteFunPtr pfun = devit->write_fun_ptr;
|
|
if (pfun != NULL) {
|
|
cont_loop = false;
|
|
(mpMemMapDev->*pfun)((int)addr,(int)val);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
mDispOp = (DEVNUM_GRDISP == devit->num);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!mROMActive || (addr < mROMBegin || addr > mROMEnd)) {
|
|
m8bitMem[addr] = val;
|
|
}
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: Poke8bitImg()
|
|
* Purpose: Write byte to specified memory location.
|
|
* Arguments: addr - (0x0000..0xffff) memory address,
|
|
* val - value (0x00..0xff)
|
|
* Returns: n/a
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
void Memory::Poke8bitImg(unsigned short addr, unsigned char val)
|
|
{
|
|
m8bitMem[addr] = val;
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* 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 Memory::SetCharIO(unsigned short addr, bool echo)
|
|
{
|
|
mCharIOAddr = addr;
|
|
mIOEcho = echo;
|
|
|
|
AddrRange addr_range(addr, addr+1);
|
|
MemAddrRanges memaddr_ranges;
|
|
DevPar dev_par("echo",(echo?"true":"false"));
|
|
DevParams dev_params;
|
|
|
|
dev_params.push_back(dev_par);
|
|
memaddr_ranges.push_back(addr_range);
|
|
|
|
SetupDevice(DEVNUM_CHARIO, memaddr_ranges, dev_params);
|
|
if (false == mCharIOActive) AddDevice(DEVNUM_CHARIO);
|
|
mCharIOActive = true;
|
|
mpMemMapDev->ActivateCharIO();
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: DisableCharIO()
|
|
* Purpose: Deactivates basic character I/O emulation (console).
|
|
* Arguments: n/a
|
|
* Returns: n/a
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
void Memory::DisableCharIO()
|
|
{
|
|
mCharIOActive = false;
|
|
DeleteDevice(DEVNUM_CHARIO);
|
|
mpMemMapDev->DeactivateCharIO();
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: GetCharIOAddr()
|
|
* Purpose: Returns current address of basic character I/O area.
|
|
* Arguments: n/a
|
|
* Returns: address of I/O area
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
unsigned short Memory::GetCharIOAddr()
|
|
{
|
|
return mCharIOAddr;
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: SetGraphDisp()
|
|
* Purpose: Setup and activate graphics display device.
|
|
* Arguments: addr - base address of display device
|
|
* Returns: n/a
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
void Memory::SetGraphDisp(unsigned short addr)
|
|
{
|
|
AddrRange addr_range(addr, addr + GRAPHDEVREG_END - 1);
|
|
MemAddrRanges memaddr_ranges;
|
|
DevPar dev_par("nil","nil");
|
|
DevParams dev_params;
|
|
|
|
dev_params.push_back(dev_par);
|
|
memaddr_ranges.push_back(addr_range);
|
|
|
|
SetupDevice(DEVNUM_GRDISP, memaddr_ranges, dev_params);
|
|
if (false == mGraphDispActive) AddDevice(DEVNUM_GRDISP);
|
|
mGraphDispActive = true;
|
|
mpMemMapDev->ActivateGraphDisp();
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: DisableGraphDisp()
|
|
* Purpose: Inactivate graphics display device.
|
|
* Arguments: n/a
|
|
* Returns: n/a
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
void Memory::DisableGraphDisp()
|
|
{
|
|
mGraphDispActive = false;
|
|
mpMemMapDev->DeactivateGraphDisp();
|
|
DeleteDevice(DEVNUM_GRDISP);
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: GetGraphDispAddr()
|
|
* Purpose: Return base address of graphics display device.
|
|
* Arguments: n/a
|
|
* Returns: unsigned short - address ($0000 - $FFFF)
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
unsigned short Memory::GetGraphDispAddr()
|
|
{
|
|
return mpMemMapDev->GetGraphDispAddrBase();
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: GetROMBegin()
|
|
* Purpose: Get starting address of read-only memory.
|
|
* Arguments:
|
|
* Returns: unsigned short - address ($0000-$FFFF)
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
unsigned short Memory::GetROMBegin()
|
|
{
|
|
return mROMBegin;
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: GetROMEnd()
|
|
* Purpose: Get end address of read-only memory.
|
|
* Arguments:
|
|
* Returns: unsigned short - address ($0000-$FFFF)
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
unsigned short Memory::GetROMEnd()
|
|
{
|
|
return mROMEnd;
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: IsROMEnabled()
|
|
* Purpose: Get status of ROM.
|
|
* Arguments:
|
|
* Returns: bool - true if enabled.
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
bool Memory::IsROMEnabled()
|
|
{
|
|
return mROMActive;
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: AddDevice()
|
|
* Purpose: Add device to active devices cache.
|
|
* Arguments: devnum - device number
|
|
* Returns: -1 if device is not supported OR already cached
|
|
* devnum - device number if it was found
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
int Memory::AddDevice(int devnum)
|
|
{
|
|
int ret = -1;
|
|
bool found = false;
|
|
Device dev = mpMemMapDev->GetDevice(devnum);
|
|
if (dev.num >= 0) {
|
|
for (vector<Device>::iterator devit = mActiveDeviceVec.begin();
|
|
devit != mActiveDeviceVec.end();
|
|
++devit
|
|
) {
|
|
|
|
if (devit->num == devnum) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
// if device not found in local cache, add it
|
|
if (!found) {
|
|
mActiveDeviceVec.push_back(dev);
|
|
ret = devnum;
|
|
|
|
// update the device usage flag in memory pages devices array mMemPageDev
|
|
for (MemAddrRanges::iterator memrangeit = dev.addr_ranges.begin();
|
|
memrangeit != dev.addr_ranges.end();
|
|
++memrangeit
|
|
) {
|
|
|
|
int pgnum = memrangeit->start_addr / MEM_PAGE_SIZE;
|
|
while (pgnum < MEM_PAGE_SIZE) {
|
|
mMemPageDev[pgnum] = devnum;
|
|
pgnum++;
|
|
if (pgnum * MEM_PAGE_SIZE > memrangeit->end_addr) break;
|
|
}
|
|
}
|
|
}
|
|
} // END if (dev.num >= 0)
|
|
// else device with such number is not supported
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: DeleteDevice()
|
|
* Purpose: Delete device from active devices cache.
|
|
* Arguments: devnum - device number
|
|
* Returns: >=0 if device was found in local cache and deleted
|
|
* -1 if device was not found
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
int Memory::DeleteDevice(int devnum)
|
|
{
|
|
vector<Device> actdev_new;
|
|
int ret = -1;
|
|
|
|
for (int i=0; i < MEM_PAGE_SIZE; i++) {
|
|
mMemPageDev[i] = -1;
|
|
}
|
|
// device is deleted by refreshing local active devices cache
|
|
// the device to be deleted is skipped and not re-added to refreshed
|
|
// cache vector
|
|
for (vector<Device>::iterator devit = mActiveDeviceVec.begin();
|
|
devit != mActiveDeviceVec.end();
|
|
++devit
|
|
) {
|
|
|
|
if (devit->num != devnum) {
|
|
|
|
Device dev = mpMemMapDev->GetDevice(devit->num);
|
|
|
|
if (dev.num < 0)
|
|
throw MKGenException("Unsupported device in local cache");
|
|
|
|
actdev_new.push_back(mpMemMapDev->GetDevice(devit->num));
|
|
|
|
// update the device number in memory pages devices array mMemPageDev
|
|
for (MemAddrRanges::iterator memrangeit = devit->addr_ranges.begin();
|
|
memrangeit != devit->addr_ranges.end();
|
|
++memrangeit
|
|
) {
|
|
|
|
int pgnum = memrangeit->start_addr / MEM_PAGE_SIZE;
|
|
while (pgnum < MEM_PAGE_SIZE) {
|
|
mMemPageDev[pgnum] = devit->num;
|
|
pgnum++;
|
|
if (pgnum * MEM_PAGE_SIZE > memrangeit->end_addr) break;
|
|
}
|
|
}
|
|
|
|
} else ret++; // indicating that the device was found in cache
|
|
}
|
|
// refresh local active devices cache
|
|
mActiveDeviceVec.clear();
|
|
mActiveDeviceVec = actdev_new;
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: SetupDevice()
|
|
* Purpose: Configure device address ranges and parameters.
|
|
* Arguments: devnum - device number, must be on active dev. list
|
|
* memranges - memory address ranges vector
|
|
* params - parameters vector
|
|
* Returns: n/a
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
void Memory::SetupDevice(int devnum,
|
|
MemAddrRanges memranges,
|
|
DevParams params)
|
|
{
|
|
Device dev = mpMemMapDev->GetDevice(devnum);
|
|
if (dev.num >= 0) {
|
|
mpMemMapDev->SetupDevice(devnum, memranges, params);
|
|
// reload device to local vector because its setup has changed
|
|
// but only if device was cached locally already (active)
|
|
if (0 <= DeleteDevice(devnum)) AddDevice(devnum);
|
|
}
|
|
if (DEVNUM_CHARIO == devnum) {
|
|
mCharIOAddr = mpMemMapDev->GetCharIOAddr();
|
|
mIOEcho = mpMemMapDev->GetCharIOEchoOn();
|
|
}
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: GetCharIn()
|
|
* Purpose: Return character from the emulated character I/O FIFO
|
|
* input buffer or -1 if FIFO empty or char I/O not active.
|
|
* Arguments: n/a
|
|
* Returns: character
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
char Memory::GetCharIn()
|
|
{
|
|
return mpMemMapDev->GetCharIn();
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: GetCharOut()
|
|
* Purpose: Return character from the emulated character I/O FIFO
|
|
* output buffer or -1 if FIFO empty or char I/O not
|
|
* active.
|
|
* Arguments: n/a
|
|
* Returns: character
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
char Memory::GetCharOut()
|
|
{
|
|
return mpMemMapDev->GetCharOut();
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: GraphDisp_ReadEvents()
|
|
* Purpose: Read events from the graphics display window.
|
|
* Arguments: n/a
|
|
* Returns: n/a
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
void Memory::GraphDisp_ReadEvents()
|
|
{
|
|
mpMemMapDev->GraphDisp_ReadEvents();
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: GraphDisp_Update()
|
|
* Purpose: Trigger update handler of the graphics display window.
|
|
* Arguments: n/a
|
|
* Returns: n/a
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
void Memory::GraphDisp_Update()
|
|
{
|
|
mpMemMapDev->GraphDisp_Update();
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: GraphDispOp()
|
|
* Purpose: Status of last operation being perf. on Graphics Display
|
|
* or not.
|
|
* Arguments: n/a
|
|
* Returns: bool, true if last operation was performed on Graphics
|
|
* Display device.
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
bool Memory::GraphDispOp()
|
|
{
|
|
return mDispOp;
|
|
}
|
|
|
|
/*
|
|
*--------------------------------------------------------------------
|
|
* Method: GetMemMapDevPtr()
|
|
* Purpose: Get the pointer to MemMapDev object.
|
|
* Arguments: n/a
|
|
* Returns: Pointer to MemMapDev object.
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
MemMapDev *Memory::GetMemMapDevPtr()
|
|
{
|
|
return mpMemMapDev;
|
|
}
|
|
|
|
} // namespace MKBasic
|