This appendix contains the framework's C++ class declarations. Anyone attempting to write a simulator should look them over.
// $Id: BasicCPU.hxx,v 1.1 1996/08/02 14:49:30 bwmott Exp $
///////////////////////////////////////////////////////////////////////////////
//
// BasicCPU.hxx
//
// This is the abstract base class for all microprocessors
//
//
// BSVC "A Microprocessor Simulation Framework"
// Copyright (c) 1993
// By: Bradford W. Mott
// June 27,1993
//
///////////////////////////////////////////////////////////////////////////////
// $Log: BasicCPU.hxx,v $
// Revision 1.1 1996/08/02 14:49:30 bwmott
// Initial revision
//
///////////////////////////////////////////////////////////////////////////////
#ifndef BASICCPU_HXX
#define BASICCPU_HXX
#include <string>
#include <vector>
#include "AddressSpace.hxx"
class BasicCPU;
class BasicDevice;
class RegisterInformationList;
class StatisticalInformationList;
class AddressSpace;
#include "Event.hxx"
class BasicCPU {
public:
// Constructor
BasicCPU(const char* name, int granularity,
vector<AddressSpace*>& addressSpaces,
const char* traceRecordFormat,
const char* defaultTraceRecordEntries);
// Destructor
virtual ~BasicCPU();
// Answer name of the microprocessor
const char* Name() const { return myName; }
// Answer the granularity of the microprocessor
unsigned int Granularity() const { return myGranularity; }
// Answer a reference to my event handler
EventHandler& eventHandler() { return myEventHandler; };
// Answer the number of address spaces used by the processor
unsigned int NumberOfAddressSpaces() const
{ return myAddressSpaces.size(); }
// Answer the execution trace record format
const char* ExecutionTraceRecord() const
{ return myExecutionTraceRecord; }
// Answer the default execution trace entries
const char* DefaultExecutionTraceEntries() const
{ return myDefaultExecutionTraceEntries; }
// Answer the indexed address space object
AddressSpace& addressSpace(unsigned int addressSpace)
{ return *myAddressSpaces[addressSpace]; }
// Execute next instruction. Answers pointer to an error message or null
virtual const char* ExecuteInstruction(string& traceRecord, bool trace) = 0;
// Handle an interrupt request from a device
virtual void InterruptRequest(BasicDevice* device, int level) = 0;
// Perform a system reset
virtual void Reset() = 0;
// Answers value of the program counter register
virtual unsigned long ValueOfProgramCounter() = 0;
// Sets named register to the given hexidecimal value
virtual void SetRegister(const string& name, const string& hexValue) = 0;
// Clear the CPU's Statistics
virtual void ClearStatistics() = 0;
// Append all of the CPU's registers to the RegisterInformationList object
virtual void BuildRegisterInformationList(RegisterInformationList&) = 0;
// Append all of the CPU's stats to the StatisticalInformationList object
virtual void BuildStatisticalInformationList(StatisticalInformationList&)=0;
protected:
// Pointer to array of address space objects
vector<AddressSpace*>& myAddressSpaces;
// My event handler
EventHandler myEventHandler;
private:
// My name
const char* myName;
// My granularity in bytes
const unsigned int myGranularity;
// Trace record format used by the ExecuteInstruction member function
const char* myExecutionTraceRecord;
// Default fields of the trace record that should be displayed by UI
const char* myDefaultExecutionTraceEntries;
};
#endif
// $Id: BasicDevice.hxx,v 1.1 1996/08/02 14:50:07 bwmott Exp $
///////////////////////////////////////////////////////////////////////////////
//
// BasicDevice.hxx
//
// This should be the base class for all devices
//
//
// BSVC "A Microprocessor Simulation Framework"
// Copyright (c) 1993
// By: Bradford W. Mott
// July 26,1993
//
///////////////////////////////////////////////////////////////////////////////
// $Log: BasicDevice.hxx,v $
// Revision 1.1 1996/08/02 14:50:07 bwmott
// Initial revision
//
///////////////////////////////////////////////////////////////////////////////
#ifndef BASICDEVICE_HXX
#define BASICDEVICE_HXX
#include <string>
class BasicDevice;
class BasicCPU;
#include "Event.hxx"
#define AUTOVECTOR_INTERRUPT -1
#define SPURIOUS_INTERRUPT -2
class BasicDevice : public EventBase {
public:
// Constructor
BasicDevice(const char* name, const string& arguments, BasicCPU& cpu);
// Destructor
virtual ~BasicDevice();
// Change my startup error message
void ErrorMessage(const string& message)
{ myErrorMessage = message; }
// Answer my startup error message
string ErrorMessage() const
{ return(myErrorMessage); }
// Answer my name
const char* Name() const { return(myName); }
// Answer the CPU I belong too
BasicCPU& CPU() const { return(myCPU); }
// Answer my initialization arguments
string Arguments() const { return (myArguments); }
// Answers true iff the address maps into the device
virtual bool CheckMapped(unsigned long) const = 0;
// Answers the lowest address used by the device
virtual unsigned long LowestAddress() const = 0;
// Answers the highest address used by the device
virtual unsigned long HighestAddress() const = 0;
// Get a byte from the device
virtual unsigned char Peek(unsigned long address) = 0;
// Put a byte into the device
virtual void Poke(unsigned long address, unsigned char c) = 0;
// Reset the device
virtual void Reset();
// This routine sends an interrupt request (IRQ) to the CPU
virtual void InterruptRequest(int level);
// This routine is called by the CPU when it processes an interrupt
virtual long InterruptAcknowledge(int level);
protected:
// Reference to the CPU I belong too
BasicCPU& myCPU;
// My name (i.e. RAM, ROM, etc.)
const char* myName;
// Arguments passed to constructor
string myArguments;
// Error that occured during construction
string myErrorMessage;
// Interrupt pending flag
bool myInterruptPending;
};
#endif
// $Id: BasicDeviceRegistry.hxx,v 1.1 1996/08/02 14:50:41 bwmott Exp $
/////////////////////////////////////////////////////////////////////////////// //
// BasicDeviceRegistry.hxx
//
// This abstract base class is used to derive a class that maintains a list
// of all the device in the simulator and allows them to be created.
//
//
// BSVC "A Microprocessor Simulation Framework"
// Copyright (c) 1993
// By: Bradford W. Mott
// October 30,1993
//
///////////////////////////////////////////////////////////////////////////////
// $Log: BasicDeviceRegistry.hxx,v $
// Revision 1.1 1996/08/02 14:50:41 bwmott
// Initial revision
//
///////////////////////////////////////////////////////////////////////////////
#ifndef BASICDEVICEREGISTRY_HXX
#define BASICDEVICEREGISTRY_HXX
#include <string>
class BasicCPU;
class BasicDevice;
// Device information structure
struct DeviceInformation {
const char* name; // The name of the device ("RAM","m6850",etc)
const char* description; // A short description of the device
const char* script; // UI script to get the device attachment args
};
class BasicDeviceRegistry {
public:
// Constructor
BasicDeviceRegistry(const DeviceInformation* devices, unsigned int number)
: myDevices(devices),
myNumberOfDevices(number)
{}
// Destructor
virtual ~BasicDeviceRegistry()
{}
// Answers the number of devices
unsigned int NumberOfDevices() { return myNumberOfDevices; }
// Get device information for the given index. Answers true iff successful
bool Information(unsigned int index, DeviceInformation& information);
// Create a device with the given name. Answers true iff successful
virtual bool Create(const string& name, const string& args,
BasicCPU& cpu, BasicDevice*& device) = 0;
private:
// Array of devices in the simulator
const DeviceInformation* myDevices;
// Number of devices in the simulator
const unsigned int myNumberOfDevices;
};
#endif
// $Id: AddressSpace.hxx,v 1.1 1996/08/02 14:48:41 bwmott Exp $
///////////////////////////////////////////////////////////////////////////////
//
// AddressSpace.hxx
//
// This class maintains a list of devices and provides methods to
// peek and poke into them.
//
//
// BSVC "A Microprocessor Simulation Framework"
// Copyright (c) 1993
// By: Bradford W. Mott
// June 27,1993
//
///////////////////////////////////////////////////////////////////////////////
// $Log: AddressSpace.hxx,v $
// Revision 1.1 1996/08/02 14:48:41 bwmott
// Initial revision
//
///////////////////////////////////////////////////////////////////////////////
#ifndef ADDRESSSPACE_HXX
#define ADDRESSSPACE_HXX
#include <list>
#include <string>
class AddressSpace;
class BasicDevice;
#include "BasicDevice.hxx"
///////////////////////////////////////////////////////////////////////////////
// AddressSpace class declaration
///////////////////////////////////////////////////////////////////////////////
class AddressSpace {
public:
// Used to retrieve information about attached devices
struct DeviceInformation {
string name;
string arguments;
unsigned int index;
};
public:
// Constructor
AddressSpace(unsigned long maximumAddress);
// Destructor
virtual ~AddressSpace();
// Answer the maximum address of the address space
unsigned long MaximumAddress() const { return(myMaximumAddress); }
// Attach the given device. Answers true iff successful
bool AttachDevice(BasicDevice*);
// Detach the indexed device and destroy it. Answers true iff successful
bool DetachDevice(unsigned int index);
// Reset all the attached devices
void Reset();
// Answers the number of attached devices
unsigned int NumberOfAttachedDevices() const;
// Get information about the indexed device. Answer true iff successful
bool GetDeviceInformation(unsigned int index,
AddressSpace::DeviceInformation& info) const;
// Peek the given location. Answers true iff successful
virtual bool Peek(unsigned long addr, unsigned char &c);
// Poke the given location. Answers true iff successful
virtual bool Poke(unsigned long addr, unsigned char c);
private:
// List of attached devices
list<BasicDevice*> myDevices;
// Maximum address for this address space (In CPU words not bytes!!)
const unsigned long myMaximumAddress;
};
#endif
// $Id: BasicLoader.hxx,v 1.1 1996/08/02 14:51:02 bwmott Exp $
///////////////////////////////////////////////////////////////////////////////
// BasicLoader.hxx
//
// This abstract base class provides methods to load object files into the
// the simulator.
//
//
// BSVC "A Microprocessor Simulation Framework"
// Copyright (c) 1993
// By: Bradford W. Mott
// November 5,1993
//
///////////////////////////////////////////////////////////////////////////////
// $Log: BasicLoader.hxx,v $
// Revision 1.1 1996/08/02 14:51:02 bwmott
// Initial revision
//
///////////////////////////////////////////////////////////////////////////////
#ifndef BASICLOADER_HXX
#define BASICLOADER_HXX
#include <string>
class BasicCPU;
///////////////////////////////////////////////////////////////////////////////
// BasicLoader class declaration
///////////////////////////////////////////////////////////////////////////////
class BasicLoader {
public:
BasicLoader(BasicCPU& c)
: myCPU(c)
{}
virtual ~BasicLoader()
{}
// Answer my CPU
BasicCPU& CPU() { return myCPU; }
// Loads the named file and answers an error message or the empty string
virtual string Load(const char *filename, int addressSpace) = 0;
protected:
BasicCPU& myCPU;
};
#endif
// $Id: Event.hxx,v 1.1 1996/08/02 14:51:50 bwmott Exp $
///////////////////////////////////////////////////////////////////////////////
// Event.hxx
//
// This class maintains a queue of events requested by EventBase derived
// objects.
//
//
// BSVC "A Microprocessor Simulation Framework"
// Copyright (c) 1993
// By: Bradford W. Mott
// August 11,1993
//
///////////////////////////////////////////////////////////////////////////////
// $Log: Event.hxx,v $
// Revision 1.1 1996/08/02 14:51:50 bwmott
// Initial revision
//
///////////////////////////////////////////////////////////////////////////////
#ifndef EVENT_HXX
#define EVENT_HXX
#include <string>
class EventHandler;
///////////////////////////////////////////////////////////////////////////////
// Should be the base class for any class that is going to register
// events with the event handler
///////////////////////////////////////////////////////////////////////////////
class EventBase {
public:
// Constructor
EventBase(EventHandler& handler)
: myEventHandler(handler)
{}
// Destructor
virtual ~EventBase();
// Called when a registered event is dispatched
virtual void EventCallback(long data, void* pointer) = 0;
private:
EventHandler& myEventHandler;
};
class EventHandler {
public:
// Constructor
EventHandler();
// Check for any expired events
void Check();
// Add an event to the event list
void Add(EventBase* object, long data, void* pointer, long time);
// Remove events for the given object
void Remove(EventBase* object);
private:
// The event class
class Event {
public:
Event(EventBase* object, long data, void* pointer, unsigned long t)
: total_time(t), next(0),
myObject(object), myPointer(pointer), myData(data)
{};
// Dispatch the event by calling the object's callback routine
void Dispatch() { myObject->EventCallback(myData, myPointer); }
// Return the owning object
EventBase* Owner() { return myObject; }
// Total amount of time to elapse before the event
const long total_time;
// Time left before the event occurs
long delta_time;
// Pointer to the next event
Event *next;
private:
// The object that owns this event
EventBase* myObject;
// Data to be passed to the callback method
void* myPointer;
long myData;
};
// Linked list of events
Event* myEvents;
// Number of calls since last time update
long myIterations;
// Last usec_per_check update time
long myOldTime;
// Average micro-seconds per call to Check
long myMicrosecondsPerCheck;
};
#endif
// $Id: RegInfo.hxx,v 1.1 1996/08/02 14:52:55 bwmott Exp $
/////////////////////////////////////////////////////////////////////////////// //
// RegInfo.hxx
//
// This class is used by BasicCPU (and derived classes) to manage a list of
// of register structures.
//
//
// BSVC "A Microprocessor Simulation Framework"
// Copyright (c) 1993
// By: Bradford W. Mott
// October 25,1993
//
///////////////////////////////////////////////////////////////////////////////
// $Log: RegInfo.hxx,v $
// Revision 1.1 1996/08/02 14:52:55 bwmott
// Initial revision
//
///////////////////////////////////////////////////////////////////////////////
#ifndef REGINFO_HXX
#define REGINFO_HXX
#include <string>
#include <list>
class BasicCPU;
///////////////////////////////////////////////////////////////////////////////
// RegisterInformation class declaration
///////////////////////////////////////////////////////////////////////////////
class RegisterInformation {
public:
// Constructor
RegisterInformation(const string& name, const string& hexValue,
const string& description)
: myName(name),
myHexValue(hexValue),
myDescription(description)
{}
// Default Construtor
RegisterInformation()
{}
// Destructor
~RegisterInformation()
{}
// Set the name, hex value, and the description fields
void Set(const string& name, const string& hexValue,
const string& description)
{ myName = name; myHexValue = hexValue; myDescription = description; }
string Name() const { return myName; }
string HexValue() const { return myHexValue; }
string Description() const { return myDescription; }
private:
string myName; // The name given to the register ("D0", "PC", etc)
string myHexValue; // The value of the register in hexidecimal
string myDescription; // A short description of the register
};
///////////////////////////////////////////////////////////////////////////////
// RegisterInformationList class declaration
///////////////////////////////////////////////////////////////////////////////
class RegisterInformationList {
public:
// Constructor
RegisterInformationList(BasicCPU& cpu);
// Destructor
~RegisterInformationList();
// Append an element to the end of the list
void Append(const string& name, const string& hexValue, const string& desc);
// Return the number of elements in the list
unsigned int NumberOfElements() const { return myList.size(); }
// Get the element with the given index. Answer true iff successful
bool Element(unsigned int index, RegisterInformation& info);
private:
list<RegisterInformation*> myList;
};
#endif
// $Id: StatInfo.hxx,v 1.1 1996/08/02 14:53:12 bwmott Exp $
/////////////////////////////////////////////////////////////////////////////// //
// StatInfo.hxx
//
// This class is used by BasicCPU (and derived classes) to manage a list of
// of statistics objects.
//
//
// BSVC "A Microprocessor Simulation Framework"
// Copyright (c) 1993
// By: Bradford W. Mott
// December 5,1993
//
///////////////////////////////////////////////////////////////////////////////
// $Log: StatInfo.hxx,v $
// Revision 1.1 1996/08/02 14:53:12 bwmott
// Initial revision
//
///////////////////////////////////////////////////////////////////////////////
#ifndef STATINFO_HXX
#define STATINFO_HXX
#include <string>
#include <list>
class BasicCPU;
///////////////////////////////////////////////////////////////////////////////
// The Statistic Information Class
///////////////////////////////////////////////////////////////////////////////
class StatisticInformation {
public:
// Constructor
StatisticInformation(const string& statistic)
: myStatistic(statistic)
{}
// Default constructor
StatisticInformation()
{}
// Destructor
~StatisticInformation()
{}
// Set the statistic fields
void Set(const string& statistic)
{ myStatistic = statistic; }
// Answer my statistic
string Statistic() const { return myStatistic; }
private:
string myStatistic;
};
///////////////////////////////////////////////////////////////////////////////
// The Statistical Information List Class
///////////////////////////////////////////////////////////////////////////////
class StatisticalInformationList {
public:
// Constructor
StatisticalInformationList(BasicCPU& cpu);
// Destructor
~StatisticalInformationList();
// Append an element to the end of the list
void Append(const string& statistic);
// Answer the number of elements in the list
unsigned int NumberOfElements() const { return myList.size(); }
// Get the element with the given index. Answer true iff successful
bool Element(unsigned int index, StatisticInformation& info);
private:
list<StatisticInformation*> myList;
};
#endif
// $Id: Interface.hxx,v 1.1 1996/08/02 14:52:26 bwmott Exp $
///////////////////////////////////////////////////////////////////////////////
// Interface.hxx
//
// This is the user interface command class. It handles all of the
// command's issue by the user interface.
//
//
// BSVC "A Microprocessor Simulation Framework"
// Copyright (c) 1993
// By: Bradford W. Mott
// October 21,1993
//
///////////////////////////////////////////////////////////////////////////////
// $Log: Interface.hxx,v $
// Revision 1.1 1996/08/02 14:52:26 bwmott
// Initial revision
//
///////////////////////////////////////////////////////////////////////////////
#ifndef INTERFACE_HXX
#define INTERFACE_HXX
#include <iostream.h>
class BasicCPU;
class BasicDeviceRegistry;
class BasicLoader;
class BreakpointList;
class Interface {
public:
// Constructor
Interface(BasicCPU& cpu, BasicDeviceRegistry& registry,
BasicLoader& loader);
// Command loop
void CommandLoop();
private:
// Structure for the interface's command table
struct CommandTable {
const char* name;
void (Interface::*mfp)(char*);
};
private:
// Indicates the number of commands in the command table
const unsigned int myNumberOfCommands;
// Reference to the CPU I'm managing
BasicCPU& myCPU;
// Reference to the device registry
BasicDeviceRegistry& myDeviceRegistry;
// Reference to the loader
BasicLoader& myLoader;
// Reference to the input stream used to get information from the UI
istream& myInputStream;
// Reference to the output stream used to send information to the UI
ostream& myOutputStream;
// Breakpoint list to manage the breakpoints
BreakpointList& myBreakpointList;
// Execute the given command
void ExecuteCommand(char* command);
// Table of commands
static CommandTable ourCommandTable[];
// Member funtion for each of the commands
void AddBreakpoint(char* args);
void AttachDevice(char* args);
void ClearStatistics(char* args);
void DeleteBreakpoint(char* args);
void DetachDevice(char* args);
void FillMemoryBlock(char* args);
void ListAttachedDevices(char* args);
void ListBreakpoints(char* args);
void ListDevices(char* args);
void ListDeviceScript(char* args);
void ListExecutionTraceRecord(char* args);
void ListDefaultExecutionTraceEntries(char* args);
void ListGranularity(char* args);
void ListMemory(char* args);
void ListMaximumAddress(char* args);
void ListNumberOfAddressSpaces(char* args);
void ListRegisters(char* args);
void ListRegisterValue(char* args);
void ListRegisterDescription(char* args);
void ListStatistics(char* args);
void LoadProgram(char* args);
void ProgramCounterValue(char* args);
void Reset(char* args);
void Run(char* args);
void SetRegister(char* args);
void SetMemory(char* args);
void Step(char* args);
};
#endif
This document was produced using an evaluation version of HTML Transit