Return to debug.cc CVS log

Up to [UNIX Amiga Emulator] / uae

Annotation of uae/debug.cc, revision 1.1

1.1     ! root        1:  /* 
        !             2:   * UAE - The Unusable Amiga Emulator
        !             3:   * 
        !             4:   * debugger v0.0
        !             5:   * 
        !             6:   * (c) 1995 Bernd Schmidt
        !             7:   * 
        !             8:   */
        !             9: 
        !            10: #include <ctype.h>
        !            11: #include <iostream.h>
        !            12: #include <iomanip.h>
        !            13: 
        !            14: #include "amiga.h"
        !            15: #include "memory.h"
        !            16: #include "cpu.h"
        !            17: #include "custom.h"
        !            18: #include "cia.h"
        !            19: 
        !            20: void ignore_ws(char *&c)
        !            21: {
        !            22:   while (isspace(*c)) c++;
        !            23: }
        !            24: 
        !            25: ULONG readhex(char *&c)
        !            26: {
        !            27:   ULONG val = 0;
        !            28:   char nc;
        !            29: 
        !            30:   ignore_ws(c);
        !            31: 
        !            32:   while (isxdigit(nc = *c++)){
        !            33:     val *= 16;
        !            34:     nc = toupper(nc);
        !            35:     if (isdigit(nc)) {
        !            36:       val += nc - '0';
        !            37:     } else {
        !            38:       val += nc - 'A' + 10;
        !            39:     }
        !            40:   }
        !            41:   return val;
        !            42: }
        !            43: 
        !            44: char getchar(char *&c)
        !            45: {
        !            46:   ignore_ws(c);
        !            47:   return *c++;
        !            48: }
        !            49: 
        !            50: bool more_params(char *&c)
        !            51: {
        !            52:   ignore_ws(c);
        !            53:   return (*c) != 0;
        !            54: }
        !            55: 
        !            56: void dumpmem(CPTR addr,CPTR &nxmem,int lines)
        !            57: {
        !            58:   for (;lines--;){
        !            59:     cout << hex << setfill('0') << setw(8) << addr << " ";
        !            60:     for(int i=0; i< 16; i++) {
        !            61:       cout << setw(4) << mem.get_word(addr) << " "; addr += 2;
        !            62:     }
        !            63:     cout << "\n";
        !            64:   }
        !            65:   nxmem = addr;
        !            66: }
        !            67: 
        !            68: void debug()
        !            69: {
        !            70:   char input[80],c;
        !            71:   CPTR nextpc,nxdis,nxmem;
        !            72: 
        !            73:   cout << "debugging...\n";
        !            74:   MC68000_dumpstate(nextpc);
        !            75:   nxdis = nextpc; nxmem = 0;
        !            76:   for(;;){
        !            77:     char cmd,*inptr;
        !            78:     cout << ">";
        !            79:     cin.get(input,80,'\n');
        !            80:     cin.get(c);
        !            81:     inptr = input;
        !            82:     cmd = getchar(inptr);
        !            83:     switch(cmd){
        !            84:     case 'q': 
        !            85:       return;
        !            86:     case 'c':
        !            87:       dumpcia(); dumpcustom(); break;
        !            88:     case 'r':
        !            89:       MC68000_dumpstate(nextpc); break;
        !            90:     case 'd': 
        !            91:       {
        !            92:        ULONG daddr;
        !            93:        int count;
        !            94:        
        !            95:        if (more_params(inptr)) daddr = readhex(inptr); else daddr = nxdis;
        !            96:        if (more_params(inptr)) count = readhex(inptr); else count = 10;
        !            97:        MC68000_disasm(daddr,nxdis,count);
        !            98:       }
        !            99:       break;
        !           100:     case 't': 
        !           101:       MC68000_step(); MC68000_dumpstate(nextpc); break;
        !           102:     case 'z': 
        !           103:       MC68000_skip(nextpc); MC68000_dumpstate(nextpc); nxdis = nextpc; break;
        !           104:     case 'f': 
        !           105:       MC68000_skip(readhex(inptr)); MC68000_dumpstate(nextpc); break;
        !           106:     case 'm':
        !           107:       {
        !           108:        ULONG maddr; int lines;
        !           109:        if (more_params(inptr)) maddr = readhex(inptr); else maddr = nxmem;
        !           110:        if (more_params(inptr)) lines = readhex(inptr); else lines = 16;
        !           111:        dumpmem(maddr,nxmem,lines);
        !           112:       }
        !           113:       break;
        !           114:     }
        !           115:   }
        !           116: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.