Subversion Repositories pentevo

Rev

Blame | Last modification | View Log | Download | RSS feed | ?url?

  1. #include "std.h"
  2.  
  3. #include "emul.h"
  4. #include "vars.h"
  5. #include "debug.h"
  6. #include "dbgpaint.h"
  7. #include "dbgtrace.h"
  8. #include "dbgrwdlg.h"
  9. #include "fdd.h"
  10. #include "util.h"
  11.  
  12. /*
  13.      dialogs design
  14.  
  15. ┌───────────────────────┐
  16. │Read from TR-DOS file  │
  17. ├───────────────────────┤
  18. │drive: A               │
  19. │file:  12345678 C      │
  20. │start: E000 end: FFFF  │
  21. └───────────────────────┘
  22.  
  23. ┌───────────────────────┐
  24. │Read from TR-DOS sector│
  25. ├───────────────────────┤
  26. │drive: A               │
  27. │trk (00-9F): 00        │
  28. │sec (00-0F): 08        │
  29. │start: E000 end: FFFF  │
  30. └───────────────────────┘
  31.  
  32. ┌───────────────────────┐
  33. │Read RAW sectors       │
  34. ├───────────────────────┤
  35. │drive: A               │
  36. │cyl (00-4F): 00 side: 0│
  37. │sec (00-0F): 08 num: 01│
  38. │start: E000            │
  39. └───────────────────────┘
  40.  
  41. ┌───────────────────────┐
  42. │Read from host file    │
  43. ├───────────────────────┤
  44. │file: 12345678.bin     │
  45. │start: C000 end: FFFF  │
  46. └───────────────────────┘
  47.  
  48. */
  49.  
  50. enum FILEDLG_MODE
  51. {
  52.     FDM_LOAD = 0,
  53.     FDM_SAVE,
  54.     FDM_DISASM
  55. };
  56.  
  57. unsigned addr = 0;
  58. unsigned end = 0xFFFF;
  59. static unsigned char *memdata;
  60. static unsigned rw_drive;
  61. static unsigned rw_trk;
  62. static unsigned rw_tsec;
  63. static char fname[ 20] = "";
  64. static char trdname[ 9] = "12345678";
  65. static char trdext[ 2] = "C";
  66.  
  67. const int FILEDLG_X = 6;
  68. const int FILEDLG_Y = 10;
  69. const int FILEDLG_DX = 25;
  70.  
  71. //=============================================================================
  72. static void rw_err( const char *msg)
  73. {
  74.     MessageBox( wnd, msg, "Error", MB_OK | MB_ICONERROR);
  75. }
  76. //=============================================================================
  77.  
  78.  
  79.  
  80. //=============================================================================
  81. static char query_file_addr( FILEDLG_MODE mode)
  82. {
  83.     filledframe( FILEDLG_X, FILEDLG_Y, FILEDLG_DX, 5);
  84.     char ln[ 64];
  85.     static const char *titles[] = { " Read from binary file   ",
  86.                                     " Write to binary file    ",
  87.                                     " Disasm to text file     " };
  88.    
  89.     tprint( FILEDLG_X, FILEDLG_Y, titles[ mode], FRM_HEADER);
  90.     tprint( FILEDLG_X + 1, FILEDLG_Y + 2, "file:", FFRAME_INSIDE);
  91.    
  92.     sprintf(  ln,
  93.               (mode != FDM_LOAD)  ?  "start: %04X end: %04X" :
  94.                                      "start: %04X",
  95.               addr,
  96.               end  );
  97.     tprint( FILEDLG_X + 1, FILEDLG_Y + 3, ln, FFRAME_INSIDE);
  98.     strcpy( str, fname);
  99.     //-------------------------------------------------------------------------
  100.     for (    ;    ;    )
  101.     {
  102.         //---------------------------------------------------------------------
  103.         if (!inputhex( FILEDLG_X + 7, FILEDLG_Y + 2, 16, false))
  104.           return 0;
  105.         //---------------------------------------------------------------------
  106.         if (mode != FDM_LOAD)
  107.           break;
  108.         //---------------------------------------------------------------------
  109.         if (GetFileAttributes( str) != INVALID_FILE_ATTRIBUTES)
  110.           break;
  111.         //---------------------------------------------------------------------
  112.     }
  113.     //-------------------------------------------------------------------------
  114.     strcpy( fname, str);
  115.     sprintf( ln, "%-16s", fname);
  116.     fillattr( FILEDLG_X + 7,FILEDLG_Y + 2, 16);
  117.     int a1 = input4( FILEDLG_X + 8, FILEDLG_Y + 3, addr);
  118.     //-------------------------------------------------------------------------
  119.     if (a1 == -1)
  120.         return 0;
  121.     //-------------------------------------------------------------------------
  122.     addr = unsigned( a1);
  123.     fillattr( FILEDLG_X + 8, FILEDLG_Y + 3, 4);
  124.     //-------------------------------------------------------------------------
  125.     if (mode == FDM_LOAD)
  126.         return 1;
  127.     //-------------------------------------------------------------------------
  128.     for (    ;    ;    )
  129.     {
  130.         int e1 = input4( FILEDLG_X + 18, FILEDLG_Y + 3, end);
  131.         //---------------------------------------------------------------------
  132.         if (e1 == -1)
  133.             return 0;
  134.         //---------------------------------------------------------------------
  135.         if (unsigned( e1) < addr)
  136.             continue;
  137.         //---------------------------------------------------------------------
  138.         end = unsigned( e1);
  139.         return 1;
  140.     }
  141.     //-------------------------------------------------------------------------
  142. }
  143. //=============================================================================
  144.  
  145.  
  146.  
  147. //=============================================================================
  148. static void write_mem()
  149. {
  150.     Z80 &cpu = CpuMgr.Cpu();
  151.     u8 *ptr = memdata;
  152.     //-------------------------------------------------------------------------
  153.     for (unsigned a1 = addr;    a1 <= end;    a1++)
  154.         *cpu.DirectMem( a1) = *ptr++;
  155.     //-------------------------------------------------------------------------
  156. }
  157. //=============================================================================
  158.  
  159.  
  160.  
  161. //=============================================================================
  162. static void read_mem()
  163. {
  164.     Z80 &cpu = CpuMgr.Cpu();
  165.     unsigned char *ptr = memdata;
  166.     //-------------------------------------------------------------------------
  167.     for (unsigned a1 = addr;    a1 <= end;    a1++)
  168.         *ptr++ = cpu.DirectRm( a1);
  169.     //-------------------------------------------------------------------------
  170. }
  171. //=============================================================================
  172.  
  173.  
  174.  
  175. //=============================================================================
  176. static char rw_select_drive()
  177. {
  178.     tprint(FILEDLG_X+1, FILEDLG_Y+2, "drive:", FFRAME_INSIDE);
  179.     //-------------------------------------------------------------------------
  180.     for (    ;    ;    )
  181.     {
  182.         *(unsigned*) str = 'A' + rw_drive;
  183.         //---------------------------------------------------------------------
  184.         if (!inputhex( FILEDLG_X + 8, FILEDLG_Y + 2, 1, true))
  185.             return 0;
  186.         //---------------------------------------------------------------------
  187.         fillattr( FILEDLG_X + 8, FILEDLG_Y + 2, 1);
  188.         unsigned disk = unsigned( *str - 'A');
  189.         //---------------------------------------------------------------------
  190.         if (disk > 3)
  191.             continue;
  192.         //---------------------------------------------------------------------
  193.         if (!comp.fdd[ disk].rawdata)
  194.             continue;
  195.         //---------------------------------------------------------------------
  196.         rw_drive = disk;
  197.         return 1;
  198.     }
  199.     //-------------------------------------------------------------------------
  200. }
  201. //=============================================================================
  202.  
  203.  
  204.  
  205. //=============================================================================
  206. static char rw_trdos_sectors( FILEDLG_MODE mode)
  207. {
  208.     filledframe( FILEDLG_X, FILEDLG_Y, FILEDLG_DX, 7);
  209.     const char *title = (mode == FDM_LOAD)  ?  " Read from TR-DOS sectors" :
  210.                                                " Write to TR-DOS sectors ";
  211.     tprint( FILEDLG_X, FILEDLG_Y, title, FRM_HEADER);
  212.  
  213.     char ln[ 64];
  214.     int t;
  215.  
  216.     sprintf( ln, "trk (00-9F): %02X", rw_trk);
  217.     tprint( FILEDLG_X + 1, FILEDLG_Y + 3, ln, FFRAME_INSIDE);
  218.  
  219.     sprintf( ln, "sec (00-0F): %02X", rw_tsec);
  220.     tprint( FILEDLG_X + 1, FILEDLG_Y + 4, ln, FFRAME_INSIDE);
  221.  
  222.     sprintf( ln, "start: %04X end: %04X", addr, end);
  223.     tprint( FILEDLG_X + 1, FILEDLG_Y + 5, ln, FFRAME_INSIDE);
  224.  
  225.     //-------------------------------------------------------------------------
  226.     if (!rw_select_drive())
  227.         return 0;
  228.     //-------------------------------------------------------------------------
  229.     FDD *fdd = &comp.fdd[ rw_drive];
  230.     //-------------------------------------------------------------------------
  231.     // if (fdd->sides != 2)
  232.     // {
  233.     //      rw_err( "single-side TR-DOS disks are not supported");
  234.     //      return 0;
  235.     // }
  236.     //-------------------------------------------------------------------------
  237.     t = input2(FILEDLG_X+14, FILEDLG_Y+3, rw_trk);
  238.     //-------------------------------------------------------------------------
  239.     if (t == -1)
  240.     {
  241.         return 0;
  242.     }
  243.     //-------------------------------------------------------------------------
  244.     else
  245.     {
  246.         rw_trk = unsigned( t);
  247.     }
  248.     //-------------------------------------------------------------------------
  249.     fillattr( FILEDLG_X + 14, FILEDLG_Y + 3, 2);
  250.  
  251.     t = input2( FILEDLG_X + 14, FILEDLG_Y + 4, rw_tsec);
  252.     //-------------------------------------------------------------------------
  253.     if (t == -1)
  254.     {
  255.         return 0;
  256.     }
  257.     //-------------------------------------------------------------------------
  258.     else
  259.     {    
  260.         rw_tsec = unsigned( t);
  261.     }
  262.     //-------------------------------------------------------------------------
  263.     fillattr( FILEDLG_X + 14, FILEDLG_Y + 4, 2);
  264.  
  265.     t = input4(FILEDLG_X+8,FILEDLG_Y+5,addr);
  266.     //-------------------------------------------------------------------------
  267.     if (t == -1)
  268.     {
  269.         return 0;
  270.     }
  271.     //-------------------------------------------------------------------------
  272.     else
  273.     {
  274.         addr = unsigned( t);
  275.     }
  276.     //-------------------------------------------------------------------------
  277.     fillattr( FILEDLG_X + 8, FILEDLG_Y + 5, 4);
  278.     //-------------------------------------------------------------------------
  279.     for (    ;    ;    )
  280.     {
  281.         t = input4( FILEDLG_X + 18, FILEDLG_Y + 5, end);
  282.         fillattr( FILEDLG_X + 18, FILEDLG_Y + 5, 4);
  283.         //-------------------------------------------------------------------------
  284.         if (t == -1)
  285.             return 0;
  286.         //-------------------------------------------------------------------------
  287.         if (unsigned( t) < addr)
  288.             continue;
  289.         //-------------------------------------------------------------------------
  290.         end = unsigned( t);
  291.         break;
  292.     }
  293.     //-------------------------------------------------------------------------
  294.     unsigned offset = 0;
  295.     //-------------------------------------------------------------------------
  296.     if (mode == FDM_SAVE)
  297.         read_mem();
  298.     //-------------------------------------------------------------------------
  299.     unsigned trk = rw_trk;
  300.     unsigned sec = rw_tsec;
  301.  
  302.     TRKCACHE tc; tc.clear();
  303.     //-------------------------------------------------------------------------
  304.     for (    ;    ;    )
  305.     {
  306.         int left = int( end + 1) - int( addr + offset);
  307.         //---------------------------------------------------------------------
  308.         if (left <= 0)
  309.             break;
  310.         //---------------------------------------------------------------------
  311.         if (left > 0x100)
  312.             left = 0x100;
  313.         //---------------------------------------------------------------------
  314.         tc.seek( fdd, trk/2, trk & 1, LOAD_SECTORS);
  315.         //---------------------------------------------------------------------
  316.         if (!tc.trkd)
  317.         {
  318.             sprintf( ln, "track #%02X not found", trk);
  319.             rw_err( ln);
  320.             break;
  321.         }
  322.         //---------------------------------------------------------------------
  323.         const SECHDR *hdr = tc.get_sector( sec + 1, 1);
  324.         //---------------------------------------------------------------------
  325.         if (!hdr || !hdr->data)
  326.         {
  327.             sprintf( ln, "track #%02X, sector #%02X not found", trk, sec);
  328.             rw_err( ln);
  329.             break;
  330.         }
  331.         //---------------------------------------------------------------------
  332.         if (hdr->l != 1)
  333.         {
  334.             sprintf( ln, "track #%02X, sector #%02X is not 256 bytes", trk, sec);
  335.             rw_err( ln);
  336.             break;
  337.         }
  338.         //---------------------------------------------------------------------
  339.         if (mode == FDM_LOAD)
  340.         {
  341.             memcpy( memdata + offset, hdr->data, size_t( left));
  342.         }
  343.         else
  344.         {
  345.             tc.write_sector( sec+1, 1, memdata + offset);
  346.             fdd->optype |= 1;
  347.         }
  348.         //---------------------------------------------------------------------
  349.  
  350.         offset += unsigned( left);
  351.         //---------------------------------------------------------------------
  352.         if (++sec == 0x10)
  353.         {
  354.             trk++;
  355.             sec = 0;
  356.         }
  357.         //---------------------------------------------------------------------
  358.     }
  359.     //-------------------------------------------------------------------------
  360.  
  361.     end = addr + offset - 1;
  362.     //-------------------------------------------------------------------------
  363.     if (mode == FDM_LOAD)
  364.         write_mem();
  365.     //-------------------------------------------------------------------------
  366.     return 1;
  367. }
  368. //=============================================================================
  369.  
  370.  
  371.  
  372. //=============================================================================
  373. static char wr_trdos_file()
  374. {
  375.     filledframe( FILEDLG_X, FILEDLG_Y, FILEDLG_DX, 6);
  376.     const char *title = " Write to TR-DOS file    ";
  377.     tprint( FILEDLG_X, FILEDLG_Y, title, FRM_HEADER);
  378.  
  379.     char ln[ 64];
  380.     int t;
  381.  
  382.     sprintf( ln, "file:  %-8s %s", trdname, trdext);
  383.     tprint( FILEDLG_X + 1, FILEDLG_Y + 3, ln, FFRAME_INSIDE);
  384.  
  385.     sprintf( ln, "start: %04X end: %04X", addr, end);
  386.     tprint( FILEDLG_X + 1, FILEDLG_Y + 4, ln, FFRAME_INSIDE);
  387.     //-------------------------------------------------------------------------
  388.     if (!rw_select_drive())
  389.         return 0;
  390.     //-------------------------------------------------------------------------
  391.     FDD *fdd = &comp.fdd[ rw_drive];
  392.    // if (fdd->sides != 2) { rw_err("single-side TR-DOS disks are not supported"); return 0; }
  393.  
  394.     strcpy( str, trdname);
  395.     //-------------------------------------------------------------------------
  396.     if (!inputhex( FILEDLG_X + 8, FILEDLG_Y + 3, 8, false))
  397.         return 0;
  398.     //-------------------------------------------------------------------------
  399.     fillattr( FILEDLG_X + 8, FILEDLG_Y + 3, 8);
  400.     strcpy( trdname, str);
  401.     //-------------------------------------------------------------------------
  402.     for (size_t ptr = strlen( trdname);    ptr < 8;    trdname[ ptr++] = ' ');
  403.     //-------------------------------------------------------------------------
  404.     trdname[ 8] = 0;
  405.  
  406.     strcpy( str, trdext);
  407.     //-------------------------------------------------------------------------
  408.     if (!inputhex( FILEDLG_X + 17, FILEDLG_Y + 3, 1, false))
  409.         return 0;
  410.     //-------------------------------------------------------------------------
  411.     fillattr( FILEDLG_X + 17, FILEDLG_Y + 3, 1);
  412.     trdext[0] = str[0];
  413.     trdext[1] = 0;
  414.  
  415.     t = input4( FILEDLG_X + 8, FILEDLG_Y + 4, addr);
  416.     //-------------------------------------------------------------------------
  417.     if (t == -1)
  418.     {
  419.         return 0;
  420.     }
  421.     //-------------------------------------------------------------------------
  422.     else
  423.     {
  424.         addr = unsigned( t);
  425.     }
  426.     //-------------------------------------------------------------------------
  427.     fillattr( FILEDLG_X + 8, FILEDLG_Y + 4, 4);
  428.     //-------------------------------------------------------------------------
  429.     for (    ;    ;    )
  430.     {
  431.         t = input4( FILEDLG_X + 18, FILEDLG_Y + 4, end);
  432.         fillattr( FILEDLG_X + 18, FILEDLG_Y + 4, 4);
  433.         //---------------------------------------------------------------------
  434.         if (t == -1)
  435.             return 0;
  436.         //---------------------------------------------------------------------
  437.         if (unsigned( t) < addr)
  438.             continue;
  439.         //---------------------------------------------------------------------
  440.         end = unsigned( t);
  441.         break;
  442.     }
  443.     //-------------------------------------------------------------------------
  444.  
  445.     read_mem();
  446.  
  447.     unsigned char hdr[ 16];
  448.     memcpy( hdr, trdname, 8);
  449.     hdr[ 8] = u8( *trdext);
  450.  
  451.     unsigned sz = end - addr + 1;
  452.     *(unsigned short*) (hdr + 9) = u16( addr);
  453.     *(unsigned short*) (hdr + 11) = u16( sz);
  454.     hdr[ 13] = u8( align_by( sz, 0x100U) / 0x100);      // sector size
  455.  
  456.     fdd->optype |= 1;
  457.     //-------------------------------------------------------------------------
  458.     if (!fdd->addfile(hdr, memdata))
  459.     {
  460.         rw_err( "write error");
  461.         return 0;
  462.     }
  463.     //-------------------------------------------------------------------------
  464.     return 1;
  465. }
  466. //=============================================================================
  467.  
  468.  
  469.  
  470. //=============================================================================
  471. void mon_load()
  472. {
  473.     static MENUITEM items[] =
  474.     {
  475.         { "from binary file", MENUITEM::LEFT },
  476.         { "from TR-DOS file", MENUITEM::LEFT },
  477.         { "from TR-DOS sectors", MENUITEM::LEFT },
  478.         { "from raw sectors of FDD image", MENUITEM::LEFT }
  479.     };
  480.    static MENUDEF menu =
  481.    {
  482.         items,
  483.         3,
  484.         "Load data to memory...",
  485.         0
  486.     };
  487.     //-------------------------------------------------------------------------
  488.     if (!handle_menu( &menu))
  489.         return;
  490.     //-------------------------------------------------------------------------
  491.     unsigned char bf[ 0x10000];
  492.     memdata = bf;
  493.     //-------------------------------------------------------------------------
  494.     switch (menu.pos)
  495.     {
  496.         //---------------------------------------------------------------------
  497.         case 0:
  498.         {
  499.             //-----------------------------------------------------------------
  500.             if (!query_file_addr( FDM_LOAD))
  501.                 return;
  502.             //-----------------------------------------------------------------
  503.             FILE *ff = fopen( fname, "rb");
  504.             //-----------------------------------------------------------------
  505.             if (!ff)
  506.                 return;
  507.             //-----------------------------------------------------------------
  508.             size_t sz = fread( bf, 1, sizeof( bf), ff);
  509.             fclose( ff);
  510.             end = unsigned( addr + sz - 1);
  511.             end = min( end, 0xFFFFU);
  512.             write_mem();
  513.             return;
  514.         }
  515.         //---------------------------------------------------------------------
  516.         case 1:
  517.         {
  518.             rw_err( "file selector\r\nis not implemented");
  519.             return;
  520.         }
  521.         //---------------------------------------------------------------------
  522.         case 2:
  523.         {
  524.             rw_trdos_sectors( FDM_LOAD);
  525.             return;
  526.         }
  527.         //---------------------------------------------------------------------
  528.         case 3:
  529.         {
  530.             return;
  531.         }
  532.         //---------------------------------------------------------------------
  533.     }
  534.     //-------------------------------------------------------------------------
  535. }
  536. //=============================================================================
  537.  
  538.  
  539.  
  540. //=============================================================================
  541. void mon_save()
  542. {
  543.     static MENUITEM items[] =
  544.     {
  545.         { "to binary file", MENUITEM::LEFT },
  546.         { "to TR-DOS file", MENUITEM::LEFT },
  547.         { "to TR-DOS sectors", MENUITEM::LEFT },
  548.         { "as Z80 disassembly", MENUITEM::LEFT },
  549.         { "to raw sectors of FDD image", (MENUITEM::FLAGS) (MENUITEM::LEFT | MENUITEM::DISABLED) }
  550.     };
  551.     static MENUDEF menu =
  552.     {
  553.         items,
  554.         4,
  555.         "Save data from memory...",
  556.         0
  557.     };
  558.     //-------------------------------------------------------------------------
  559.     if (!handle_menu( &menu))
  560.         return;
  561.     //-------------------------------------------------------------------------
  562.     unsigned char bf[ 0x10000];
  563.     memdata = bf;
  564.     //-------------------------------------------------------------------------
  565.     switch (menu.pos)
  566.     {
  567.         //---------------------------------------------------------------------
  568.         case 0:
  569.         {
  570.             //-----------------------------------------------------------------
  571.             if (!query_file_addr( FDM_SAVE))
  572.                 return;
  573.             //-----------------------------------------------------------------
  574.             read_mem();
  575.             FILE *ff = fopen( fname, "wb");
  576.             //-----------------------------------------------------------------
  577.             if (!ff)
  578.                 return;
  579.             //-----------------------------------------------------------------
  580.             fwrite( bf, 1, end + 1 - addr, ff);
  581.             fclose( ff);
  582.             return;
  583.         }
  584.         //---------------------------------------------------------------------
  585.         case 1:
  586.         {
  587.             wr_trdos_file();
  588.             return;
  589.         }
  590.         //---------------------------------------------------------------------
  591.         case 2:
  592.         {
  593.             rw_trdos_sectors( FDM_SAVE);
  594.             return;
  595.         }
  596.         //---------------------------------------------------------------------
  597.         case 3:
  598.         {
  599.             //-----------------------------------------------------------------
  600.             if (!query_file_addr( FDM_DISASM))
  601.                 return;
  602.             //-----------------------------------------------------------------
  603.             FILE *ff = fopen( fname, "wt");
  604.             //-----------------------------------------------------------------
  605.             if (!ff)
  606.                 return;
  607.             //-----------------------------------------------------------------
  608.             for (unsigned a = addr;    a <= end;    )
  609.             {
  610.                 // char line[64];               // Alone Coder 0.36.7
  611.                 char line[ 16 + 129];           // Alone Coder 0.36.7
  612.                 a += unsigned( disasm_line( a, line));
  613.                 fprintf( ff, "%s\n", line);
  614.             }
  615.             //-----------------------------------------------------------------
  616.             fclose( ff);
  617.             return;
  618.         }
  619.         //---------------------------------------------------------------------
  620.         case 4:
  621.         {
  622.             return;
  623.         }
  624.         //---------------------------------------------------------------------
  625.     }
  626.     //-------------------------------------------------------------------------
  627. }
  628. //=============================================================================
  629.