1<HTML> 2<HEAD> 3<TITLE>appb.htm</TITLE> 4<LINK REL="ToC" HREF="httoc.htm"> 5<LINK REL="Previous" HREF="appa.htm"></HEAD> 6<BODY BGCOLOR="#FFFFFF" TEXT="#000000"> 7<HR WIDTH=100% SIZE=6 ALIGN=CENTER> 8<H1 ALIGN="CENTER"> 9<CENTER><A ID="I1" NAME="I1">Appendix B Framework Class Declarations 10<BR></A></CENTER></H1> 11<HR WIDTH=100% SIZE=6 ALIGN=CENTER> 12<P>This appendix contains the framework's C++ class declarations. Anyone attempting to write a simulator should look them over.</P><A ID="I2" NAME="I2"> 13<BR> 14<FONT SIZE=+2><B>BasicCPU Class Declaration</B></FONT></A> 15<HR SIZE=2 NOSHADE ALIGN=LEFT> 16<PRE> 17 // $Id: BasicCPU.hxx,v 1.1 1996/08/02 14:49:30 bwmott Exp $ 18 /////////////////////////////////////////////////////////////////////////////// 19 // 20 // BasicCPU.hxx 21 // 22 // This is the abstract base class for all microprocessors 23 // 24 // 25 // BSVC "A Microprocessor Simulation Framework" 26 // Copyright (c) 1993 27 // By: Bradford W. Mott 28 // June 27,1993 29 // 30 /////////////////////////////////////////////////////////////////////////////// 31 // $Log: BasicCPU.hxx,v $ 32 // Revision 1.1 1996/08/02 14:49:30 bwmott 33 // Initial revision 34 // 35 /////////////////////////////////////////////////////////////////////////////// 36 #ifndef BASICCPU_HXX 37 #define BASICCPU_HXX 38 #include <string> 39 #include <vector> 40 #include "AddressSpace.hxx" 41 class BasicCPU; 42 class BasicDevice; 43 class RegisterInformationList; 44 class StatisticalInformationList; 45 class AddressSpace; 46 #include "Event.hxx" 47 class BasicCPU { 48 public: 49 // Constructor 50 BasicCPU(const char* name, int granularity, 51 vector<AddressSpace*>& addressSpaces, 52 const char* traceRecordFormat, 53 const char* defaultTraceRecordEntries); 54 // Destructor 55 virtual ~BasicCPU(); 56 // Answer name of the microprocessor 57 const char* Name() const { return myName; } 58 // Answer the granularity of the microprocessor 59 unsigned int Granularity() const { return myGranularity; } 60 // Answer a reference to my event handler 61 EventHandler& eventHandler() { return myEventHandler; }; 62 // Answer the number of address spaces used by the processor 63 unsigned int NumberOfAddressSpaces() const 64 { return myAddressSpaces.size(); } 65 // Answer the execution trace record format 66 const char* ExecutionTraceRecord() const 67 { return myExecutionTraceRecord; } 68 // Answer the default execution trace entries 69 const char* DefaultExecutionTraceEntries() const 70 { return myDefaultExecutionTraceEntries; } 71 // Answer the indexed address space object 72 AddressSpace& addressSpace(unsigned int addressSpace) 73 { return *myAddressSpaces[addressSpace]; } 74 // Execute next instruction. Answers pointer to an error message or null 75 virtual const char* ExecuteInstruction(string& traceRecord, bool trace) = 0; 76 // Handle an interrupt request from a device 77 virtual void InterruptRequest(BasicDevice* device, int level) = 0; 78 // Perform a system reset 79 virtual void Reset() = 0; 80 // Answers value of the program counter register 81 virtual unsigned long ValueOfProgramCounter() = 0; 82 // Sets named register to the given hexidecimal value 83 virtual void SetRegister(const string& name, const string& hexValue) = 0; 84 // Clear the CPU's Statistics 85 virtual void ClearStatistics() = 0; 86 // Append all of the CPU's registers to the RegisterInformationList object 87 virtual void BuildRegisterInformationList(RegisterInformationList&) = 0; 88 // Append all of the CPU's stats to the StatisticalInformationList object 89 virtual void BuildStatisticalInformationList(StatisticalInformationList&)=0; 90 protected: 91 // Pointer to array of address space objects 92 vector<AddressSpace*>& myAddressSpaces; 93 // My event handler 94 EventHandler myEventHandler; 95 private: 96 // My name 97 const char* myName; 98 // My granularity in bytes 99 const unsigned int myGranularity; 100 // Trace record format used by the ExecuteInstruction member function 101 const char* myExecutionTraceRecord; 102 // Default fields of the trace record that should be displayed by UI 103 const char* myDefaultExecutionTraceEntries; 104 }; 105 #endif</PRE><A ID="I3" NAME="I3"> 106<BR> 107<FONT SIZE=+2><B>BasicDevice Class Declaration</B></FONT></A> 108<HR SIZE=2 NOSHADE ALIGN=LEFT> 109<PRE> 110 // $Id: BasicDevice.hxx,v 1.1 1996/08/02 14:50:07 bwmott Exp $ 111 /////////////////////////////////////////////////////////////////////////////// 112 // 113 // BasicDevice.hxx 114 // 115 // This should be the base class for all devices 116 // 117 // 118 // BSVC "A Microprocessor Simulation Framework" 119 // Copyright (c) 1993 120 // By: Bradford W. Mott 121 // July 26,1993 122 // 123 /////////////////////////////////////////////////////////////////////////////// 124 // $Log: BasicDevice.hxx,v $ 125 // Revision 1.1 1996/08/02 14:50:07 bwmott 126 // Initial revision 127 // 128 /////////////////////////////////////////////////////////////////////////////// 129 #ifndef BASICDEVICE_HXX 130 #define BASICDEVICE_HXX 131 #include <string> 132 class BasicDevice; 133 class BasicCPU; 134 #include "Event.hxx" 135 #define AUTOVECTOR_INTERRUPT -1 136 #define SPURIOUS_INTERRUPT -2 137 class BasicDevice : public EventBase { 138 public: 139 // Constructor 140 BasicDevice(const char* name, const string& arguments, BasicCPU& cpu); 141 // Destructor 142 virtual ~BasicDevice(); 143 // Change my startup error message 144 void ErrorMessage(const string& message) 145 { myErrorMessage = message; } 146 // Answer my startup error message 147 string ErrorMessage() const 148 { return(myErrorMessage); } 149 // Answer my name 150 const char* Name() const { return(myName); } 151 // Answer the CPU I belong too 152 BasicCPU& CPU() const { return(myCPU); } 153 // Answer my initialization arguments 154 string Arguments() const { return (myArguments); } 155 // Answers true iff the address maps into the device 156 virtual bool CheckMapped(unsigned long) const = 0; 157 // Answers the lowest address used by the device 158 virtual unsigned long LowestAddress() const = 0; 159 // Answers the highest address used by the device 160 virtual unsigned long HighestAddress() const = 0; 161 // Get a byte from the device 162 virtual unsigned char Peek(unsigned long address) = 0; 163 // Put a byte into the device 164 virtual void Poke(unsigned long address, unsigned char c) = 0; 165 // Reset the device 166 virtual void Reset(); 167 // This routine sends an interrupt request (IRQ) to the CPU 168 virtual void InterruptRequest(int level); 169 170 // This routine is called by the CPU when it processes an interrupt 171 virtual long InterruptAcknowledge(int level); 172 protected: 173 // Reference to the CPU I belong too 174 BasicCPU& myCPU; 175 // My name (i.e. RAM, ROM, etc.) 176 const char* myName; 177 // Arguments passed to constructor 178 string myArguments; 179 // Error that occured during construction 180 string myErrorMessage; 181 // Interrupt pending flag 182 bool myInterruptPending; 183 }; 184 #endif</PRE><A ID="I4" NAME="I4"> 185<BR> 186<FONT SIZE=+2><B>BasicDeviceRegistry Class Declaration</B></FONT></A> 187<HR SIZE=2 NOSHADE ALIGN=LEFT> 188<PRE> 189 // $Id: BasicDeviceRegistry.hxx,v 1.1 1996/08/02 14:50:41 bwmott Exp $ 190 /////////////////////////////////////////////////////////////////////////////// // 191 // BasicDeviceRegistry.hxx 192 // 193 // This abstract base class is used to derive a class that maintains a list 194 // of all the device in the simulator and allows them to be created. 195 // 196 // 197 // BSVC "A Microprocessor Simulation Framework" 198 // Copyright (c) 1993 199 // By: Bradford W. Mott 200 // October 30,1993 201 // 202 /////////////////////////////////////////////////////////////////////////////// 203 // $Log: BasicDeviceRegistry.hxx,v $ 204 // Revision 1.1 1996/08/02 14:50:41 bwmott 205 // Initial revision 206 // 207 /////////////////////////////////////////////////////////////////////////////// 208 #ifndef BASICDEVICEREGISTRY_HXX 209 #define BASICDEVICEREGISTRY_HXX 210 #include <string> 211 class BasicCPU; 212 class BasicDevice; 213 // Device information structure 214 struct DeviceInformation { 215 const char* name; // The name of the device ("RAM","m6850",etc) 216 const char* description; // A short description of the device 217 const char* script; // UI script to get the device attachment args 218 }; 219 class BasicDeviceRegistry { 220 public: 221 // Constructor 222 BasicDeviceRegistry(const DeviceInformation* devices, unsigned int number) 223 : myDevices(devices), 224 myNumberOfDevices(number) 225 {} 226 // Destructor 227 virtual ~BasicDeviceRegistry() 228 {} 229 // Answers the number of devices 230 unsigned int NumberOfDevices() { return myNumberOfDevices; } 231 // Get device information for the given index. Answers true iff successful 232 bool Information(unsigned int index, DeviceInformation& information); 233 // Create a device with the given name. Answers true iff successful 234 virtual bool Create(const string& name, const string& args, 235 BasicCPU& cpu, BasicDevice*& device) = 0; 236 private: 237 // Array of devices in the simulator 238 const DeviceInformation* myDevices; 239 // Number of devices in the simulator 240 const unsigned int myNumberOfDevices; 241 }; 242 #endif</PRE><A ID="I5" NAME="I5"> 243<BR> 244<FONT SIZE=+2><B>AddressSpace Class Declaration</B></FONT></A> 245<HR SIZE=2 NOSHADE ALIGN=LEFT> 246<PRE> 247 // $Id: AddressSpace.hxx,v 1.1 1996/08/02 14:48:41 bwmott Exp $ 248 /////////////////////////////////////////////////////////////////////////////// 249 // 250 // AddressSpace.hxx 251 // 252 // This class maintains a list of devices and provides methods to 253 // peek and poke into them. 254 // 255 // 256 // BSVC "A Microprocessor Simulation Framework" 257 // Copyright (c) 1993 258 // By: Bradford W. Mott 259 // June 27,1993 260 // 261 /////////////////////////////////////////////////////////////////////////////// 262 // $Log: AddressSpace.hxx,v $ 263 // Revision 1.1 1996/08/02 14:48:41 bwmott 264 // Initial revision 265 // 266 /////////////////////////////////////////////////////////////////////////////// 267 #ifndef ADDRESSSPACE_HXX 268 #define ADDRESSSPACE_HXX 269 #include <list> 270 #include <string> 271 class AddressSpace; 272 class BasicDevice; 273 #include "BasicDevice.hxx" 274 /////////////////////////////////////////////////////////////////////////////// 275 // AddressSpace class declaration 276 /////////////////////////////////////////////////////////////////////////////// 277 class AddressSpace { 278 public: 279 // Used to retrieve information about attached devices 280 struct DeviceInformation { 281 string name; 282 string arguments; 283 unsigned int index; 284 }; 285 public: 286 // Constructor 287 AddressSpace(unsigned long maximumAddress); 288 // Destructor 289 virtual ~AddressSpace(); 290 // Answer the maximum address of the address space 291 unsigned long MaximumAddress() const { return(myMaximumAddress); } 292 // Attach the given device. Answers true iff successful 293 bool AttachDevice(BasicDevice*); 294 // Detach the indexed device and destroy it. Answers true iff successful 295 bool DetachDevice(unsigned int index); 296 // Reset all the attached devices 297 void Reset(); 298 // Answers the number of attached devices 299 unsigned int NumberOfAttachedDevices() const; 300 // Get information about the indexed device. Answer true iff successful 301 bool GetDeviceInformation(unsigned int index, 302 AddressSpace::DeviceInformation& info) const; 303 // Peek the given location. Answers true iff successful 304 virtual bool Peek(unsigned long addr, unsigned char &c); 305 // Poke the given location. Answers true iff successful 306 virtual bool Poke(unsigned long addr, unsigned char c); 307 private: 308 // List of attached devices 309 list<BasicDevice*> myDevices; 310 // Maximum address for this address space (In CPU words not bytes!!) 311 const unsigned long myMaximumAddress; 312 }; 313 #endif</PRE><A ID="I6" NAME="I6"> 314<BR> 315<FONT SIZE=+2><B>BasicLoader Class Declaration</B></FONT></A> 316<HR SIZE=2 NOSHADE ALIGN=LEFT> 317<PRE> 318 // $Id: BasicLoader.hxx,v 1.1 1996/08/02 14:51:02 bwmott Exp $ 319 /////////////////////////////////////////////////////////////////////////////// 320 // BasicLoader.hxx 321 // 322 // This abstract base class provides methods to load object files into the 323 // the simulator. 324 // 325 // 326 // BSVC "A Microprocessor Simulation Framework" 327 // Copyright (c) 1993 328 // By: Bradford W. Mott 329 // November 5,1993 330 // 331 /////////////////////////////////////////////////////////////////////////////// 332 // $Log: BasicLoader.hxx,v $ 333 // Revision 1.1 1996/08/02 14:51:02 bwmott 334 // Initial revision 335 // 336 /////////////////////////////////////////////////////////////////////////////// 337 #ifndef BASICLOADER_HXX 338 #define BASICLOADER_HXX 339 #include <string> 340 class BasicCPU; 341 /////////////////////////////////////////////////////////////////////////////// 342 // BasicLoader class declaration 343 /////////////////////////////////////////////////////////////////////////////// 344 class BasicLoader { 345 public: 346 BasicLoader(BasicCPU& c) 347 : myCPU(c) 348 {} 349 virtual ~BasicLoader() 350 {} 351 // Answer my CPU 352 BasicCPU& CPU() { return myCPU; } 353 // Loads the named file and answers an error message or the empty string 354 virtual string Load(const char *filename, int addressSpace) = 0; 355 protected: 356 BasicCPU& myCPU; 357 }; 358 #endif</PRE><A ID="I7" NAME="I7"> 359<BR> 360<FONT SIZE=+2><B>EventHandler Class Declaration</B></FONT></A> 361<HR SIZE=2 NOSHADE ALIGN=LEFT> 362<PRE> 363 // $Id: Event.hxx,v 1.1 1996/08/02 14:51:50 bwmott Exp $ 364 /////////////////////////////////////////////////////////////////////////////// 365 // Event.hxx 366 // 367 // This class maintains a queue of events requested by EventBase derived 368 // objects. 369 // 370 // 371 // BSVC "A Microprocessor Simulation Framework" 372 // Copyright (c) 1993 373 // By: Bradford W. Mott 374 // August 11,1993 375 // 376 /////////////////////////////////////////////////////////////////////////////// 377 // $Log: Event.hxx,v $ 378 // Revision 1.1 1996/08/02 14:51:50 bwmott 379 // Initial revision 380 // 381 /////////////////////////////////////////////////////////////////////////////// 382 #ifndef EVENT_HXX 383 #define EVENT_HXX 384 #include <string> 385 class EventHandler; 386 /////////////////////////////////////////////////////////////////////////////// 387 // Should be the base class for any class that is going to register 388 // events with the event handler 389 /////////////////////////////////////////////////////////////////////////////// 390 class EventBase { 391 public: 392 // Constructor 393 EventBase(EventHandler& handler) 394 : myEventHandler(handler) 395 {} 396 // Destructor 397 virtual ~EventBase(); 398 // Called when a registered event is dispatched 399 virtual void EventCallback(long data, void* pointer) = 0; 400 private: 401 EventHandler& myEventHandler; 402 }; 403 class EventHandler { 404 public: 405 // Constructor 406 EventHandler(); 407 // Check for any expired events 408 void Check(); 409 // Add an event to the event list 410 void Add(EventBase* object, long data, void* pointer, long time); 411 // Remove events for the given object 412 void Remove(EventBase* object); 413 private: 414 // The event class 415 class Event { 416 public: 417 Event(EventBase* object, long data, void* pointer, unsigned long t) 418 : total_time(t), next(0), 419 myObject(object), myPointer(pointer), myData(data) 420 {}; 421 // Dispatch the event by calling the object's callback routine 422 void Dispatch() { myObject->EventCallback(myData, myPointer); } 423 // Return the owning object 424 EventBase* Owner() { return myObject; } 425 // Total amount of time to elapse before the event 426 const long total_time; 427 // Time left before the event occurs 428 long delta_time; 429 // Pointer to the next event 430 Event *next; 431 private: 432 // The object that owns this event 433 EventBase* myObject; 434 // Data to be passed to the callback method 435 void* myPointer; 436 long myData; 437 }; 438 439 // Linked list of events 440 Event* myEvents; 441 // Number of calls since last time update 442 long myIterations; 443 // Last usec_per_check update time 444 long myOldTime; 445 // Average micro-seconds per call to Check 446 long myMicrosecondsPerCheck; 447 }; 448 #endif</PRE><A ID="I8" NAME="I8"> 449<BR> 450<FONT SIZE=+2><B>RegisterInformationList Class Declaration</B></FONT></A> 451<HR SIZE=2 NOSHADE ALIGN=LEFT> 452<PRE> 453 // $Id: RegInfo.hxx,v 1.1 1996/08/02 14:52:55 bwmott Exp $ 454 /////////////////////////////////////////////////////////////////////////////// // 455 // RegInfo.hxx 456 // 457 // This class is used by BasicCPU (and derived classes) to manage a list of 458 // of register structures. 459 // 460 // 461 // BSVC "A Microprocessor Simulation Framework" 462 // Copyright (c) 1993 463 // By: Bradford W. Mott 464 // October 25,1993 465 // 466 /////////////////////////////////////////////////////////////////////////////// 467 // $Log: RegInfo.hxx,v $ 468 // Revision 1.1 1996/08/02 14:52:55 bwmott 469 // Initial revision 470 // 471 /////////////////////////////////////////////////////////////////////////////// 472 #ifndef REGINFO_HXX 473 #define REGINFO_HXX 474 #include <string> 475 #include <list> 476 class BasicCPU; 477 /////////////////////////////////////////////////////////////////////////////// 478 // RegisterInformation class declaration 479 /////////////////////////////////////////////////////////////////////////////// 480 class RegisterInformation { 481 public: 482 // Constructor 483 RegisterInformation(const string& name, const string& hexValue, 484 const string& description) 485 : myName(name), 486 myHexValue(hexValue), 487 myDescription(description) 488 {} 489 // Default Construtor 490 RegisterInformation() 491 {} 492 // Destructor 493 ~RegisterInformation() 494 {} 495 // Set the name, hex value, and the description fields 496 void Set(const string& name, const string& hexValue, 497 const string& description) 498 { myName = name; myHexValue = hexValue; myDescription = description; } 499 string Name() const { return myName; } 500 string HexValue() const { return myHexValue; } 501 string Description() const { return myDescription; } 502 private: 503 string myName; // The name given to the register ("D0", "PC", etc) 504 string myHexValue; // The value of the register in hexidecimal 505 string myDescription; // A short description of the register 506 }; 507 /////////////////////////////////////////////////////////////////////////////// 508 // RegisterInformationList class declaration 509 /////////////////////////////////////////////////////////////////////////////// 510 class RegisterInformationList { 511 public: 512 // Constructor 513 RegisterInformationList(BasicCPU& cpu); 514 // Destructor 515 ~RegisterInformationList(); 516 // Append an element to the end of the list 517 void Append(const string& name, const string& hexValue, const string& desc); 518 // Return the number of elements in the list 519 unsigned int NumberOfElements() const { return myList.size(); } 520 // Get the element with the given index. Answer true iff successful 521 bool Element(unsigned int index, RegisterInformation& info); 522 private: 523 list<RegisterInformation*> myList; 524 }; 525 #endif</PRE><A ID="I9" NAME="I9"> 526<BR> 527<FONT SIZE=+2><B>StatisticalInformationList Class Declaration</B></FONT></A> 528<HR SIZE=2 NOSHADE ALIGN=LEFT> 529<PRE> 530 // $Id: StatInfo.hxx,v 1.1 1996/08/02 14:53:12 bwmott Exp $ 531 /////////////////////////////////////////////////////////////////////////////// // 532 // StatInfo.hxx 533 // 534 // This class is used by BasicCPU (and derived classes) to manage a list of 535 // of statistics objects. 536 // 537 // 538 // BSVC "A Microprocessor Simulation Framework" 539 // Copyright (c) 1993 540 // By: Bradford W. Mott 541 // December 5,1993 542 // 543 /////////////////////////////////////////////////////////////////////////////// 544 // $Log: StatInfo.hxx,v $ 545 // Revision 1.1 1996/08/02 14:53:12 bwmott 546 // Initial revision 547 // 548 /////////////////////////////////////////////////////////////////////////////// 549 #ifndef STATINFO_HXX 550 #define STATINFO_HXX 551 #include <string> 552 #include <list> 553 class BasicCPU; 554 /////////////////////////////////////////////////////////////////////////////// 555 // The Statistic Information Class 556 /////////////////////////////////////////////////////////////////////////////// 557 class StatisticInformation { 558 public: 559 // Constructor 560 StatisticInformation(const string& statistic) 561 : myStatistic(statistic) 562 {} 563 // Default constructor 564 StatisticInformation() 565 {} 566 // Destructor 567 ~StatisticInformation() 568 {} 569 // Set the statistic fields 570 void Set(const string& statistic) 571 { myStatistic = statistic; } 572 // Answer my statistic 573 string Statistic() const { return myStatistic; } 574 private: 575 string myStatistic; 576 }; 577 /////////////////////////////////////////////////////////////////////////////// 578 // The Statistical Information List Class 579 /////////////////////////////////////////////////////////////////////////////// 580 class StatisticalInformationList { 581 public: 582 // Constructor 583 StatisticalInformationList(BasicCPU& cpu); 584 // Destructor 585 ~StatisticalInformationList(); 586 // Append an element to the end of the list 587 void Append(const string& statistic); 588 // Answer the number of elements in the list 589 unsigned int NumberOfElements() const { return myList.size(); } 590 // Get the element with the given index. Answer true iff successful 591 bool Element(unsigned int index, StatisticInformation& info); 592 private: 593 list<StatisticInformation*> myList; 594 }; 595 #endif</PRE><A ID="I10" NAME="I10"> 596<BR> 597<FONT SIZE=+2><B>Interface Class Declaration</B></FONT></A> 598<HR SIZE=2 NOSHADE ALIGN=LEFT> 599<PRE> 600 // $Id: Interface.hxx,v 1.1 1996/08/02 14:52:26 bwmott Exp $ 601 /////////////////////////////////////////////////////////////////////////////// 602 // Interface.hxx 603 // 604 // This is the user interface command class. It handles all of the 605 // command's issue by the user interface. 606 // 607 // 608 // BSVC "A Microprocessor Simulation Framework" 609 // Copyright (c) 1993 610 // By: Bradford W. Mott 611 // October 21,1993 612 // 613 /////////////////////////////////////////////////////////////////////////////// 614 // $Log: Interface.hxx,v $ 615 // Revision 1.1 1996/08/02 14:52:26 bwmott 616 // Initial revision 617 // 618 /////////////////////////////////////////////////////////////////////////////// 619 #ifndef INTERFACE_HXX 620 #define INTERFACE_HXX 621 #include <iostream.h> 622 class BasicCPU; 623 class BasicDeviceRegistry; 624 class BasicLoader; 625 class BreakpointList; 626 class Interface { 627 public: 628 // Constructor 629 Interface(BasicCPU& cpu, BasicDeviceRegistry& registry, 630 BasicLoader& loader); 631 // Command loop 632 void CommandLoop(); 633 634 private: 635 // Structure for the interface's command table 636 struct CommandTable { 637 const char* name; 638 void (Interface::*mfp)(char*); 639 }; 640 private: 641 // Indicates the number of commands in the command table 642 const unsigned int myNumberOfCommands; 643 // Reference to the CPU I'm managing 644 BasicCPU& myCPU; 645 // Reference to the device registry 646 BasicDeviceRegistry& myDeviceRegistry; 647 // Reference to the loader 648 BasicLoader& myLoader; 649 // Reference to the input stream used to get information from the UI 650 istream& myInputStream; 651 // Reference to the output stream used to send information to the UI 652 ostream& myOutputStream; 653 // Breakpoint list to manage the breakpoints 654 BreakpointList& myBreakpointList; 655 // Execute the given command 656 void ExecuteCommand(char* command); 657 // Table of commands 658 static CommandTable ourCommandTable[]; 659 // Member funtion for each of the commands 660 void AddBreakpoint(char* args); 661 void AttachDevice(char* args); 662 void ClearStatistics(char* args); 663 void DeleteBreakpoint(char* args); 664 void DetachDevice(char* args); 665 void FillMemoryBlock(char* args); 666 void ListAttachedDevices(char* args); 667 void ListBreakpoints(char* args); 668 void ListDevices(char* args); 669 void ListDeviceScript(char* args); 670 void ListExecutionTraceRecord(char* args); 671 void ListDefaultExecutionTraceEntries(char* args); 672 void ListGranularity(char* args); 673 void ListMemory(char* args); 674 void ListMaximumAddress(char* args); 675 void ListNumberOfAddressSpaces(char* args); 676 void ListRegisters(char* args); 677 void ListRegisterValue(char* args); 678 void ListRegisterDescription(char* args); 679 void ListStatistics(char* args); 680 void LoadProgram(char* args); 681 void ProgramCounterValue(char* args); 682 void Reset(char* args); 683 void Run(char* args); 684 void SetRegister(char* args); 685 void SetMemory(char* args); 686 void Step(char* args); 687 }; 688 #endif</PRE> 689<P>This document was produced using an evaluation version of <A HREF="http://www.infoaccess.com/products/transit/httoc.htm">HTML Transit</A></P> 690</BODY></HTML> 691