#
Appendix B Framework Class Declarations

This appendix contains the framework's C++ class declarations. Anyone attempting to write a simulator should look them over.

BasicCPU Class Declaration

      // $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

BasicDevice Class Declaration

      // $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

BasicDeviceRegistry Class Declaration

      // $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

AddressSpace Class Declaration

      // $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

BasicLoader Class Declaration

      // $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

EventHandler Class Declaration

      // $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

RegisterInformationList Class Declaration

      // $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

StatisticalInformationList Class Declaration

      // $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

Interface Class Declaration

      // $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