Subversion Repositories pentevo

Rev

Rev 716 | Blame | Last modification | View Log | Download | RSS feed

  1. #include "std.h"
  2.  
  3. #include "emul.h"
  4. #include "vars.h"
  5. #include "debug.h"
  6. #include "dbgpaint.h"
  7. #include "dbgcmd.h"
  8. #include "dbgmem.h"
  9. #include "wd93crc.h"
  10. #include "util.h"
  11.  
  12. TRKCACHE edited_track;
  13.  
  14. unsigned sector_offset, sector;
  15.  
  16. void findsector(unsigned addr)
  17. {
  18.    for (sector_offset = sector = 0; sector < edited_track.s; sector++, sector_offset += edited_track.hdr[sector].datlen)
  19.       if (addr >= sector_offset && addr < sector_offset + edited_track.hdr[sector].datlen)
  20.          return;
  21.    errexit("internal diskeditor error");
  22. }
  23.  
  24. unsigned char *editam(unsigned addr)
  25. {
  26.    Z80 &cpu = CpuMgr.Cpu();
  27.    if (editor == ED_CMOS) return &cmos[addr & (sizeof(cmos)-1)];
  28.    if (editor == ED_NVRAM) return &nvram[addr & (sizeof(nvram)-1)];
  29.    if (editor == ED_MEM) return cpu.DirectMem(addr);
  30.    if (!edited_track.trkd) return 0;
  31.    if (editor == ED_PHYS) return edited_track.trkd + addr;
  32.    // editor == ED_LOG
  33.    findsector(addr); return edited_track.hdr[sector].data + addr - sector_offset;
  34. }
  35.  
  36. void editwm(unsigned addr, unsigned char byte)
  37. {
  38.    if (editrm(addr) == byte) return;
  39.    unsigned char *ptr = editam(addr);
  40.    if (!ptr) return; *ptr = byte;
  41.    if (editor == ED_MEM || editor == ED_CMOS || editor == ED_NVRAM) return;
  42.    if (editor == ED_PHYS) { comp.wd.fdd[mem_disk].optype |= 2; return; }
  43.    comp.wd.fdd[mem_disk].optype |= 1;
  44.    // recalc sector checksum
  45.    findsector(addr);
  46.    *(unsigned short*)(edited_track.hdr[sector].data + edited_track.hdr[sector].datlen) =
  47.       wd93_crc(edited_track.hdr[sector].data - 1, edited_track.hdr[sector].datlen + 1);
  48. }
  49.  
  50. unsigned memadr(unsigned addr)
  51. {
  52.    if (editor == ED_MEM) return (addr & 0xFFFF);
  53.    if (editor == ED_CMOS) return (addr & (sizeof(cmos)-1));
  54.    if (editor == ED_NVRAM) return (addr & (sizeof(nvram)-1));
  55.    // else if (editor == ED_PHYS || editor == ED_LOG)
  56.    if (!mem_max) return 0;
  57.    while ((int)addr < 0) addr += mem_max;
  58.    while (addr >= mem_max) addr -= mem_max;
  59.    return addr;
  60. }
  61.  
  62. void showmem()
  63. {
  64.    Z80 &cpu = CpuMgr.Cpu();
  65.    char line[80]; unsigned ii;
  66.    unsigned cursor_found = 0;
  67.    if (mem_dump) mem_ascii = 1, mem_sz = 32; else mem_sz = 8;
  68.  
  69.    if (editor == ED_LOG || editor == ED_PHYS)
  70.    {
  71.       edited_track.clear();
  72.       edited_track.seek(comp.wd.fdd+mem_disk, mem_track/2, mem_track & 1, (editor == ED_LOG)? LOAD_SECTORS : JUST_SEEK);
  73.       if (!edited_track.trkd) { // no track
  74.          for (ii = 0; ii < mem_size; ii++) {
  75.             sprintf(line, (ii == mem_size/2)?
  76.                "          track not found            ":
  77.                "                                     ");
  78.             tprint(mem_x, mem_y+ii, line, (activedbg == WNDMEM) ? W_SEL : W_NORM);
  79.          }
  80.          mem_max = 0;
  81.          goto title;
  82.       }
  83.       mem_max = edited_track.trklen;
  84.       if (editor == ED_LOG)
  85.          for (mem_max = ii = 0; ii < edited_track.s; ii++)
  86.             mem_max += edited_track.hdr[ii].datlen;
  87.    }
  88.    else if(editor == ED_MEM)
  89.        mem_max = 0x10000;
  90.    else if(editor == ED_CMOS)
  91.        mem_max = sizeof(cmos);
  92.    else if(editor == ED_NVRAM)
  93.        mem_max = sizeof(nvram);
  94.  
  95. redraw:
  96.    cpu.mem_curs = memadr(cpu.mem_curs);
  97.    cpu.mem_top = memadr(cpu.mem_top);
  98.    for (ii = 0; ii < mem_size; ii++)
  99.    {
  100.       unsigned ptr = memadr(cpu.mem_top + ii*mem_sz);
  101.       sprintf(line, "%04X ", ptr);
  102.       unsigned cx = 0;
  103.       if (mem_dump)
  104.       {  // 0000 0123456789ABCDEF0123456789ABCDEF
  105.          for (unsigned dx = 0; dx < 32; dx++)
  106.          {
  107.             if (ptr == cpu.mem_curs) cx = dx+5;
  108.             unsigned char c = editrm(ptr); ptr = memadr(ptr+1);
  109.             line[dx+5] = c ? c : '.';
  110.          }
  111.       }
  112.       else
  113.       {  // 0000 11 22 33 44 55 66 77 88 abcdefgh
  114.          for (unsigned dx = 0; dx < 8; dx++)
  115.          {
  116.             if (ptr == cpu.mem_curs) cx = (mem_ascii) ? dx+29 : dx*3 + 5 + cpu.mem_second;
  117.             unsigned char c = editrm(ptr); ptr = memadr(ptr+1);
  118.             sprintf(line+5+3*dx, "%02X", c); line[7+3*dx] = ' ';
  119.             line[29+dx] = c ? c : '.';
  120.          }
  121.       }
  122.       line[37] = 0;
  123.       tprint(mem_x, mem_y+ii, line, (activedbg == WNDMEM) ? W_SEL : W_NORM);
  124.       cursor_found |= cx;
  125.       if (cx && (activedbg == WNDMEM))
  126.          txtscr[(mem_y+ii)*80+mem_x+cx+80*30] = W_CURS;
  127.    }
  128.    if (!cursor_found) { cursor_found=1; cpu.mem_top=cpu.mem_curs & ~(mem_sz-1); goto redraw; }
  129. title:
  130.    const char *MemName = 0;
  131.    if (editor == ED_MEM)
  132.        MemName = "memory";
  133.    else if (editor == ED_CMOS)
  134.        MemName = "cmos";
  135.    else if (editor == ED_NVRAM)
  136.        MemName = "nvram";
  137.  
  138.    if(editor == ED_MEM || editor == ED_CMOS || editor == ED_NVRAM)
  139.    {
  140.        sprintf(line, "%s: %04X gsdma: %06X", MemName, cpu.mem_curs & 0xFFFF, temp.gsdmaaddr);
  141.    }
  142.    else if (editor == ED_PHYS)
  143.        sprintf(line, "disk %c, trk %02X, offs %04X", mem_disk+'A', mem_track, cpu.mem_curs);
  144.    else
  145.    { // ED_LOG
  146.       if (mem_max)
  147.           findsector(cpu.mem_curs);
  148.       sprintf(line, "disk %c, trk %02X, sec %02X[%02X], offs %04X",
  149.         mem_disk+'A', mem_track, sector, edited_track.hdr[sector].n,
  150.         cpu.mem_curs-sector_offset);
  151.    }
  152.    tprint(mem_x, mem_y-1, line, W_TITLE);
  153.    frame(mem_x,mem_y,37,mem_size,FRAME);
  154. }
  155.  
  156.       /* ------------------------------------------------------------- */
  157. void mstl()
  158. {
  159.     Z80 &cpu = CpuMgr.Cpu();
  160.     if (mem_max) cpu.mem_curs &= ~(mem_sz-1), cpu.mem_second = 0;
  161. }
  162. void mendl()
  163. {
  164.     Z80 &cpu = CpuMgr.Cpu();
  165.     if (mem_max) cpu.mem_curs |= (mem_sz-1), cpu.mem_second = 1;
  166. }
  167. void mup()
  168. {
  169.     Z80 &cpu = CpuMgr.Cpu();
  170.     if (mem_max) cpu.mem_curs -= mem_sz;
  171. }
  172. void mpgdn()
  173. {
  174.     Z80 &cpu = CpuMgr.Cpu();
  175.     if (mem_max) cpu.mem_curs += mem_size*mem_sz, cpu.mem_top += mem_size*mem_sz;
  176. }
  177.  
  178. void mpgup()
  179. {
  180.     Z80 &cpu = CpuMgr.Cpu();
  181.     if (mem_max) cpu.mem_curs -= mem_size*mem_sz, cpu.mem_top -= mem_size*mem_sz;
  182. }
  183.  
  184. void mdown()
  185. {
  186.    if (!mem_max) return;
  187.  
  188.    Z80 &cpu = CpuMgr.Cpu();
  189.    cpu.mem_curs += mem_sz;
  190.    if (((cpu.mem_curs - cpu.mem_top + mem_max) % mem_max) / mem_sz >= mem_size) cpu.mem_top += mem_sz;
  191. }
  192.  
  193. void mleft()
  194. {
  195.    if (!mem_max) return;
  196.    Z80 &cpu = CpuMgr.Cpu();
  197.    if (mem_ascii || !cpu.mem_second) cpu.mem_curs--;
  198.    if (!mem_ascii) cpu.mem_second ^= 1;
  199. }
  200.  
  201. void mright()
  202. {
  203.    Z80 &cpu = CpuMgr.Cpu();
  204.    if (!mem_max) return;
  205.    if (mem_ascii || cpu.mem_second) cpu.mem_curs++;
  206.    if (!mem_ascii) cpu.mem_second ^= 1;
  207.    if (((cpu.mem_curs - cpu.mem_top + mem_max) % mem_max) / mem_sz >= mem_size) cpu.mem_top += mem_sz;
  208. }
  209.  
  210. char dispatch_mem()
  211. {
  212.    Z80 &cpu = CpuMgr.Cpu();
  213.    if (!mem_max)
  214.        return 0;
  215.  
  216.    u8 Kbd[256];
  217.    GetKeyboardState(Kbd);
  218.    unsigned short k = 0;
  219.    if (ToAscii(input.lastkey,0,Kbd,&k,0) != 1)
  220.        return 0;
  221.  
  222.    if (mem_ascii)
  223.    {
  224.       k &= 0xFF;
  225.       if (k < 0x20 || k >= 0x80)
  226.           return 0;
  227.       editwm(cpu.mem_curs, (unsigned char)k);
  228.       mright();
  229.       return 1;
  230.    }
  231.    else
  232.    {
  233.       u8 u = toupper(k);
  234.       if ((u >= '0' && u <= '9') || (u >= 'A' && u <= 'F'))
  235.       {
  236.          unsigned char k = (u >= 'A') ? u - 'A'+10 : u - '0';
  237.          unsigned char c = editrm(cpu.mem_curs);
  238.          if (cpu.mem_second) editwm(cpu.mem_curs, (c & 0xF0) | k);
  239.          else editwm(cpu.mem_curs, (c & 0x0F) | (k << 4));
  240.          mright();
  241.          return 1;
  242.       }
  243.    }
  244.    return 0;
  245. }
  246.  
  247. void mtext()
  248. {
  249.    Z80 &cpu = CpuMgr.Cpu();
  250.    unsigned rs = find1dlg(cpu.mem_curs);
  251.    if (rs != -1) cpu.mem_curs = rs;
  252. }
  253.  
  254. void mcode()
  255. {
  256.    Z80 &cpu = CpuMgr.Cpu();
  257.    unsigned rs = find2dlg(cpu.mem_curs);
  258.    if (rs != -1) cpu.mem_curs = rs;
  259. }
  260.  
  261. void mgoto()
  262. {
  263.    Z80 &cpu = CpuMgr.Cpu();
  264.    unsigned v = input4(mem_x, mem_y, cpu.mem_top);
  265.    if (v != -1) cpu.mem_top = (v & ~(mem_sz-1)), cpu.mem_curs = v;
  266. }
  267.  
  268. void mswitch() { mem_ascii ^= 1; }
  269.  
  270. void msp()
  271. {
  272.     Z80 &cpu = CpuMgr.Cpu();
  273.     cpu.mem_curs = cpu.sp;
  274. }
  275. void mpc()
  276. {
  277.     Z80 &cpu = CpuMgr.Cpu();
  278.     cpu.mem_curs = cpu.pc;
  279. }
  280.  
  281. void mbc()
  282. {
  283.     Z80 &cpu = CpuMgr.Cpu();
  284.     cpu.mem_curs = cpu.bc;
  285. }
  286.  
  287. void mde()
  288. {
  289.     Z80 &cpu = CpuMgr.Cpu();
  290.     cpu.mem_curs = cpu.de;
  291. }
  292.  
  293. void mhl()
  294. {
  295.     Z80 &cpu = CpuMgr.Cpu();
  296.     cpu.mem_curs = cpu.hl;
  297. }
  298.  
  299. void mix()
  300. {
  301.     Z80 &cpu = CpuMgr.Cpu();
  302.     cpu.mem_curs = cpu.ix;
  303. }
  304.  
  305. void miy()
  306. {
  307.     Z80 &cpu = CpuMgr.Cpu();
  308.     cpu.mem_curs = cpu.iy;
  309. }
  310.  
  311. void mmodemem() { editor = ED_MEM; }
  312. void mmodephys() { editor = ED_PHYS; }
  313. void mmodelog() { editor = ED_LOG; }
  314.  
  315. void mdiskgo()
  316. {
  317.    Z80 &cpu = CpuMgr.Cpu();
  318.    if (editor == ED_MEM) return;
  319.    for (;;) {
  320.       *(unsigned*)str = mem_disk + 'A';
  321.       if (!inputhex(mem_x+5, mem_y-1, 1, true)) return;
  322.       if (*str >= 'A' && *str <= 'D') break;
  323.    }
  324.    mem_disk = *str-'A'; showmem();
  325.    unsigned x = input2(mem_x+12, mem_y-1, mem_track);
  326.    if (x == -1) return;
  327.    mem_track = x;
  328.    if (editor == ED_PHYS) return;
  329.    showmem();
  330.    // enter sector
  331.    for (;;) {
  332.       findsector(cpu.mem_curs); x = input2(mem_x+20, mem_y-1, sector);
  333.       if (x == -1) return; if (x < edited_track.s) break;
  334.    }
  335.    for (cpu.mem_curs = 0; x; x--) cpu.mem_curs += edited_track.hdr[x-1].datlen;
  336. }
  337.