Subversion Repositories pentevo

Rev

Rev 1090 | Blame | Compare with Previous | 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 "dbgtrace.h"
  7. #include "dbglabls.h"
  8. #include "dbgpaint.h"
  9. #include "dbgcmd.h"
  10. #include "memory.h"
  11. #include "z80asm.h"
  12. #include "z80/op_system.h"
  13. #include "util.h"
  14.  
  15. #include "gsz80.h"              // фы  z80gs::GSCPUFQ   [NS]
  16.  
  17.  
  18.  
  19.  
  20. //#define       MOD_NEW_LABELS          // [NS]
  21.  
  22.  
  23.  
  24.  
  25. unsigned trace_follow_regs_in_view;     //Їыру ўЄю PC эрїюфшЄё  т яюыхчЁхэш      //[NS]
  26.  
  27.  
  28. //unsigned trace_follow_request;        // .conf Їыру ўЄю эєцэю яхЁхтхёЄш Їюъєё эр regs //[NS]
  29.  
  30. //unsigned trace_follow_regs;   // ЄхяхЁ№ conf.trace_follow_regs
  31.  
  32.  
  33.  
  34.  
  35.  
  36.  
  37. //=============================================================================
  38. bool get_labels( unsigned addr, char *line)                             // [NS]
  39. {
  40.     Z80 &cpu = CpuMgr.Cpu();
  41.  
  42.     sprintf( line, "   > ");
  43.     int ptr = 5;
  44.     //-------------------------------------------------------------------------
  45.  
  46.     {
  47.         char *virtlbl = mon_labels.find(((unsigned char *)NULL) + addr);        //NEDOREPO
  48.         char *lbl = mon_labels.find( am_r( addr));
  49.         //---------------------------------------------------------------------
  50.         if (virtlbl)
  51.             lbl = virtlbl;              //NEDOREPO
  52.         //---------------------------------------------------------------------
  53.         if (lbl)
  54.         {
  55.             for (int k = 0;    (k < 10) && lbl[ k];    )
  56.                 line[ ptr++] = lbl[ k++]; //Alone Coder
  57.         }
  58.         //---------------------------------------------------------------------
  59.         else
  60.         {
  61.             return FALSE;
  62.         }
  63.         //---------------------------------------------------------------------
  64.     }
  65.     //-------------------------------------------------------------------------
  66.     // чрыштър ёЄЁюъш юЄ юяъюфр фю ьэхьюэшъш
  67.     while (ptr < 32)
  68.         line[ ptr++] = ' ';
  69.     //-------------------------------------------------------------------------
  70.     line[ ptr] = 0;
  71.     return TRUE;
  72. }
  73. //=============================================================================
  74.  
  75.  
  76.  
  77. //=============================================================================
  78. int disasm_line( unsigned addr, char *line)
  79. {
  80.     Z80 &cpu = CpuMgr.Cpu();
  81.     unsigned char dbuf[ 16 + 129];                      /*Alone Code 0.36.7*/
  82.     ptrdiff_t i;                                        //Alone Coder 0.36.7
  83.     //-------------------------------------------------------------------------
  84.     for (/*int*/ i = 0;    i < 16;    i++)
  85.         dbuf[i] = cpu.DirectRm( addr + unsigned( i));
  86.     //-------------------------------------------------------------------------
  87.     sprintf( line, "%04X ", addr);
  88.     int ptr = 5;
  89.     ptrdiff_t len = disasm( dbuf, addr, char( trace_labels)) - dbuf;
  90.     //8000 ..DDCB0106 rr (ix+1)
  91.    
  92.    
  93.     //-------------------------------------------------------------------------
  94.     // 0000 LABELS ╤рьш ьэхьюэшъш ЄєЄ эх яхўрЄр■Єёю?
  95.     if ((trace_labels) && (!conf.Disasm_New_Labels))
  96.     {
  97.         char *virtlbl = mon_labels.find( ((unsigned char *) NULL) + addr);      //NEDOREPO
  98.         char *lbl = mon_labels.find( am_r( addr));
  99.         //---------------------------------------------------------------------
  100.         if (virtlbl)
  101.             lbl = virtlbl;              //NEDOREPO
  102.         //---------------------------------------------------------------------
  103. //      if (lbl) for (int k = 0;  k < 10  && lbl[k];  line[ptr++] = lbl[k++]); //Alone Coder    //╧╬╦═╬╤╥▄▐ ╙─└╦┼═╬ ┬ NEDOREPO
  104.        
  105.         if (lbl)
  106.         {
  107.             for (int k = 0;    (k < 10) && lbl[k];    )
  108.                 line[ ptr++] = lbl[ k++]; //Alone Coder
  109.         }
  110.     }
  111.     //-------------------------------------------------------------------------
  112.     // 0000 OPCODES ╤рьш ьэхьюэшъш ЄєЄ эх яхўрЄр■Єёю?
  113.     else
  114.     {
  115.         ptrdiff_t len1 = len;
  116.         //---------------------------------------------------------------------
  117.         if (len > 4)
  118.         {
  119.             len1 = 4;
  120.             *(short*) (line + ptr) = WORD2('.', '.');
  121.             ptr += 2;
  122.         }
  123.         //---------------------------------------------------------------------
  124.         for (i = len - len1;    i < len;    i++)
  125.         {
  126.             sprintf( line + ptr, "%02X", dbuf[ i]);
  127.             ptr += 2;
  128.         }
  129.         //---------------------------------------------------------------------
  130.     }
  131.     //-------------------------------------------------------------------------
  132.     // чрыштър ёЄЁюъш юЄ юяъюфр фю ьэхьюэшъш
  133.     while (ptr < 16)
  134.         line[ ptr++] = ' ';
  135.     //-------------------------------------------------------------------------
  136.     strcpy( line + ptr, asmbuf);
  137.     return int( len);
  138. }
  139. //=============================================================================
  140. #define TWF_BRANCH  0x010000U
  141. #define TWF_BRADDR  0x020000U
  142. #define TWF_LOOPCMD 0x040000U
  143. #define TWF_CALLCMD 0x080000U
  144. #define TWF_BLKCMD  0x100000U
  145. #define TWF_HALTCMD 0x200000U
  146. // ╠ырф°шх 16сшЄ - рфЁхё z80
  147. // ёЄрЁ°шх 16сшЄ - Їыруш TWF_xxxx
  148. //=============================================================================
  149.  
  150.  
  151. //=============================================================================
  152. static unsigned tracewndflags()                                         //????
  153. {
  154.     Z80 &cpu = CpuMgr.Cpu();
  155.     unsigned readptr = cpu.pc;
  156.     unsigned base = cpu.hl;
  157.     unsigned char opcode = 0;
  158.     unsigned char ed = 0;
  159.     //-------------------------------------------------------------------------
  160.     for (;;)
  161.     {
  162.         opcode = cpu.DirectRm( readptr++);
  163.         //---------------------------------------------------------------------
  164.         if (opcode == 0xDD)
  165.             base = cpu.ix;
  166.         //---------------------------------------------------------------------
  167.         else if (opcode == 0xFD)
  168.             base = cpu.iy;
  169.         //---------------------------------------------------------------------
  170.         else if (opcode == 0xED)
  171.             ed = 1;
  172.         //---------------------------------------------------------------------
  173.         else
  174.             break;
  175.         //---------------------------------------------------------------------
  176.     }
  177.     //-------------------------------------------------------------------------
  178.     unsigned fl = 0;
  179.     //-------------------------------------------------------------------------
  180.     if (opcode == 0x76) // halt
  181.     {
  182.         u32 addr;
  183.         //---------------------------------------------------------------------
  184.         if (cpu.im < 2)         //!!!! Єюўэю ыш фы  тёхї?????
  185.         {
  186.             addr = 0x38;
  187.         }
  188.         //---------------------------------------------------------------------
  189.         // im2
  190.         else
  191.         {
  192.             unsigned vec = unsigned( cpu.i << 8U) | cpu.IntVec();
  193.             addr = u32( (cpu.DirectRm( vec+1) << 8U) | cpu.DirectRm( vec));
  194.         }
  195.         //---------------------------------------------------------------------
  196.         return TWF_HALTCMD | addr;
  197.     }
  198.     //-------------------------------------------------------------------------
  199.     if (ed)
  200.     {
  201.         //---------------------------------------------------------------------
  202.         // ldir/lddr | cpir/cpdr | inir/indr | otir/otdr
  203.         if ((opcode & 0xF4) == 0xB0)
  204.             return TWF_BLKCMD;
  205.         //---------------------------------------------------------------------
  206.         // reti/retn
  207.         if ((opcode & 0xC7) != 0x45)
  208.             return 0;
  209.         //---------------------------------------------------------------------
  210. ret:
  211.         return  ( cpu.DirectRm( cpu.sp) | unsigned( cpu.DirectRm( cpu.sp + 1) << 8U))   |
  212.                 TWF_BRANCH                                                              |
  213.                 TWF_BRADDR;
  214.     }
  215.     //-------------------------------------------------------------------------
  216.     // ret
  217.     if (opcode == 0xC9)                                        
  218.         goto ret;
  219.     //-------------------------------------------------------------------------
  220.     // jp
  221.     if (opcode == 0xC3)                                        
  222.     {
  223. jp:    
  224.         return (cpu.DirectRm( readptr) | unsigned( cpu.DirectRm( readptr + 1) << 8U))   |
  225.         TWF_BRANCH                                                                      |
  226.         fl;
  227.     }
  228.     //-------------------------------------------------------------------------
  229.     // call
  230.     if (opcode == 0xCD)                                        
  231.     {
  232.         fl = TWF_CALLCMD;
  233.         goto jp;
  234.     }
  235.     //-------------------------------------------------------------------------
  236.     static const unsigned char flags[] = { ZF,CF,PV,SF };
  237.     //-------------------------------------------------------------------------
  238.     if ((opcode & 0xC1) == 0xC0)
  239.     {
  240.         unsigned char flag = flags[(opcode >> 4) & 3];
  241.         unsigned char res = cpu.f & flag;
  242.         //---------------------------------------------------------------------
  243.         if (!(opcode & 0x08))
  244.             res ^= flag;
  245.         //---------------------------------------------------------------------
  246.         if (!res)
  247.             return 0;
  248.         //---------------------------------------------------------------------
  249.         // ret cc
  250.         if ((opcode & 0xC7) == 0xC0)                           
  251.             goto ret;
  252.         //---------------------------------------------------------------------
  253.         // call cc
  254.         if ((opcode & 0xC7) == 0xC4)                           
  255.         {
  256.             fl = TWF_CALLCMD;
  257.             goto jp;
  258.         }
  259.         //---------------------------------------------------------------------
  260.         // jp cc
  261.         if ((opcode & 0xC7) == 0xC2)                           
  262.         {
  263.             fl = TWF_LOOPCMD;
  264.             goto jp;
  265.         }
  266.         //---------------------------------------------------------------------
  267.     }
  268.     //-------------------------------------------------------------------------
  269.     // jp (hl/ix/iy)
  270.     if (opcode == 0xE9)
  271.         return base | TWF_BRANCH | TWF_BRADDR;         
  272.     //-------------------------------------------------------------------------
  273.     // rst #xx
  274.     if ((opcode & 0xC7) == 0xC7)
  275.         return (opcode & 0x38) | TWF_CALLCMD | TWF_BRANCH;     
  276.     //-------------------------------------------------------------------------
  277.     if ((opcode & 0xC7) == 0x00)
  278.     {
  279.         //---------------------------------------------------------------------
  280.         if (!opcode || opcode == 0x08)
  281.             return 0;
  282.         //---------------------------------------------------------------------
  283.         int offs = (signed char) cpu.DirectRm( readptr++);
  284.         unsigned addr = unsigned( offs + int( readptr)) | TWF_BRANCH;
  285.         //---------------------------------------------------------------------
  286.         // jr
  287.         if (opcode == 0x18)
  288.             return addr;                                       
  289.         //---------------------------------------------------------------------
  290.         // djnz
  291.         if (opcode == 0x10)
  292.             return (cpu.b == 1)  ?  0 :
  293.                                     addr | TWF_LOOPCMD;        
  294.         //---------------------------------------------------------------------
  295.         // jr cc
  296.         unsigned char flag = flags[ (opcode >> 4) & 1];        
  297.         unsigned char res = cpu.f & flag;
  298.         //---------------------------------------------------------------------
  299.         if (!(opcode & 0x08))
  300.             res ^= flag;
  301.         //---------------------------------------------------------------------
  302.         return res  ?  addr | TWF_LOOPCMD :
  303.                        0;
  304.         //---------------------------------------------------------------------
  305.     }
  306.     return 0;
  307. }
  308. //=============================================================================
  309.  
  310.  
  311. //=============================================================================
  312. static unsigned trcurs_y;
  313. unsigned asmii;
  314. static char asmpc[ 64];
  315. static char dumppc[ 12];
  316. const unsigned cs[ 3][ 2] =
  317. {
  318.     {  0,  4},
  319.     {  5, 10},
  320.     { 16, 16}
  321. };
  322.  
  323. //=============================================================================
  324.  
  325.  
  326.  
  327.  
  328. //=============================================================================
  329. // юсэютыхэшх юъэр фшчрёьр т фхсрухЁх
  330. void showtrace()
  331. {
  332.  
  333. #define DBG_ATTR_TITLES         0x5D    //0x71  //white blue
  334.  
  335.  
  336.     char trace_follow_regs_text[ 10];
  337.     //-------------------------------------------------------------------------
  338.     switch (conf.trace_follow_regs)
  339.     {
  340.         case REG_AF:    sprintf( trace_follow_regs_text, "(AF)");       break;
  341.         case REG_BC:    sprintf( trace_follow_regs_text, "(BC)");       break;
  342.         case REG_DE:    sprintf( trace_follow_regs_text, "(DE)");       break;
  343.         case REG_HL:    sprintf( trace_follow_regs_text, "(HL)");       break;
  344.         case REG_AF1:   sprintf( trace_follow_regs_text, "(AF\')");     break;
  345.         case REG_BC1:   sprintf( trace_follow_regs_text, "(BC\')");     break;
  346.         case REG_DE1:   sprintf( trace_follow_regs_text, "(DE\')");     break;
  347.         case REG_HL1:   sprintf( trace_follow_regs_text, "(HL\')");     break;
  348.         case REG_IX:    sprintf( trace_follow_regs_text, "(IX)");       break;
  349.         case REG_IY:    sprintf( trace_follow_regs_text, "(IY)");       break;
  350.         case REG_SP:    sprintf( trace_follow_regs_text, "(SP)");       break;
  351.         case REG_PC:    sprintf( trace_follow_regs_text, "(PC)");       break;
  352.         default:        sprintf( trace_follow_regs_text, "(None)");     break;
  353.     }
  354.     //-------------------------------------------------------------------------
  355.     tprint(     trace_x + 26,
  356.                 trace_y - 1,
  357.                 trace_follow_regs_text,
  358.                 DBG_ATTR_TITLES
  359.              );
  360.     //-------------------------------------------------------------------------
  361.  
  362. //яхЁхьхёЄшЄ№ т debug.h !!!!
  363. #define DBG_ATTR_BCKGRND                0x00    //0     0
  364. #define DBG_ATTR_BCKGRND_ACTIVE         0x10    //blue  0
  365. #define DBG_ATTR_BCKGRND_BRIGHT         0X80    //br+   0
  366.  
  367. #define DBG_ATTR_TRACE_LINES            0x0F    //0             br+WHITE
  368. #define DBG_ATTR_TRACE_LINES_ROM        0x07    //0             WHITE
  369.  
  370.  
  371. #define DBG_ATTR_TRACE_BREAK_EX         0x0A    //0             red
  372.  
  373.  
  374. #define DBG_ATTR_TRACE_BREAK_R_BACK     0x40    //red           0
  375. #define DBG_ATTR_TRACE_BREAK_W_BACK     0x20    //green         0
  376. #define DBG_ATTR_TRACE_BREAK_RW_BACK    0x60    //yellow        0
  377. #define DBG_ATTR_TRACE_REG_PC_BACK      0xD0    //br+WHITE      0
  378. #define DBG_ATTR_TRACE_REG_FOLLOW_BACK  0xF0    //br+WHITE      0
  379.  
  380.  
  381.  
  382. #define DBG_ATTR_TRACE_SELECTED         0xB0    //br+MAGENTAA   0
  383.  
  384.  
  385. #define DBG_ATTR_TRACE_BRANCH_DIRECTION         0x0A    //0     br+RED
  386. #define DBG_ATTR_TRACE_BRANCH_DIRECTION_INV     0x0D    //0     br+CYAN
  387.  
  388. #define DBG_ATTR_TRACE_BRANCH_DESTINATION       0x0D    //0     br+CYAN
  389.  
  390. #define DBG_ATTR_TRACE_CURRENT_Z80              0x5D//0x70      //white 0
  391. #define DBG_ATTR_TRACE_LAST_BRANCH              0x5D//0x70      //white 0
  392.  
  393.  
  394.  
  395. /*
  396. ьрёшт їЁрэшЄ рфЁхёр тёхї юЄюсЁрцрхь√ї ёЄЁюъ т фхсрухЁх
  397. cpu.trpc[00] - 00E5
  398. cpu.trpc[01] - 00E7
  399. cpu.trpc[02] - 00E8
  400.  
  401. cpu.trpc[18] - 0109
  402. cpu.trpc[19] - 010C
  403. cpu.trpc[20] - 010F
  404.  
  405. + х∙х ёЄЁюър ё рфЁхёюь эрўрыр ёыхфє■∙хщ ёЄЁрэшЎ√
  406. cpu.trpc[21] - 0112
  407. */
  408.  
  409.  
  410. //    trace_follow_regs = 4;
  411.  
  412.  
  413. restart_showtrace:
  414.  
  415.  
  416.    
  417.  
  418.     trace_follow_regs_in_view = 0;
  419.  
  420.     Z80 &cpu = CpuMgr.Cpu();
  421. //  char line[ 40];             //Alone Coder 0.36.7
  422.     char line[ 16 + 129];       //Alone Coder 0.36.7
  423.  
  424.     cpu.trace_curs &= 0xFFFF;
  425.     cpu.trace_top &= 0xFFFF;
  426.     cpu.pc &= 0xFFFF;
  427.     cpu.trace_mode = (cpu.trace_mode + 3) % 3;
  428.  
  429.     cpu.pc_trflags = tracewndflags();
  430.     cpu.nextpc = (cpu.pc_trflags & TWF_HALTCMD)  ?  (cpu.pc_trflags & 0xFFFF):
  431.                                                     ((cpu.pc + unsigned( disasm_line( cpu.pc, line))) & 0xFFFF );
  432.     unsigned pc = cpu.trace_top;
  433.     asmii = -1U;        //ъєЁёюЁ т эх яюы  чЁхэш 
  434.    
  435. //  unsigned char atr0 = (activedbg == WNDTRACE)   ?    W_SEL : //0x17
  436. //                                                      W_NORM; //0x07
  437.  
  438.     unsigned char attr1;        //temp attr
  439.     unsigned char current_back_attr = (activedbg == WNDTRACE)  ?  DBG_ATTR_BCKGRND_ACTIVE :     //(т√фхыхээюх юъэю)
  440.                                                                   DBG_ATTR_BCKGRND;
  441.                                                                
  442.     unsigned char attr_lines = (current_back_attr | DBG_ATTR_TRACE_LINES);
  443.     unsigned char attr_lines_rom = (current_back_attr | DBG_ATTR_TRACE_LINES_ROM);
  444.     //-------------------------------------------------------------------------
  445.     unsigned ii; //Alone Coder 0.36.7
  446.     //-------------------------------------------------------------------------
  447.  
  448.     //-------------------------------------------------------------------------
  449.     for (ii = 0;    ii < trace_size;    ii++)
  450.     {
  451.         pc &= 0xFFFF;
  452.         cpu.trpc[ ii] = pc;
  453.         int len = disasm_line( pc, line);
  454.         //---------------------------------------------------------------------
  455.         char *ptr = line + strlen( line);       //тшфшью чрўшёЄър ёЄЁюъш
  456.         //---------------------------------------------------------------------
  457.         while (ptr < line + 32)
  458.             *ptr++ = ' ';
  459.         //---------------------------------------------------------------------
  460.         line[ 32] = 0;
  461.         //---------------------------------------------------------------------
  462.  
  463.  
  464.        
  465. #define FLAG_FOLLOW     0x01
  466. #define FLAG_BP_X       0x02
  467. #define FLAG_BP_R       0x04
  468. #define FLAG_BP_W       0x08
  469.  
  470. #define FLAG_PC         0x10    //+FLAG_FOLLOW
  471.  
  472.         //---------------------------------------------------------------------
  473.         //attr1 = attr_lines;
  474.  
  475.         attr1 = (bankr[ (pc >> 14) & 3] != bankw[ (pc >> 14) & 3])  ?  attr_lines_rom   :
  476.                                                                        attr_lines ;    
  477.         int temp_line_flags = 0;
  478.         //---------------------------------------------------------------------
  479.         if (pc == (cpu.pc & 0xFFFF))
  480.         {
  481.             temp_line_flags |= FLAG_PC;
  482.         }
  483.         //---------------------------------------------------------------------
  484.         int follow_regs_value;
  485.         //---------------------------------------------------------------------
  486.         switch (conf.trace_follow_regs)
  487.         {
  488.             case REG_AF:        follow_regs_value = cpu.af;     break;
  489.             case REG_BC:        follow_regs_value = cpu.bc;     break;
  490.             case REG_DE:        follow_regs_value = cpu.de;     break;
  491.             case REG_HL:        follow_regs_value = cpu.hl;     break;
  492.             case REG_AF1:       follow_regs_value = cpu.alt.af; break;
  493.             case REG_BC1:       follow_regs_value = cpu.alt.bc; break;
  494.             case REG_DE1:       follow_regs_value = cpu.alt.de; break;
  495.             case REG_HL1:       follow_regs_value = cpu.alt.hl; break;
  496.             case REG_IX:        follow_regs_value = cpu.ix;     break;
  497.             case REG_IY:        follow_regs_value = cpu.iy;     break;
  498.             case REG_SP:        follow_regs_value = cpu.sp;     break;
  499.             case REG_PC:        follow_regs_value = cpu.pc;     break;
  500.         }
  501.         //---------------------------------------------------------------------
  502.         // Єъ т ёЄрЁ°шї сшЄрї ьюцхЄ с√Є№ ыхт√щ ьєёюЁ ╨┼└╦▄═╬!!!
  503.         follow_regs_value &= 0xFFFF;   
  504.         //---------------------------------------------------------------------
  505.         // ┼ёыш ёыхфшь чр ъръшь Єю ЁхушёЄЁюь
  506.         if (conf.trace_follow_regs)
  507.         {
  508.             //-----------------------------------------------------------------
  509.             if (pc == follow_regs_value)        // r0171 fix [NS]
  510.             {
  511.                 // printf("now in view\n");
  512.                 temp_line_flags |= FLAG_FOLLOW;
  513.                 trace_follow_regs_in_view = 1;
  514.             }
  515.             //-----------------------------------------------------------------
  516.         }
  517.         //---------------------------------------------------------------------
  518.         // ┼ёыш эх ёыхфшь
  519.         else
  520.         {
  521.             // Єю фхырхь тшф ўЄю ь√ єцх тёх эр°ыш
  522.             // printf("now not in view\n");
  523.             trace_follow_regs_in_view = 1;
  524.             conf.trace_follow_request = 0;
  525.         }
  526.         //-------------------------------------------------------------------------
  527.        
  528. //      if (pc == cpu.pc) { temp_line_flags |= FLAG_PC; trace_follow_regs_in_view = 1; }
  529.        
  530.         //-------------------------------------------------------------------------
  531.         if (cpu.membits[ pc] & MEMBITS_BPX)     temp_line_flags |= FLAG_BP_X;
  532.         if (cpu.membits[ pc] & MEMBITS_BPR)     temp_line_flags |= FLAG_BP_R;
  533.         if (cpu.membits[ pc] & MEMBITS_BPW)     temp_line_flags |= FLAG_BP_W;
  534.         //---------------------------------------------------------------------
  535.         switch ((temp_line_flags & (FLAG_BP_X | FLAG_BP_R | FLAG_BP_W)))
  536.         {
  537.             //X only ----------------------------------------------------------
  538.             case (FLAG_BP_X):                           //...O
  539.                 attr1 = (attr1 & 0xF0) | DBG_ATTR_TRACE_BREAK_EX;       break;  //+ back
  540.             //RW --------------------------------------------------------------
  541.             case (FLAG_BP_R):                           //..O.
  542.                 attr1 = (attr1 & 0x0F) | DBG_ATTR_TRACE_BREAK_R_BACK;   break;  //+ ink
  543.             case (FLAG_BP_W):                           //.O..
  544.                 attr1 = (attr1 & 0x0F) | DBG_ATTR_TRACE_BREAK_W_BACK;   break;  //+ ink
  545.             case (FLAG_BP_R | FLAG_BP_W):               //.OO.
  546.                 attr1 = (attr1 & 0x0F) | DBG_ATTR_TRACE_BREAK_RW_BACK;  break;  //+ ink
  547.             //RW + X ----------------------------------------------------------
  548.             case (FLAG_BP_X | FLAG_BP_R):               //..OO
  549.                 attr1 = DBG_ATTR_TRACE_BREAK_EX | DBG_ATTR_TRACE_BREAK_R_BACK;  break;
  550.             case (FLAG_BP_X | FLAG_BP_W):               //.O.O
  551.                 attr1 = DBG_ATTR_TRACE_BREAK_EX | DBG_ATTR_TRACE_BREAK_W_BACK;  break;
  552.             case (FLAG_BP_X | FLAG_BP_R | FLAG_BP_W):   //.OOO
  553.                 attr1 = DBG_ATTR_TRACE_BREAK_EX | DBG_ATTR_TRACE_BREAK_RW_BACK; break;
  554.         }
  555.         //---------------------------------------------------------------------
  556.         switch ((temp_line_flags & (FLAG_BP_X | FLAG_PC | FLAG_FOLLOW)))
  557.         {
  558.             //Follow яютхЁx PC  -----------------------------------------------
  559.             case (FLAG_FOLLOW):                        
  560.             case (FLAG_FOLLOW | FLAG_PC):              
  561.                 attr1 = DBG_ATTR_TRACE_REG_FOLLOW_BACK;
  562.                 break;
  563.             //Follow яютхЁї PC + X --------------------------------------------
  564.             case (FLAG_BP_X | FLAG_FOLLOW):                            
  565.             case (FLAG_BP_X | FLAG_FOLLOW | FLAG_PC):          
  566.                 attr1 = DBG_ATTR_TRACE_REG_FOLLOW_BACK | DBG_ATTR_TRACE_BREAK_EX;
  567.                 break;
  568.             //PC --------------------------------------------------------------
  569.             case (FLAG_PC):    
  570.                 attr1 = DBG_ATTR_TRACE_REG_PC_BACK;
  571.                 break;         
  572.             //PC + X ----------------------------------------------------------
  573.             case (FLAG_PC | FLAG_BP_X):        
  574.                 attr1 = DBG_ATTR_TRACE_REG_PC_BACK | DBG_ATTR_TRACE_BREAK_EX;
  575.                 break;
  576.             //-----------------------------------------------------------------
  577.         }
  578.         //---------------------------------------------------------------------
  579.            
  580.  
  581.                
  582.  
  583. //      //---------------------------------------------------------------------
  584. //      // рЄЁшсєЄ ёЄЁюъш ё (Єхъє∙шь PC) / (юс√ўэр  ёЄЁюър)
  585. //      attr1 = (pc == cpu.pc)  ?       DBG_ATTR_TRACE_REG_PC_BACK :    //W_TRACEPOS : 
  586. //                                      attr_lines;                     //atr0;
  587. //      //---------------------------------------------------------------------
  588.  
  589.  
  590. //      // рЄЁшсєЄ тёхщ ёЄЁюъш ё сЁ ъюь
  591. //      //                                      Єръ цх яюЄюь ьюцэю сєфхЄ юЄюсЁрцрЄ№ Ёрчэ√х тшф√ сЁ ъют
  592. //      //                                      Ёрчэ√ьш ЎтхЄрьш
  593. //
  594. //      if (cpu.membits[pc] & MEMBITS_BPX)      //EX
  595. //      {
  596. //              attr1 = (attr1 & 0xF0) | DBG_ATTR_TRACE_BREAK_EX;       // + back
  597. //      }
  598.  
  599.  
  600.  
  601.         //---------------------------------------------------------------------
  602.         //#ifdef MOD_NEW_LABELS
  603.         if ((trace_labels) && (conf.Disasm_New_Labels))
  604.         {
  605.             char labels_line[ 16 + 129];
  606.             //-----------------------------------------------------------------
  607.             // ╩╬╤╥█╦▄ Єъ яюър уы■ъш ё юЄЁшёютъющ яхЁтющ ш яюёыхфэхщ ёЄЁюъш
  608.             if (ii >= (trace_size - 1))
  609.                 goto mod_new_labels_skip_2;    
  610.             //-----------------------------------------------------------------
  611.             if (get_labels( pc, labels_line))
  612.             {
  613.                 tprint( trace_x,
  614.                         (trace_y + ii),
  615.                         labels_line,
  616.                         ((current_back_attr & 0xF0) | 0x0E)     //F)
  617.                         );
  618.                                
  619.                     //trace_y_displace++;
  620.                     //trace_size_1--;
  621.                 ii++;
  622.                 //-------------------------------------------------------------
  623.                 //if (ii >= (trace_size-1))
  624.                 //if (ii == (trace_size))
  625.                 //    goto mod_new_labels_skip;
  626.                 //-------------------------------------------------------------
  627.                 cpu.trpc[ ii] = pc;
  628.             }
  629.             //-----------------------------------------------------------------    
  630.         //#endif
  631.         }
  632.         //---------------------------------------------------------------------
  633.        
  634. mod_new_labels_skip_2: 
  635.        
  636.         //---------------------------------------------------------------------
  637.         tprint(         trace_x,
  638.                         (trace_y + ii),         //trace_y + ii,
  639.                         line,
  640.                         attr1
  641.                );
  642.                
  643. mod_new_labels_skip:
  644.  
  645.         //---------------------------------------------------------------------
  646.         // т√фхыхэшх яюыюцхэш  ъєЁёюЁр т юъэх фшчрёьр
  647.         // ═┼ ═└ ┬╤▐ ╤╥╨╬╩╙! р Єюы№ъю т ръЄштэюь ёЄюысЎх
  648.         if (pc == cpu.trace_curs)
  649.         {
  650.             asmii = ii;                         // єёЄрэютър "ъєЁёюЁр яю Ёхры№эюьє яюыюцхэш■
  651.             cpu.graph_trace_cursor_pos = ii;    // [NS]
  652.             //-----------------------------------------------------------------
  653.             if (activedbg == WNDTRACE)
  654.             {
  655.                 //-------------------------------------------------------------
  656.                 for (unsigned q = 0;    q < cs[ cpu.trace_mode][ 1];    q++)
  657.                 {
  658.                     txtscr[     s80 * s30               +
  659.                                 (trace_y + ii) * s80    +
  660.                                 trace_x                 +
  661.                                 cs[ cpu.trace_mode][ 0] +
  662.                                 q
  663.                            ] = (DBG_ATTR_TRACE_SELECTED);       //W_CURS;
  664.                 }
  665.                 //-------------------------------------------------------------
  666.             }
  667.             //-----------------------------------------------------------------
  668.         }
  669.         //---------------------------------------------------------------------
  670.         if (cpu.pc_trflags & TWF_BRANCH)
  671.         {
  672.             //-----------------------------------------------------------------
  673.             if (pc == cpu.pc)
  674.             {
  675.                 unsigned addr = cpu.pc_trflags & 0xFFFF;
  676.                 //-------------------------------------------------------------
  677.                 // ёшьтюы ёЄЁхыюўъш эряЁртыхэш  яхЁхїюфр
  678.                 unsigned arr = (addr <= cpu.pc)  ?  0x18 :
  679.                                                     0x19;       // up/down arrow
  680.                 attr1 = (       (pc == cpu.trace_curs)  &&
  681.                                 (activedbg == WNDTRACE) &&
  682.                                 (cpu.trace_mode == 2)
  683.                          )  
  684.                             ?   // ёЄЁхыюўър эряЁртыхэш  яхЁхїюфр яюф ъєЁёюЁюь
  685.                                 DBG_ATTR_TRACE_BRANCH_DIRECTION_INV :   //W_TRACE_JINFO_CURS_FG :  // 0x0D 0 br+CYAN
  686.                                 // ёЄЁхыюўър эряЁртыхэш 
  687.                                 DBG_ATTR_TRACE_BRANCH_DIRECTION;        //W_TRACE_JINFO_NOCURS_FG; // 0x02 0 red       
  688.                 //-------------------------------------------------------------
  689.                 // юЄЁшёютър ёЄЁхыюўър эряЁртыхэш  яхЁхїюфр ттхЁї/тэшч     
  690.                 if (cpu.pc_trflags & TWF_BRADDR)
  691.                 {
  692.                     sprintf(    line,
  693.                                 "%04X%c",
  694.                                 addr,
  695.                                 int( arr)
  696.                             );
  697.                 // рфЁхё + ёЄЁхыюўър яЁш RET    (5B13 C9 ret   0038^)
  698.                     tprint_fg(  trace_x + 32 - 5,
  699.                                 trace_y + ii,
  700.                                 line,
  701.                                 attr1   //ink only      //color
  702.                               );
  703.                 }
  704.                 //-------------------------------------------------------------
  705.                 else
  706.                 {
  707.                 // ёЄЁхыюўър яЁш JP CALL        (0043 2003 jr nz,0048   v)
  708.                     tprint_fg(  trace_x + 32 - 1,
  709.                                 trace_y + ii,
  710.                                 (char*) &arr,
  711.                                 attr1   //ink only      //color
  712.                               );
  713.                 }
  714.              }
  715.             //-----------------------------------------------------------------
  716.             // ёЄЁхыюўър тючых рфЁхёр ъєфр яЁюшёїюфшЄ яхЁхїюф   (5B00 F5 push af   <)
  717.             if (pc == (cpu.pc_trflags & 0xFFFF))
  718.             {
  719.                 unsigned arr = 0x11; // left arrow
  720.                 tprint_fg(      trace_x + 32 - 1,
  721.                                 trace_y + ii,
  722.                                 (char*) &arr,
  723.                                 DBG_ATTR_TRACE_BRANCH_DESTINATION       //W_TRACE_JARROW_FOREGR //0x0D  br+CYAN
  724.                           );
  725.             }
  726.             //-----------------------------------------------------------------
  727.         }
  728.         //---------------------------------------------------------------------
  729.         pc += unsigned( len);
  730.     } // for (ii = 0;    ii < trace_size;    ii++)
  731.     //-------------------------------------------------------------------------
  732.    
  733.    
  734.     //-------------------------------------------------------------------------
  735.     cpu.trpc[ ii] = pc;         // юсэюты хь ьрёшт рфЁхёют
  736.     //-------------------------------------------------------------------------
  737.  
  738.  
  739.        
  740.     //-------------------------------------------------------------------------
  741.     // эр тё ъшщ
  742.     cpu.trace_top &= 0xFFFF;    // [NS]
  743.     cpu.trace_curs &= 0xFFFF;
  744.     //-------------------------------------------------------------------------                
  745.     if (conf.trace_follow_request)                                      // [NS]
  746.     {
  747.         //printf("trace_follow_request \n");
  748.         //---------------------------------------------------------------------
  749.         if ((!trace_follow_regs_in_view) && (conf.trace_follow_regs))
  750.         {
  751.             //printf("(!trace_PC_in_view)\n");
  752.             //-----------------------------------------------------------------
  753.             switch (conf.trace_follow_regs)
  754.             {
  755.                 case REG_AF:  cpu.trace_top = cpu.trace_curs = cpu.af;          break;
  756.                 case REG_BC:  cpu.trace_top = cpu.trace_curs = cpu.bc;          break;
  757.                 case REG_DE:  cpu.trace_top = cpu.trace_curs = cpu.de;          break;
  758.                 case REG_HL:  cpu.trace_top = cpu.trace_curs = cpu.hl;          break;
  759.                 case REG_AF1: cpu.trace_top = cpu.trace_curs = cpu.alt.af;      break;
  760.                 case REG_BC1: cpu.trace_top = cpu.trace_curs = cpu.alt.bc;      break;
  761.                 case REG_DE1: cpu.trace_top = cpu.trace_curs = cpu.alt.de;      break;
  762.                 case REG_HL1: cpu.trace_top = cpu.trace_curs = cpu.alt.hl;      break;
  763.                 case REG_IX:  cpu.trace_top = cpu.trace_curs = cpu.ix;          break;
  764.                 case REG_IY:  cpu.trace_top = cpu.trace_curs = cpu.iy;          break;
  765.                 case REG_SP:  cpu.trace_top = cpu.trace_curs = cpu.sp;          break;
  766.                 case REG_PC:  cpu.trace_top = cpu.trace_curs = cpu.pc;          break;
  767.             }
  768.             //-----------------------------------------------------------------
  769.             //cpu.trace_top = cpu.trace_curs = cpu.pc;
  770.             //printf("restart_showtrace ");
  771.             // хёыш эх эр°ыш Єюую чр ўхь ёыхфшь
  772.             goto restart_showtrace;
  773.         }
  774.         //---------------------------------------------------------------------
  775.         // хёыш эх чрўхь эх ёыхфшь Єю ёэшьрхь ЁхътхёЄ
  776.         else
  777.         {
  778.             //printf("trace_follow_request = 0;");
  779.             conf.trace_follow_request = 0;
  780.         }
  781.     }
  782.     //-------------------------------------------------------------------------
  783.     // KєЁёюЁ яюёЁхфш ъюьрэф√ !!!                       // [NS]
  784.     // шыш page down
  785.     if (asmii == -1U)                          
  786.     {
  787.         // printf("(asmii == -1U) ");
  788.         // яхЁхёЄрты хь тхЁї эр яюыюцхэшх ъєЁёюЁр ш фшчрёьшь х∙х Ёрч
  789.        
  790.         //---------------------------------------------------------------------
  791.         // Page down -> ь√ фхЄхъЄшь яю эрїюцфхэш■ т яюёыхфэхщ ёЄЁюъх
  792.         //      эю яюьюхьє ¤Єю т√ч√трхЄ эхъюЄюЁ√х уы■ъш (ъръшх?)        2do !!!!!
  793.         if (cpu.graph_trace_cursor_pos == (trace_size - 1))
  794.         {
  795.             cpu.trace_curs = cpu.trpc[ cpu.graph_trace_cursor_pos];
  796.         }
  797.         //---------------------------------------------------------------------
  798.         // ╩єЁёюЁ яюёЁхфш ъюьрэф√
  799.         // Єхъє∙шьш ёЁхфёЄтрьш ьюцхь юЄфшчрёьшЄ№ Єюы№ъю ъюуфр юэю т trace_top
  800.         //      эєцэю яЁртшЄ№ фшчрёьхЁ фы  юсЁрсюЄъш ъєЁёюЁр яюёЁхфш ъюьрэф√
  801.         else
  802.         {
  803.             cpu.graph_trace_cursor_pos = 0;
  804.             cpu.trace_top = cpu.trace_curs;     //cpu.trpc[0]; 
  805.             //cpu.trace_curs = cpu.trpc[0];
  806.         }
  807.         //---------------------------------------------------------------------
  808.         //printf("restart_showtrace 2");
  809.         goto restart_showtrace;
  810.     }
  811.     //-------------------------------------------------------------------------
  812.    
  813.  
  814.  
  815.     unsigned char dbuf[16];
  816.     //-------------------------------------------------------------------------
  817.     unsigned i; //Alone Coder
  818.     //-------------------------------------------------------------------------
  819.     for (/*int*/ i = 0;    i < 16;    i++)
  820.         dbuf[i] = cpu.DirectRm( cpu.trace_curs + i);
  821.     //-------------------------------------------------------------------------
  822.     ptrdiff_t len = disasm(     dbuf,
  823.                                 cpu.trace_curs,
  824.                                 0
  825.                            ) - dbuf;
  826.     strcpy( asmpc, asmbuf);
  827.  
  828.     //-------------------------------------------------------------------------
  829.     // юяъюф√ ъюьрэф т Ёхцшьх ЁхфръЄшЁютрэш 
  830.     for (/*int*/ i = 0;    i < len && i < 5;    i++)
  831.         sprintf(        dumppc + i * 2,
  832.                         "%02X",
  833.                         cpu.DirectRm(cpu.trace_curs + i)
  834.                 );
  835.     //-------------------------------------------------------------------------
  836.     // яхўрЄ№ Єхъє∙хую z80
  837.     char cpu_num[ 10];
  838. //    _snprintf(        cpu_num,
  839. //                      sizeof( cpu_num),
  840. //                      "Z80(%u)",
  841. //                      CpuMgr.GetCurrentCpu()
  842. //              );
  843.     //-------------------------------------------------------------------------
  844.     if ( (CpuMgr.GetCurrentCpu()) == 0 )        // [NS]
  845.     {
  846.         sprintf( cpu_num, "ZX-CPU" );//"ZX-Z80" );      //╚ чрўхь эрь эєцэю с√ыю єурф√трЄ№ уфх ь√ ∙рё?
  847.     }
  848.     //-------------------------------------------------------------------------
  849.     else
  850.     {
  851.         sprintf( cpu_num, "GS-CPU" );//"GS-Z80" );
  852.     }
  853.     //-------------------------------------------------------------------------
  854.              
  855.     tprint(     trace_x,
  856.                 trace_y - 1,
  857.                 cpu_num,
  858.                 DBG_ATTR_TRACE_CURRENT_Z80      //W_TITLE
  859.            );
  860.     //-------------------------------------------------------------------------
  861.     // яхўрЄ№ рфЁхёр яюёыхфэхую яхЁхїюфр
  862.     char lbr[ 18];                      //lbr[5];
  863.     _snprintf(  lbr,
  864.                 sizeof( lbr),
  865.                 "Last Branch(%04hX)",   //"%04hX",
  866.                 cpu.last_branch
  867.               );
  868.     tprint(     trace_x + 8,
  869.                 trace_y - 1,
  870.                 lbr,
  871.                 DBG_ATTR_TRACE_LAST_BRANCH      //W_TITLE
  872.           );
  873. //    //-------------------------------------------------------------------------
  874. //    // Ёрьюўър ═┼═╙╞═└
  875. //    frame(    trace_x,
  876. //              trace_y,
  877. //              32,
  878. //              trace_size,
  879. //              FRAME
  880. //       );
  881. //    //-------------------------------------------------------------------------
  882.    
  883. } //void showtrace()
  884. //=============================================================================
  885.  
  886.  
  887. //=============================================================================
  888. void c_lbl_import() //menu for importing labels from XAS/ALASM ???      // т ьхэ■ WNDTRACE фхсрухЁр
  889. {                                                                       // ш "cpu.importl" їюЄъхщ
  890.     mon_labels.import_menu();                                           // ёъюЁхщ тёхую єцх ёыюьрэ?
  891. }
  892. //=============================================================================
  893.  
  894.       /* ------------------------------------------------------------- */
  895. static unsigned save_pos[ 8] = { -1U,-1U,-1U,-1U,-1U,-1U,-1U,-1U };
  896. static unsigned save_cur[ 8] = { -1U,-1U,-1U,-1U,-1U,-1U,-1U,-1U };
  897. static unsigned stack_pos[ 1024] = { -1U };     // 32] = { -1U }; 1╩ їтрЄшЄ тёхь [NS]
  898. static unsigned stack_cur[ 1024] = { -1U };     // 32] = { -1U };
  899.  
  900. //=============================================================================
  901. void push_pos();                                                        //????
  902. void push_pos()
  903. {
  904.     Z80 &cpu = CpuMgr.Cpu();
  905.     memmove( &stack_pos[ 1], &stack_pos[ 0], sizeof stack_pos - sizeof *stack_pos);
  906.     memmove( &stack_cur[ 1], &stack_cur[ 0], sizeof stack_cur - sizeof *stack_cur);
  907.     stack_pos[ 0] = cpu.trace_top;
  908.     stack_cur[ 0] = cpu.trace_curs;
  909. }
  910. //=============================================================================
  911.  
  912.  
  913. //=============================================================================
  914. // ╧юыєўхэшх рфЁхёр яЁхф√фє∙хщ ъюьрэф√
  915. //    їч ъръ юэю ЁрсюЄрхЄ ш эр ёъюы№ъю Єюўэю
  916. static unsigned cpu_up( unsigned ip)
  917. {
  918.     Z80 &cpu = CpuMgr.Cpu();
  919.     //printf("ip = %X\n",ip);
  920.     unsigned char buf1[ 0x10];
  921.     unsigned p1 = (ip > sizeof buf1)  ?  ip - sizeof buf1 :
  922.                                          0;
  923.     //-------------------------------------------------------------------------
  924.     for (unsigned i = 0;    i < sizeof buf1;    i++)
  925.         buf1[ i] = cpu.DirectRm( p1 + i);
  926.     //-------------------------------------------------------------------------
  927.     const unsigned char *dispos = buf1;
  928.     const unsigned char *prev;
  929.     //-------------------------------------------------------------------------
  930.     do {
  931.         prev = dispos;
  932.         dispos = disasm( dispos, 0, 0);
  933.     } while ((unsigned)( dispos - buf1 + p1) < ip);
  934.     //-------------------------------------------------------------------------
  935.     return unsigned( prev - buf1 + p1);
  936. }
  937. //=============================================================================
  938.  
  939.  
  940.  
  941.  
  942. //=============================================================================
  943. // єёЄрЁхт°шщ goto adress т юъэх фшчрёьр                // "cpu.goto" їюЄхъхщ
  944. // Єръющ цх ъръ т юъэх ьхьюЁш тшхтхЁр
  945. // цьхь ъэюяъє, ттюфшь рфЁхё Ёєўърьш
  946. void cgoto()                                           
  947. {
  948.     Z80 &cpu = CpuMgr.Cpu();
  949.     int v = input4( trace_x, trace_y, cpu.trace_top);
  950.     //-------------------------------------------------------------------------
  951.     if (v != -1)
  952.         cpu.trace_top = cpu.trace_curs = unsigned( v);
  953.     //-------------------------------------------------------------------------
  954. }
  955. //=============================================================================
  956.  
  957.  
  958. //=============================================================================
  959. // SET_PC_TO_CURSOR                                     // т ьхэ■ WNDTRACE фхсрухЁр
  960. void csetpc()                                           // ш "cpu.setpc" їюЄъхщ
  961. {
  962.     Z80 &cpu = CpuMgr.Cpu();
  963.     cpu.pc = cpu.trace_curs;
  964. }
  965. //=============================================================================
  966.  
  967.  
  968. //=============================================================================
  969. void center()   // edit instruction ???
  970. {                                                       //"cpu.asm" їюЄъхщ
  971.     //-------------------------------------------------------------------------
  972.     // эхы№ч  ЁхфръЄшЁютрЄ№ ъюуфр ъєЁёюЁ эх эрщфхэ !!!!
  973.     // (яюёЁхфш ъюьрэф√) эєцэю ЁхфшчрёьшЄ№
  974.     if (asmii == -1U)
  975.     {
  976.         printf("asmii/trace cursor error\n");
  977.         return;
  978.     }
  979.     //-------------------------------------------------------------------------
  980.     Z80 &cpu = CpuMgr.Cpu();
  981.     //-------------------------------------------------------------------------
  982.     // addr
  983.     if (!cpu.trace_mode) // = 0
  984.         sprintf(        str,
  985.                         "%04X",
  986.                         cpu.trace_curs
  987.                 );
  988.     //-------------------------------------------------------------------------
  989.     // dump
  990.     else if (cpu.trace_mode == 1)
  991.         strcpy( str, dumppc);
  992.     //-------------------------------------------------------------------------
  993.     // disasm
  994.     else
  995.         strcpy( str, asmpc);
  996.     //-------------------------------------------------------------------------
  997.     // т ёыєўрх тїюфр т Ёхцшь ЁхфръЄшЁютрэш  эрўрыюь ттюфр ЄхъёЄр
  998.     // шфхЄ юўшёЄър тёхщ ёЄЁюъш
  999.     //    ═╬ center ьюцхЄ с√Є№ эх Єюы№ъю эр Enter-e !!!!!
  1000.     //    эєцэр яЁютхЁър шьхээю эр center hotkey
  1001.     //    шэрўх эхы№ч  яхЁхэрчэрўшЄ№ center !!!!! [NS]
  1002.     if (input.lastkey != VK_RETURN)
  1003.     {
  1004.         //---------------------------------------------------------------------
  1005.         // яЁ ьющ ттюф чэрўхэшщ т ёЄюысЎх рфЁхёр эх юўш∙рхЄ ёЄЁюъє рфЁхёр
  1006.         if (cpu.trace_mode != 0) // addr
  1007.         {
  1008.             *str = 0;
  1009.         }
  1010.         //---------------------------------------------------------------------
  1011.         // °ы яр - є∙хЁсэ√щ ттюф чэрўхэш  ъюЄюЁ√ь ь√ тю°ыш т Ёхцшь ЁхфръЄшЁютрэш 
  1012.         PostThreadMessage(      GetCurrentThreadId(),
  1013.                                 WM_KEYDOWN,
  1014.                                 input.lastkey,
  1015.                                 1
  1016.                         );
  1017.     }
  1018.     //-------------------------------------------------------------------------
  1019.     for (    ;    ;    )
  1020.     {
  1021.         //---------------------------------------------------------------------
  1022.         // asmii ъръ Ёрч Єшяю Єхъє∙шщ ъєЁёюЁ
  1023.        
  1024.         if (!inputhex(  (trace_x + cs[ cpu.trace_mode][ 0]),
  1025.                         (trace_y + trcurs_y + asmii),           //trcurs_y тююс∙х эх шёяюы№чєхЄёю
  1026.                         (cs[ cpu.trace_mode][ 1]),
  1027.                         (cpu.trace_mode < 2),           //0...1 - hex=TRUE 2 - hex=FALSE
  1028.                         (cpu.trace_mode == 2) ? FALSE : //ы■фёъющ ёяюёюс ттюфр ЄхъёЄр
  1029.                                                 TRUE    //hex-√ цх єфюсэю ттюфшЄ№ insert-юь
  1030.                       )
  1031.          )
  1032.         {
  1033.             break;
  1034.         }
  1035.         //---------------------------------------------------------------------
  1036.         // addr
  1037.         if (!cpu.trace_mode)
  1038.         {
  1039.             push_pos();
  1040.             sscanf(     str,
  1041.                         "%X",
  1042.                         &cpu.trace_top
  1043.                    );
  1044.             cpu.trace_curs = cpu.trace_top;
  1045.             //-----------------------------------------------------------------
  1046.             //printf("asmii %d ",asmii);
  1047.             for (unsigned i = 0;    i < asmii;    i++)
  1048.             {
  1049.                 //printf("** ");
  1050.                 cpu.trace_top = cpu_up(cpu.trace_top);
  1051.             }
  1052.             //printf("\n");
  1053.             //-----------------------------------------------------------------
  1054.             break;
  1055.         }
  1056.         //---------------------------------------------------------------------
  1057.         // dump
  1058.         else if (cpu.trace_mode == 1)
  1059.         {
  1060.             char *p; //Alone Coder 0.36.7
  1061.             //-----------------------------------------------------------------
  1062.             for (/*char * */p = str + strlen(str) - 1;    p >= str && *p == ' ';    *p-- = 0);
  1063.             //-----------------------------------------------------------------
  1064.             unsigned char dump[8];
  1065.             unsigned i;
  1066.             //-----------------------------------------------------------------
  1067.             for (p = str, i = 0;    ishex( *p) && ishex( p[ 1]);    p += 2)
  1068.                 dump[i++] = hex(p);
  1069.             //-----------------------------------------------------------------
  1070.             if (*p)
  1071.                 continue;
  1072.             //-----------------------------------------------------------------
  1073.             for (unsigned j = 0;    j < i;    j++)
  1074.                 cpu.DirectWm( cpu.trace_curs + j, dump[ j]);
  1075.             //-----------------------------------------------------------------
  1076.             break;
  1077.         }
  1078.         //---------------------------------------------------------------------
  1079.         // disasm
  1080.         else
  1081.         {
  1082.             unsigned sz = assemble_cmd( (unsigned char*) str, cpu.trace_curs);
  1083.             //-----------------------------------------------------------------
  1084.             if (sz)
  1085.             {
  1086.                 //-------------------------------------------------------------
  1087.                 for (unsigned i = 0;    i < sz;    i++)
  1088.                     cpu.DirectWm( cpu.trace_curs + i, asmresult[ i]);
  1089.                 //-------------------------------------------------------------
  1090.                 showtrace();
  1091.                 void cdown();
  1092.                 cdown();
  1093.                 break;
  1094.             }
  1095.             //-----------------------------------------------------------------
  1096.         }
  1097.     }
  1098. }
  1099. //=============================================================================
  1100.  
  1101.  
  1102. //=============================================================================
  1103. char dispatch_trace()                           //????
  1104. {
  1105.     //printf("dispatch_trace %c\n",input.lastkey);
  1106.     //-------------------------------------------------------------------------
  1107.     if ( (input.lastkey >= '0' && input.lastkey <= '9') ||      // [NS] ттюф ЎшЇЁ цю Єюц√ эєцхэ т юъэх фшчрёьр
  1108.          (input.lastkey >= 'A' && input.lastkey <= 'Z')
  1109.      )
  1110.     {
  1111.         center();
  1112.         return 1;
  1113.     }
  1114.     //-------------------------------------------------------------------------
  1115.     return 0;
  1116. }
  1117. //=============================================================================
  1118.  
  1119.  
  1120. //=============================================================================
  1121. // FIND TEXT т юъэх фшчрёьр                     // т ьхэ■ WNDTRACE фхсрухЁр
  1122. void cfindtext()                                // ш "cpu.findtext" їюЄъхщ
  1123. {
  1124.     Z80 &cpu = CpuMgr.Cpu();
  1125.     unsigned char oldmode = editor;
  1126.     editor = ED_MEM;
  1127.     int rs = find1dlg( cpu.trace_curs);
  1128.     editor = oldmode;
  1129.     //-------------------------------------------------------------------------
  1130.     if (rs != -1)
  1131.         cpu.trace_top = cpu.trace_curs = unsigned( rs);
  1132.     //-------------------------------------------------------------------------
  1133. }
  1134. //=============================================================================
  1135. // FIND CODE т юъэх фшчрёьр                     // т ьхэ■ WNDTRACE фхсрухЁр
  1136. void cfindcode()                                // ш "cpu.findcode" їюЄъхщ
  1137. {
  1138.     Z80 &cpu = CpuMgr.Cpu();
  1139.     unsigned char oldmode = editor;
  1140.     editor = ED_MEM;
  1141.     int rs = find2dlg( cpu.trace_curs);
  1142.     editor = oldmode;
  1143.     //-------------------------------------------------------------------------
  1144.     if (rs != -1)
  1145.         cpu.trace_top = cpu.trace_curs = unsigned( rs);
  1146.     //-------------------------------------------------------------------------
  1147. }
  1148. //=============================================================================
  1149.  
  1150.  
  1151. //=============================================================================
  1152. // set breakpoint                               // т ьхэ■ WNDTRACE фхсрухЁр
  1153. void cbpx()                                     // ш "cpu.bpx" їюЄъхщ
  1154. {                      
  1155.     Z80 &cpu = CpuMgr.Cpu();
  1156.     cpu.membits[ cpu.trace_curs] ^= MEMBITS_BPX;
  1157. }
  1158. //=============================================================================v
  1159. void cbpr()                                     // т ьхэ■ WNDTRACE фхсрухЁр
  1160. {                                               // [NS]
  1161.     Z80 &cpu = CpuMgr.Cpu();                   
  1162.     cpu.membits[ cpu.trace_curs] ^= MEMBITS_BPR;
  1163. }
  1164. //=============================================================================
  1165. void cbpw()                                     // т ьхэ■ WNDTRACE фхсрухЁр
  1166. {                                               // [NS]
  1167.     Z80 &cpu = CpuMgr.Cpu();                   
  1168.     cpu.membits[ cpu.trace_curs] ^= MEMBITS_BPW;
  1169. }
  1170. //=============================================================================
  1171.  
  1172.  
  1173.  
  1174.  
  1175.  
  1176.  
  1177. //=============================================================================
  1178. // GOTO PC                                      // т ьхэ■ WNDTRACE фхсрухЁр
  1179. void cfindpc()                                  // ш "cpu.findpc" їюЄъхщ
  1180. {
  1181.     //printf("cfindpc\n");
  1182.     Z80 &cpu = CpuMgr.Cpu();
  1183.     cpu.trace_top = cpu.trace_curs = cpu.pc;
  1184.    
  1185. //    cup();    ш фрцх Єрър  ъюэёЄЁєъЎш  эх ЁрсюЄрЄхЄ
  1186. //    cup();    їюЄ  эх ЁрсюЄрхЄ Єюы№ъю эр Ўхяюўъх ЁрчэюўшЄрхь√ї юяъюфют?
  1187. //    cup();
  1188. //    cup();
  1189. //    cup();
  1190. //    cpu.trace_curs = cpu.pc;
  1191.                                         //эюЁьры№эю юЄёЄєяшЄ№ ё чрярёюь эх яюыєўрхЄёю
  1192.                                         //эрўры№э√щ рфЁхё ьюцхЄ яюярёЄ№ эр яюы ъюьрэф√
  1193.                                         //ш ш Єюуфр рфЁхё Єхъє∙хую PC эх юЄюсЁрчшЄёю
  1194. }
  1195. //=============================================================================
  1196.  
  1197.  
  1198.  
  1199. //=============================================================================
  1200. // яхЁхїюф ъ рфЁхёє т юъэх фшчрёьр                                      // [NS]
  1201. //    шч юъэр фшчрёьр
  1202.  
  1203. void mon_goto_disasm_addr( unsigned addr)                              
  1204. {
  1205. //  unsigned addr = cpu.af;
  1206.     addr &= 0xFFFF;                     // юсЁхчър Єъ ьюцхЄ с√Є№ Їшуэ  т√°ю
  1207.     Z80 &cpu = CpuMgr.Cpu();
  1208.     cpu.trace_top = cpu.trace_curs = addr;
  1209. }
  1210.  
  1211. void mon_goto_disasm_rAF()      { Z80 &cpu = CpuMgr.Cpu();      mon_goto_disasm_addr( cpu.af);  }
  1212. void mon_goto_disasm_rBC()      { Z80 &cpu = CpuMgr.Cpu();      mon_goto_disasm_addr( cpu.bc);  }
  1213. void mon_goto_disasm_rDE()      { Z80 &cpu = CpuMgr.Cpu();      mon_goto_disasm_addr( cpu.de);  }
  1214. void mon_goto_disasm_rHL()      { Z80 &cpu = CpuMgr.Cpu();      mon_goto_disasm_addr( cpu.hl);  }
  1215.                                  
  1216. void mon_goto_disasm_rAF1()     { Z80 &cpu = CpuMgr.Cpu();      mon_goto_disasm_addr( cpu.alt.af);      }
  1217. void mon_goto_disasm_rBC1()     { Z80 &cpu = CpuMgr.Cpu();      mon_goto_disasm_addr( cpu.alt.bc);      }
  1218. void mon_goto_disasm_rDE1()     { Z80 &cpu = CpuMgr.Cpu();      mon_goto_disasm_addr( cpu.alt.de);      }
  1219. void mon_goto_disasm_rHL1()     { Z80 &cpu = CpuMgr.Cpu();      mon_goto_disasm_addr( cpu.alt.hl);      }
  1220.                                  
  1221. void mon_goto_disasm_rIX()      { Z80 &cpu = CpuMgr.Cpu();      mon_goto_disasm_addr( cpu.ix);  }
  1222. void mon_goto_disasm_rIY()      { Z80 &cpu = CpuMgr.Cpu();      mon_goto_disasm_addr( cpu.iy);  }
  1223.  
  1224. void mon_goto_disasm_rSP()      { Z80 &cpu = CpuMgr.Cpu();      mon_goto_disasm_addr( cpu.sp);  }
  1225. void mon_goto_disasm_rPC()      { Z80 &cpu = CpuMgr.Cpu();      mon_goto_disasm_addr( cpu.pc);  }
  1226.  
  1227. //=============================================================================
  1228.  
  1229.  
  1230. //=============================================================================
  1231. // move cursor up (тшфшью т юъэх фшчрёьр)                       //"cpu.up" їюЄъхщ
  1232. void cup()                                     
  1233. {
  1234.     Z80 &cpu = CpuMgr.Cpu();
  1235.     //-------------------------------------------------------------------------
  1236.     // яЁюёЄющ яхЁхїюф т ёхЁхфшэх ¤ъЁрэр
  1237.     if (cpu.graph_trace_cursor_pos > 0)
  1238.     {
  1239.         // printf("simple\n");
  1240.         int prev_cpu_trace_curs = cpu.trpc[ cpu.graph_trace_cursor_pos];
  1241.         cpu.graph_trace_cursor_pos--;
  1242.         cpu.trace_curs = cpu.trpc[ cpu.graph_trace_cursor_pos];
  1243.                
  1244.         //---------------------------------------------------------------------
  1245.         // ╧хЁхїюф ўхЁхч ьхЄъє юЄфхы№эющ ёЄЁюъющ (фтющэющ рфЁхё)        [NS]
  1246.         if (prev_cpu_trace_curs == cpu.trace_curs)
  1247.         {
  1248.             // printf("  double\n");
  1249.             //-----------------------------------------------------------------
  1250.             // яхЁхїюф шч ёхЁхфшэ√ ёЄЁюъш
  1251.             if (cpu.graph_trace_cursor_pos > 0)
  1252.             {
  1253.                 // printf("    cursor > 0\n");
  1254.                 cpu.graph_trace_cursor_pos--;
  1255.                 cpu.trace_curs = cpu.trpc[ cpu.graph_trace_cursor_pos];
  1256.             }
  1257.             //-----------------------------------------------------------------
  1258.             else
  1259.             {
  1260.                 // printf("    cursor == 0\n");
  1261.                 // printf("      %x\n",cpu.trace_top);
  1262.                 //-------------------------------------------------------------
  1263.                 // ╧хЁхїюф ўхЁхч уЁрэшЎє FFFF-0000 (ъюуфр 0000 ё ьхЄъющ)
  1264.                 if (cpu.trace_top == 0x0000)
  1265.                 {
  1266.                     cpu.trace_top = cpu.trace_curs = cpu_up( 0x10000);
  1267.                 }
  1268.                 //-------------------------------------------------------------
  1269.                 // ╧хЁхїюф ъюуфр т ёрьюь тхЁїє ¤ъЁрэр рфЁхё ё ьхЄъющ
  1270.                 else
  1271.                 {
  1272.                     cpu.trace_top = cpu.trace_curs = cpu_up( cpu.trace_top);
  1273.                 }
  1274.                 //-------------------------------------------------------------
  1275.             }
  1276.             //-----------------------------------------------------------------
  1277.         }
  1278.         //---------------------------------------------------------------------
  1279.     }  
  1280.     //-------------------------------------------------------------------------
  1281.     // ёъЁюыы ¤ъЁрэр Єюы№ъю ё ёрьющ тхЁїэхщ яючшЎшш
  1282.     else
  1283.     {
  1284.         // printf("scroll\n");
  1285.         //---------------------------------------------------------------------
  1286.         // ╧ЁюёЄющ яхЁхїюф
  1287.         if (cpu.trace_top > 0x0000)
  1288.         {
  1289.             // printf("  trace_top > 0\n");
  1290.             cpu.trace_top = cpu.trace_curs = cpu_up( cpu.trace_top);
  1291.         }
  1292.         //---------------------------------------------------------------------
  1293.         // ╧хЁхїюф ё 0x0000 ъ 0xFFFF
  1294.         else
  1295.         {
  1296.             // printf("  trace_top < 0\n");
  1297.         //  cpu.trace_top = cpu.trace_curs = 0xFFFF;
  1298.             cpu.trace_top = cpu.trace_curs = cpu_up( 0x10000);
  1299.         }
  1300.         //---------------------------------------------------------------------
  1301.         cpu.graph_trace_cursor_pos = 0;
  1302.     }
  1303.     //-------------------------------------------------------------------------
  1304.    
  1305.    
  1306.   // яхЁхтюф ъєЁёюЁр т ёрь√щ тхЁї т ы■сюь ёыєўрх
  1307.  //   cpu.trace_curs = cpu.trace_top;
  1308.  //   cpu.graph_trace_cursor_pos = 0;
  1309.     //-------------------------------------------------------------------------
  1310. //    printf("cpu.trpc -");
  1311. //    for (int tmp = 0; tmp <= trace_size; tmp++)
  1312. //    {
  1313. //        //printf("tmp,cpu.trpc[%04d] - %04X\n",tmp,cpu.trpc[tmp]);
  1314. //        printf(" %04X",cpu.trpc[tmp]);
  1315. //    }
  1316. //    printf("\n");
  1317.     //-------------------------------------------------------------------------
  1318.     cpu.trace_top &= 0xFFFF;    // эр тё ъшщ ёыєўрщ
  1319.     cpu.trace_curs &= 0xFFFF;
  1320.     //-------------------------------------------------------------------------
  1321.     return;
  1322.     //-------------------------------------------------------------------------
  1323.  
  1324.  
  1325.  
  1326. /*
  1327.    Z80 &cpu = CpuMgr.Cpu();
  1328.  
  1329. //   printf("cpu.trace_curs %d\n",cpu.trace_curs);
  1330. //   printf("cpu.trace_top %d\n",cpu.trace_top);  
  1331.  
  1332.     // printf("cup()\n");  
  1333.  
  1334.  
  1335. // ьюцхЄ тююс∙х эх ЄЁюурЄ№ cpu.trace_curs, cpu.trace_top
  1336. // р ёЁрчє т√ч√трЄ№ follow PC
  1337. // їюЄ  ¤Єю эртхЁэю сєфхЄ сюыхх ЁхёєЁёюхьъю
  1338. //      р Єръ ьюцэю сєфхЄ ырчшЄ№ яю фшчрёьє ё чрцрЄ√ь ёЄхяюь схч яюЄхЁш ъєЁёюЁр
  1339. //      шыш Єрь рєЄюёЄхя/ЄЁхщё
  1340. //              эртхЁэюх Єръюх ыєў°ю т√эхёЄш эр юЄфхы№эє■ ъэюяъє?
  1341.  
  1342.     signed int trace_top_1;
  1343.     //-------------------------------------------------------------------------
  1344.     if (cpu.trace_curs < 500)
  1345.     {
  1346.         //---------------------------------------------------------------------
  1347.         if (cpu.trace_top > 0xF000)
  1348.         {
  1349.             printf("cpu.trace_top > 0xF000\n");
  1350.             trace_top_1 = (cpu.trace_top - 0xFFFF) - 1;
  1351.         }
  1352.         //---------------------------------------------------------------------
  1353.         else
  1354.         {
  1355.             printf("cpu.trace_top = normal\n");
  1356.             trace_top_1 = cpu.trace_top;
  1357.         }
  1358.         //---------------------------------------------------------------------
  1359.     }
  1360.     //-------------------------------------------------------------------------
  1361.    
  1362.    
  1363.     // ъюуфр cpu.trace_top = FFFF р cpu.trace_curs = 0000
  1364.     // єёыютшх эх ёЁрсрЄ√трхЄ
  1365.     // ш Єюя-юь ёЄрэютшЄёю ъєЁёюЁ ёю ёЄЁр°э√ь фхЁуюёь√ъюь
  1366.    
  1367.     //printf("cpu.trace_curs %x  cpu.trace_top %x trace_top_1 %d\n",cpu.trace_curs,cpu.trace_top,trace_top_1);
  1368.  
  1369.     signed int trace_cursor_1 = cpu.trace_curs;
  1370.     // яюўхьє Єю (cpu.trace_curs > trace_top_1) эх фрхЄ true т ёыєўрх (10 > -10) o_O
  1371.     // фрцх яЁш -O0
  1372.     // эю т√эхёхэю т юЄфхы№эє■ яхЁхьхээє■ ЁрсююЄрхЄ
  1373.    
  1374.     //-------------------------------------------------------------------------
  1375. //  if (cpu.trace_curs > cpu.trace_top)
  1376.     if (        (trace_cursor_1 > trace_top_1) &&
  1377.                 (cpu.trace_curs != cpu.trace_top)        //фы  яхЁхїюфрр ттхЁї ё тхЁїэхщ ёЄЁюъш
  1378.       )    
  1379.     {
  1380.         //printf("(cpu.trace_curs > trace_top_1) \n");
  1381.         //---------------------------------------------------------------------
  1382.        
  1383.        
  1384.         for (unsigned i = 1; i < trace_size; i++)       //trace_size = 21
  1385.         {
  1386.             //printf(" i %d\n",i);
  1387.             if (cpu.trpc[i] == cpu.trace_curs)
  1388.             {
  1389.                 // printf(" cpu.trpc[i] == cpu.trace_curs\n",i);
  1390.                 cpu.trace_curs = cpu.trpc[i - 1];
  1391.                 cpu.graph_trace_cursor_pos = i - 1;
  1392.                 //printf ("cpu.trpc[i-1] %d\n",cpu.trpc[i-1]);
  1393.             }
  1394.             //printf("i %d\n",i);
  1395.         }
  1396.         //---------------------------------------------------------------------
  1397.     }
  1398.     //-------------------------------------------------------------------------
  1399.     else
  1400.     {
  1401.         //яхЁхїюф т√°х ёрьюую тхЁїэхую яюыюцхэш 
  1402.         //---------------------------------------------------------------------
  1403.         if (cpu.trace_curs != 0) // [NS]
  1404.         {
  1405.             cpu.trace_top = cpu.trace_curs = cpu_up(cpu.trace_curs);
  1406.             //printf ("1\n");
  1407.         }
  1408.         //---------------------------------------------------------------------
  1409.         else
  1410.         {
  1411.             //яхЁхїюф ё 0000 ъ FFFF (Ёрэ№°х єяшЁрыюё№ ш ¤Єю фшъю схёшыю)
  1412.             cpu.trace_top = cpu.trace_curs = cpu_up(0x10000);
  1413.             //printf ("2\n");
  1414.         }
  1415.         //---------------------------------------------------------------------
  1416.     }
  1417.     //-------------------------------------------------------------------------
  1418.         cpu.trace_top &= 0xFFFF;
  1419.         cpu.trace_curs &= 0xFFFF;
  1420.  
  1421.  
  1422.  
  1423.  */
  1424.  
  1425. } // void cup()
  1426. //=============================================================================ь
  1427.  
  1428.  
  1429. //=============================================================================
  1430. void cdown()                                            //"cpu.down" їюЄъхщ
  1431. {
  1432.     // printf("cdown()\n");
  1433.        
  1434.     Z80 &cpu = CpuMgr.Cpu();
  1435.    
  1436.     //-------------------------------------------------------------------------
  1437.     // яЁюёЄющ яхЁхїюф т ёхЁхфшэх ¤ъЁрэр
  1438.     if (cpu.graph_trace_cursor_pos < (trace_size - 1))
  1439.     {
  1440.         cpu.graph_trace_cursor_pos++;
  1441.         cpu.trace_curs = cpu.trpc[ cpu.graph_trace_cursor_pos];
  1442.     }  
  1443.     //-------------------------------------------------------------------------
  1444.     // ёъЁюыы ¤ъЁрэр Єюы№ъю ё ёрьющ эшцэхщ яючшЎшш
  1445.     else
  1446.     {
  1447.         // printf("== trace_size\n");
  1448.         cpu.trace_top = cpu.trpc[ 1];
  1449.         cpu.trace_curs = cpu.trpc[ cpu.graph_trace_cursor_pos + 1];
  1450.         cpu.graph_trace_cursor_pos = trace_size;
  1451.         //---------------------------------------------------------------------
  1452.         // ╧хЁхїюф ўхЁхч ьхЄъє (фтющэющ рфЁхё)
  1453.         if (cpu.trpc[ 0] == cpu.trpc[ 1])
  1454.         {
  1455.             // printf("== prev_cpu_trace_curs\n");
  1456.             cpu.trace_top = cpu.trpc[ 2];
  1457.         }
  1458.         //---------------------------------------------------------------------
  1459.     }
  1460.     //-------------------------------------------------------------------------
  1461.     if (cpu.trpc[ 0] != cpu.trpc[ 1])
  1462.     {
  1463.         //---------------------------------------------------------------------
  1464.         if (cpu.graph_trace_cursor_pos >= (trace_size - 1))
  1465.         {
  1466.             // printf("fix pos\n");
  1467.             // cpu.trace_top = cpu.trpc[ 3];
  1468.             cpu.graph_trace_cursor_pos = (trace_size - 1);
  1469.         }
  1470.         //---------------------------------------------------------------------
  1471.     }
  1472.     //-------------------------------------------------------------------------
  1473.    
  1474.                 /*
  1475.                 else
  1476.                 {
  1477.                    if (cpu.graph_trace_cursor_pos >= (trace_size))
  1478.                         {
  1479.                             printf("fix pos 2\n");
  1480.                             //cpu.trace_top = cpu.trpc[ 3];
  1481.                             cpu.graph_trace_cursor_pos = (trace_size+1);
  1482.                         }
  1483.                 }
  1484.                 */
  1485.    
  1486.    
  1487. /*
  1488.     // ёЄрЁр  ╨└┴╬╫└▀ яЁюЎхфєЁр !!!!!!!!
  1489.     //-------------------------------------------------------------------------
  1490.     for (unsigned i = 0;    i < trace_size;    i++)
  1491.     {
  1492.         // printf(" i %d\n",i);
  1493.         //---------------------------------------------------------------------
  1494.         if (cpu.trpc[ i] == cpu.trace_curs)
  1495.         {
  1496.                        
  1497.             cpu.trace_curs = cpu.trpc[ i + 1];
  1498.             cpu.graph_trace_cursor_pos = i + 1;    
  1499.             //-----------------------------------------------------------------
  1500.             if (i + 1 == trace_size)
  1501.             {
  1502.                 // printf(" (i+1 == trace_size)\n",i);
  1503.                 cpu.trace_top = cpu.trpc[ 1];
  1504.             }
  1505.             //-----------------------------------------------------------------
  1506.             break;
  1507.         }
  1508.         //---------------------------------------------------------------------
  1509.     }
  1510.     //-------------------------------------------------------------------------
  1511.    */
  1512. }
  1513. //=============================================================================
  1514. // тшфшью trace_mode 0,1,2 ¤Єю рфЁхё, юяъюф, фшчрёь ?
  1515. // ўЄю шч эшї ъЄю эрфю єЄю°э Є№
  1516. //=============================================================================
  1517. void cleft()  { CpuMgr.Cpu().trace_mode--; }            // "cpu.left" їюЄъхщ
  1518. //=============================================================================
  1519. void cright() { CpuMgr.Cpu().trace_mode++; }            // "cpu.right" їюЄъхщ
  1520. //=============================================================================
  1521. void chere()    //trace to cursor????                   // т ьхэ■ WNDTRACE фхсрухЁр
  1522. {                                                       // ш "cpu.here" їюЄъхщ
  1523.     //printf("chere()\n");
  1524.     Z80 &cpu = CpuMgr.Cpu();
  1525.     cpu.dbgbreak = 0;
  1526.     dbgbreak = 0;
  1527.     cpu.dbgchk = 1;
  1528.  
  1529.     cpu.dbg_stophere = cpu.trace_curs;
  1530. }
  1531. //=============================================================================
  1532.  
  1533.  
  1534. //=============================================================================
  1535. void cpgdn()    //next page                             // "cpu.pgdn" їюЄъхщ
  1536. {
  1537.     Z80 &cpu = CpuMgr.Cpu();
  1538.    
  1539.     // тэрўрых яхЁхїюф ъ яюёыхфэхщ ёЄЁюъх
  1540.     //-------------------------------------------------------------------------
  1541.     if (cpu.graph_trace_cursor_pos < (trace_size - 1))
  1542.     {
  1543.         cpu.trace_curs = cpu.trpc[ trace_size - 1];
  1544.         cpu.graph_trace_cursor_pos = trace_size - 1;
  1545.     }
  1546.     //-------------------------------------------------------------------------
  1547.     // ╧хЁхїюф эр ёыхф ёЄЁрэшЎє Єюы№ъю ъюуфр ъєЁёюЁ т ёрьюь эшчє
  1548.     // яю Єшяє explorer.exe
  1549.     else        //if (cpu.graph_trace_cursor_pos == (trace_size - 1))
  1550.     {
  1551.         cpu.graph_trace_cursor_pos = trace_size - 1;
  1552.         //---------------------------------------------------------------------
  1553.         // єяшЁрхьё  т 0xFFFF
  1554.         if (cpu.trace_curs == 0xFFFF)
  1555.         {
  1556.             cpu.trace_top = 0xFFFF - (trace_size - 1);
  1557.             cpu.trace_curs = 0xFFFF;
  1558.             return;
  1559.         }
  1560.         //---------------------------------------------------------------------
  1561.         // яюёыхфэшх °руш єьхэ№°хээ√щ ш єяшЁр■Єёю т FFFF
  1562.         if ((cpu.trace_top < (0xFFFF - (trace_size - 1))) && (cpu.trace_top > (0xFFFF - (2 * (trace_size - 1)) - 1)))
  1563.         {
  1564.             //
  1565.             //FFEA_FFFE first -> FFEB_FFFF
  1566.             //FFD8_FFEC
  1567.             //FFD7_FFEB last  -> FFEB_FFFF
  1568.             cpu.trace_top = 0xFFFF - (trace_size - 1);
  1569.             cpu.trace_curs = 0xFFFF;
  1570.         }
  1571.         //---------------------------------------------------------------------
  1572.         // FFEC...FFFF эюЁьры№э√щ pddown
  1573.         else
  1574.         {
  1575.             cpu.trace_top = cpu.trpc[ trace_size];
  1576.         }
  1577.     }
  1578.     //-------------------------------------------------------------------------
  1579.  
  1580.     //-------------------------------------------------------------------------    
  1581.  
  1582.  
  1583.  
  1584.        
  1585.  
  1586.         //      //-------------------------------------------------------------
  1587.         //      printf("cpu.trpc -");
  1588.         //      for (int tmp = 0; tmp <= trace_size; tmp++)
  1589.         //      {
  1590.         //          //printf("tmp,cpu.trpc[%04d] - %04X\n",tmp,cpu.trpc[tmp]);
  1591.         //          printf(" %04X",cpu.trpc[tmp]);
  1592.         //      }
  1593.         //      printf("\n");
  1594.         //      //-------------------------------------------------------------
  1595.    return;
  1596.    
  1597.    
  1598.    
  1599.    
  1600.    
  1601.    
  1602.    
  1603.    
  1604.    
  1605. /*             
  1606.     Z80 &cpu = CpuMgr.Cpu();
  1607.     unsigned curs = 0;
  1608.     //-------------------------------------------------------------------------
  1609.     for (unsigned i = 0;    i < trace_size;    i++)
  1610.         if (cpu.trace_curs == cpu.trpc[i])
  1611.             curs = i;
  1612.     //-------------------------------------------------------------------------
  1613.     cpu.trace_top = cpu.trpc[trace_size];
  1614.     showtrace();
  1615.     cpu.trace_curs = cpu.trpc[curs];
  1616.   */  
  1617.    
  1618. }
  1619. //=============================================================================
  1620.  
  1621.  
  1622. //=============================================================================
  1623. void cpgup()            //prev page                     // "cpu.pgup" їюЄъхщ
  1624. {
  1625.     Z80 &cpu = CpuMgr.Cpu();
  1626.     // printf("cursor %X\n",cpu.graph_trace_cursor_pos);
  1627.     //-------------------------------------------------------------------------
  1628.     // ╧хЁхїюф эр яЁхф ёЄЁрэшЎє Єюы№ъю ъюуфр ъєЁёюЁ т ёрьюь тхЁїє
  1629.     // яю Єшяє explorer.exe
  1630.     if ( (cpu.graph_trace_cursor_pos == 0) ||
  1631.          (cpu.trace_curs == cpu.trace_top)
  1632.      )
  1633.     {
  1634.         // printf("  cursor == 0\n");
  1635.         unsigned i;             //Alone Coder 0.36.7
  1636.         //---------------------------------------------------------------------
  1637.         // Єєяю яютЄюЁ хь 20 Ёрч :rofl:                                 2do !!!!!
  1638.         //      ═╬ т Ёхцшьх ьхЄюъ юЄфхы№эющ ёЄЁюъющ
  1639.         //      ъюышўхёЄтю тшфшь√ї ёЄЁюъ ьхэ№°х ўхь ёЄЁюъ фшчрёьр !!!!!
  1640.         //      ═╙╞═╬ яюёўшЄрЄ№ ЇръЄшўхёъюх ўшёыю єэшъры№э√ї рфЁхёют
  1641.         for (i = 0;    i < trace_size;    i++)
  1642.         {
  1643.             cpu.trace_top = cpu_up( cpu.trace_top);
  1644.         }
  1645.         //---------------------------------------------------------------------
  1646.     }
  1647.     //-------------------------------------------------------------------------
  1648.     // яхЁхтюф ъєЁёюЁр т ёрь√щ тхЁї т ы■сюь ёыєўрх
  1649.     cpu.trace_curs = cpu.trace_top;
  1650.     cpu.graph_trace_cursor_pos = 0;
  1651.     //-------------------------------------------------------------------------
  1652. //    printf("cpu.trpc -");
  1653. //    for (int tmp = 0; tmp <= trace_size; tmp++)
  1654. //    {
  1655. //        //printf("tmp,cpu.trpc[%04d] - %04X\n",tmp,cpu.trpc[tmp]);
  1656. //        printf(" %04X",cpu.trpc[tmp]);
  1657. //    }
  1658. //    printf("\n");
  1659.     //-------------------------------------------------------------------------
  1660.     return;
  1661.     //-------------------------------------------------------------------------
  1662.  
  1663.  
  1664.  
  1665. //    юЁшушэры№э√щ ъюф ш є∙хЁсэ√щ ш Єєую юЄырцштрхь√щ
  1666. //    unsigned curs = 0;
  1667. //    unsigned i;               //Alone Coder 0.36.7
  1668. //    //-------------------------------------------------------------------------
  1669. //    for (/*unsigned*/ i = 0;    i < trace_size;    i++)
  1670. //      if (cpu.trace_curs == cpu.trpc[i])
  1671. //          curs = i;
  1672. //    //-------------------------------------------------------------------------
  1673. //    for (i = 0;    i < trace_size;    i++)
  1674. //      cpu.trace_top = cpu_up(cpu.trace_top);
  1675. //    //-------------------------------------------------------------------------
  1676. //    showtrace();
  1677. //    cpu.trace_curs = cpu.trpc[curs];
  1678. //              //-------------------------------------------------------------
  1679. //              printf("cpu.trpc -");
  1680. //              for (int tmp = 0; tmp <= trace_size; tmp++)
  1681. //              {
  1682. //                  //printf("tmp,cpu.trpc[%04d] - %04X\n",tmp,cpu.trpc[tmp]);
  1683. //                  printf(" %04X",cpu.trpc[tmp]);
  1684. //              }
  1685. //              printf("\n");
  1686. //              //-------------------------------------------------------------
  1687.  
  1688.  
  1689. }
  1690. //=============================================================================
  1691.  
  1692.  
  1693. //=============================================================================
  1694. // pop cursor position from jumpstack                   // т ьхэ■ WNDTRACE фхсрухЁр
  1695. void pop_pos()  // IDA mode                             // ш "cpu.back" їюЄъхщ
  1696. {               // back from "goto to branch destination"
  1697.                 // эр ёрьюь фхых ¤Єю Return to previous possition
  1698.                 // Єъ яхЁхїюф яю рфЁхёє яЁш ттюфх ъшфрхЄ рфЁхё т ёЄхъ
  1699.     Z80 &cpu = CpuMgr.Cpu();
  1700.     //-------------------------------------------------------------------------
  1701.     if (stack_pos[0] == -1U)
  1702.         return;
  1703.     //-------------------------------------------------------------------------
  1704.     cpu.trace_curs = stack_cur[ 0];
  1705.     cpu.trace_top = stack_pos[ 0];
  1706.     memcpy( &stack_pos[ 0], &stack_pos[ 1], sizeof stack_pos - sizeof *stack_pos);
  1707.     memcpy( &stack_cur[ 0], &stack_cur[ 1], sizeof stack_cur - sizeof *stack_cur);
  1708.     stack_pos[ (sizeof stack_pos / sizeof *stack_pos) - 1] = -1U;
  1709. }
  1710. //=============================================================================
  1711.  
  1712.  
  1713.  
  1714. //=============================================================================
  1715. // Goto Operand Address                         ZX/GS - ok
  1716. // push cursor position and goto instruction operand    // т ьхэ■ WNDTRACE фхсрухЁр
  1717. void cjump()    // IDA mode                             // "cpu.context" їюЄъхщ
  1718. {               // яхЁхїюф эр рфЁхё юяхЁрэфр !!!
  1719.     Z80 &cpu = CpuMgr.Cpu();
  1720.     char *ptr = nullptr;
  1721.     //-------------------------------------------------------------------------
  1722.     for (char *p = asmpc;    *p;    p++)
  1723.         if (ishex( p[ 0]) & ishex( p[ 1]) & ishex( p[ 2]) & ishex( p[ 3]))
  1724.             ptr = p;
  1725.     //-------------------------------------------------------------------------
  1726.     if (!ptr)
  1727.         return;
  1728.     //-------------------------------------------------------------------------
  1729.     push_pos();
  1730.     unsigned addr;
  1731.     sscanf( ptr, "%04X", &addr);
  1732.     cpu.trace_curs = cpu.trace_top = addr;
  1733. }
  1734. //=============================================================================
  1735.  
  1736.  
  1737.  
  1738. //=============================================================================
  1739. // View Operand Address                         ZX/GS - ok
  1740. // jump to instruction operand in data window           // т ьхэ■ WNDTRACE фхсрухЁр
  1741. void cdjump()                                           // ш "cpu.datajump" їюЄъхщ
  1742. {                                                      
  1743.     char *ptr = nullptr;
  1744.     //-------------------------------------------------------------------------
  1745.     for (char *p = asmpc;    *p;    p++)
  1746.         if (ishex( p[0]) & ishex( p[1]) & ishex( p[2]) & ishex( p[3]))
  1747.             ptr = p;
  1748.     //-------------------------------------------------------------------------
  1749.     if (!ptr)
  1750.         return;
  1751.     //-------------------------------------------------------------------------
  1752.     unsigned addr;
  1753.     sscanf( ptr, "%04X", &addr);
  1754.     Z80 &cpu = CpuMgr.Cpu();
  1755.     cpu.mem_curs = addr;
  1756.     activedbg = WNDMEM;
  1757.     editor = ED_MEM;
  1758. }
  1759. //=============================================================================
  1760.  
  1761.  
  1762.  
  1763.                
  1764.                
  1765. //=============================================================================
  1766. // яхЁхїюф ъ рфЁхёє т юъэх ьхьюЁш тшхтхЁр       ZX/GS - ok              // [NS]
  1767. // шч юъэр фшчрёьр
  1768. void mon_view_mem_addr( unsigned addr)                                 
  1769. {
  1770. //  unsigned addr = cpu.af;
  1771.     addr &= 0xFFFF;     // юсЁхчър Єъ ьюцхЄ с√Є№ Їшуэ 
  1772.     Z80 &cpu = CpuMgr.Cpu();
  1773.     cpu.mem_curs = addr;
  1774.     activedbg = WNDMEM;
  1775.     editor = ED_MEM;
  1776. }
  1777.  
  1778. void mon_view_mem_rAF()         { Z80 &cpu = CpuMgr.Cpu();      mon_view_mem_addr( cpu.af);             }
  1779. void mon_view_mem_rBC()         { Z80 &cpu = CpuMgr.Cpu();      mon_view_mem_addr( cpu.bc);             }
  1780. void mon_view_mem_rDE()         { Z80 &cpu = CpuMgr.Cpu();      mon_view_mem_addr( cpu.de);             }
  1781. void mon_view_mem_rHL()         { Z80 &cpu = CpuMgr.Cpu();      mon_view_mem_addr( cpu.hl);             }
  1782.  
  1783. void mon_view_mem_rAF1()        { Z80 &cpu = CpuMgr.Cpu();      mon_view_mem_addr( cpu.alt.af); }
  1784. void mon_view_mem_rBC1()        { Z80 &cpu = CpuMgr.Cpu();      mon_view_mem_addr( cpu.alt.bc); }
  1785. void mon_view_mem_rDE1()        { Z80 &cpu = CpuMgr.Cpu();      mon_view_mem_addr( cpu.alt.de); }
  1786. void mon_view_mem_rHL1()        { Z80 &cpu = CpuMgr.Cpu();      mon_view_mem_addr( cpu.alt.hl); }
  1787.  
  1788. void mon_view_mem_rIX()         { Z80 &cpu = CpuMgr.Cpu();      mon_view_mem_addr( cpu.ix);             }
  1789. void mon_view_mem_rIY()         { Z80 &cpu = CpuMgr.Cpu();      mon_view_mem_addr( cpu.iy);             }
  1790.  
  1791. void mon_view_mem_rSP()         { Z80 &cpu = CpuMgr.Cpu();      mon_view_mem_addr( cpu.sp);             }
  1792. void mon_view_mem_rPC()         { Z80 &cpu = CpuMgr.Cpu();      mon_view_mem_addr( cpu.pc);             }
  1793.  
  1794. //=============================================================================
  1795.  
  1796.  
  1797. //=============================================================================
  1798. // яюърчрЄ№/ёъЁ√Є№ labels
  1799. void cfliplabels()                              // т ьхэ■ WNDTRACE фхсрухЁр
  1800. {                                               // "cpu.labels" їюЄъхщ
  1801.     trace_labels = !trace_labels;
  1802.     showtrace();
  1803. }
  1804. //=============================================================================
  1805. // save cursor position to slot n
  1806. static void csave( unsigned n)          //"cpu.save1"..."cpu.save8" їюЄъхш
  1807. {
  1808.     Z80 &cpu = CpuMgr.Cpu();
  1809.     save_pos[ n] = cpu.trace_top;
  1810.     save_cur[ n] = cpu.trace_curs;
  1811. }
  1812. //=============================================================================
  1813. // save cursor position to jumpstack, load from slot 1
  1814. static void crest( unsigned n)          //"cpu.rest1"..."cpu.rest8" їюЄъхш
  1815. {
  1816.     Z80 &cpu = CpuMgr.Cpu();
  1817.     //-------------------------------------------------------------------------
  1818.     if (save_pos[n] == -1U)
  1819.         return;
  1820.     //-------------------------------------------------------------------------
  1821.     push_pos();
  1822.     cpu.trace_top = save_pos[ n];
  1823.     cpu.trace_curs = save_cur[ n];
  1824. }
  1825. //=============================================================================
  1826. void csave1() { csave(0); }
  1827. void csave2() { csave(1); }
  1828. void csave3() { csave(2); }
  1829. void csave4() { csave(3); }
  1830. void csave5() { csave(4); }
  1831. void csave6() { csave(5); }
  1832. void csave7() { csave(6); }
  1833. void csave8() { csave(7); }
  1834. //=============================================================================
  1835. void crest1() { crest(0); }
  1836. void crest2() { crest(1); }
  1837. void crest3() { crest(2); }
  1838. void crest4() { crest(3); }
  1839. void crest5() { crest(4); }
  1840. void crest6() { crest(5); }
  1841. void crest7() { crest(6); }
  1842. void crest8() { crest(7); }
  1843. //=============================================================================
  1844.  
  1845.  
  1846.  
  1847. //=============================================================================
  1848. namespace z80dbg                                                //????
  1849. {
  1850.     void __cdecl SetLastT()
  1851.     {
  1852.         cpu.debug_last_t = comp.t_states + cpu.t;
  1853.     }
  1854. }
  1855. //=============================================================================
  1856.  
  1857.  
  1858.  
  1859. float zx_step_dither = 0.0;     // яю ьюхьє ¤Єю тёх фы  ЁрёяЁхфхыхэш  ю°шсъш [NS]
  1860. float gs_step_dither = 0.0;     // яЁш ╥╚╧╬ °рурэшх zx/gs юфэютЁхьхээю
  1861.  
  1862. float zx_tact_dither = 0.0;
  1863. float gs_tact_dither = 0.0;
  1864.  
  1865.  
  1866. //=============================================================================
  1867. //с√т°шщ void mon_step()
  1868. void mon_step_single_cpu()
  1869. {
  1870.     Z80 &cpu = CpuMgr.Cpu();
  1871.     TZ80State &prevcpu = CpuMgr.PrevCpu();
  1872.    
  1873.     cpu.SetLastT();
  1874.     prevcpu = cpu;
  1875.     // CpuMgr.CopyToPrev();
  1876.    
  1877.     //-------------------------------------------------------------------------
  1878.     if (cpu.t >= conf.intlen)
  1879.        cpu.int_pend = false;
  1880.     //-------------------------------------------------------------------------
  1881.     cpu.Step();
  1882.     //-------------------------------------------------------------------------
  1883.     if (  (cpu.int_pend)        &&
  1884.           (cpu.iff1)            &&
  1885.           (cpu.t != cpu.eipos)  &&      // int enabled in CPU not issued after EI
  1886.           (cpu.int_gate)                // int enabled by ATM hardware
  1887.      )
  1888.     {
  1889.         handle_int( &cpu, cpu.IntVec());
  1890.     }
  1891.     //-------------------------------------------------------------------------
  1892.     cpu.CheckNextFrame();
  1893.     //-------------------------------------------------------------------------
  1894.     if (conf.trace_follow_regs)                                         // [NS]
  1895.     {
  1896.         //---------------------------------------------------------------------
  1897.         switch (conf.trace_follow_regs)
  1898.         {
  1899.             case REG_AF:        cpu.trace_curs = cpu.af;        break;
  1900.             case REG_BC:        cpu.trace_curs = cpu.bc;        break;
  1901.             case REG_DE:        cpu.trace_curs = cpu.de;        break;
  1902.             case REG_HL:        cpu.trace_curs = cpu.hl;        break;
  1903.             case REG_AF1:       cpu.trace_curs = cpu.alt.af;    break;
  1904.             case REG_BC1:       cpu.trace_curs = cpu.alt.bc;    break;
  1905.             case REG_DE1:       cpu.trace_curs = cpu.alt.de;    break;
  1906.             case REG_HL1:       cpu.trace_curs = cpu.alt.hl;    break;
  1907.             case REG_IX:        cpu.trace_curs = cpu.ix;        break;
  1908.             case REG_IY:        cpu.trace_curs = cpu.iy;        break;
  1909.             case REG_SP:        cpu.trace_curs = cpu.sp;        break;
  1910.             case REG_PC:        cpu.trace_curs = cpu.pc;        break;
  1911.         }
  1912.         //---------------------------------------------------------------------
  1913.         conf.trace_follow_request = 1;  // ёыхфютрЄ№ чр ўхь эшсєф№     
  1914.     }
  1915.     //-------------------------------------------------------------------------
  1916.     // ЄєЄ эєцэю эхёъюы№ъю Ёрч т√ч√трЄ№ step фы  GS
  1917.     // шыш ьюцхЄ фрцх сЁрЄ№ ЄръЄ√
  1918.     // ш ∙шЄрЄ№ ёъюы№ъю ърцфюую фюыцэю с√Є№ т√чтрэю
  1919.    
  1920. }
  1921. //=============================================================================
  1922. // ZX+GS Step                                                           // [NS]
  1923. void mon_step()                                                        
  1924. {
  1925.     //=========================================================================
  1926.     if ( (conf.gs_type == 1)    &&      // GS Z80
  1927.          (conf.ZXGS_Step == 1)          // тъы■ўхээюёЄ№ ёютьхёЄэюую ёЄхяр
  1928.      )
  1929.     {
  1930.         Z80 &cpu = CpuMgr.Cpu();
  1931.  
  1932.         // NO STATIC !!!!
  1933.         int current_cpu_back = CpuMgr.GetCurrentCpu();
  1934.    
  1935.         float zx_cpu_frq = frametime * conf.intfq;
  1936.         //printf("ZX CPU %f\n",zx_cpu_frq);
  1937.    
  1938.         //=====================================================================
  1939.         // ZX Step
  1940.         if (current_cpu_back == 0)
  1941.         {
  1942.             //printf("ZX_STEP\n");
  1943.             float gs_tacts_per_1_zx = (float) z80gs::GSCPUFQ / zx_cpu_frq;
  1944.            
  1945.             mon_step_single_cpu();      // 1 ZX Step
  1946.             //printf("cpu.Delta() %d\n",cpu.Delta());
  1947.             gs_tact_dither += gs_tacts_per_1_zx * (float) cpu.Delta();
  1948.             //printf("gs_tact_dither %f\n",gs_tact_dither);
  1949.             //-----------------------------------------------------------------
  1950.             // ┬ючьюцэр Ёрчфрўр GS ю°шсъш
  1951.             if (gs_tact_dither > 4.0)   // яє°ю ьхэ№°х 4 ЄръЄют эхтючьюцэю °руэєЄ№
  1952.             {
  1953.                 //CpuMgr.SwitchCpu();
  1954.                 CpuMgr.SetCurrentCpu( 1);       // GS CPU
  1955.                 Z80 &cpu = CpuMgr.Cpu();
  1956.                 //-------------------------------------------------------------
  1957.                 // GS Step
  1958.                 while (gs_tact_dither > 4.0)
  1959.                 {
  1960.                     //printf("  gs_step\n");
  1961.                     mon_step_single_cpu();
  1962.                     //printf("  cpu.Delta() %d\n",cpu.Delta());
  1963.                     gs_tact_dither -= (float) cpu.Delta();
  1964.                     //printf("  gs_tact_dither %f\n",gs_tact_dither);
  1965.                 }
  1966.                 //-------------------------------------------------------------
  1967.                 //CpuMgr.SwitchCpu();
  1968.             }
  1969.             //-----------------------------------------------------------------
  1970.         } // ZX Step
  1971.         //=====================================================================
  1972.         // GS Step
  1973.         else
  1974.         {
  1975.             //printf("GS_STEP\n");
  1976.             float zx_tacts_per_1_gs = zx_cpu_frq / (float) z80gs::GSCPUFQ;
  1977.            
  1978.             mon_step_single_cpu();      // 1 GS Step
  1979.             //printf("cpu.Delta() %d\n",cpu.Delta());
  1980.             zx_tact_dither += zx_tacts_per_1_gs * (float) cpu.Delta();
  1981.             //printf("zx_tact_dither %f\n",zx_tact_dither);
  1982.             //-----------------------------------------------------------------
  1983.             // ┬ючьюцэр Ёрчфрўр ZX ю°шсъш
  1984.             if (zx_tact_dither > 4.0)   // яє°ю ьхэ№°х 4 ЄръЄют эхтючьюцэю
  1985.             {
  1986.                 //CpuMgr.SwitchCpu();
  1987.                 CpuMgr.SetCurrentCpu( 0);       // ZX CPU
  1988.                 Z80 &cpu = CpuMgr.Cpu();
  1989.                 //-------------------------------------------------------------
  1990.                 // ZX Step
  1991.                 while (zx_tact_dither > 4.0)
  1992.                 {
  1993.                     //printf("  zx_step\n");
  1994.                     mon_step_single_cpu();
  1995.                     //printf("  zx cpu.Delta() %d\n",cpu.Delta());
  1996.                     zx_tact_dither -= (float) cpu.Delta();
  1997.                     //printf("  zx_tact_dither %f\n",zx_tact_dither);
  1998.                 }
  1999.                 //-------------------------------------------------------------
  2000.                 //CpuMgr.SwitchCpu();
  2001.             }
  2002.             //-----------------------------------------------------------------
  2003.         } // GS Step
  2004.         //=====================================================================
  2005.         // ┬юёЄрэютыхэшх шёїюфэюую CPU
  2006.         CpuMgr.SetCurrentCpu( current_cpu_back);
  2007.     }
  2008.     //=========================================================================
  2009.     // эх °рурЄ№ "юфэютЁхьхээю"
  2010.     else
  2011.     {
  2012.         mon_step_single_cpu();
  2013.     }
  2014.     //=========================================================================
  2015.    
  2016. /*
  2017.  
  2018.  
  2019.  
  2020.     // NO STATIC !!!!
  2021.     int current_cpu_back = CpuMgr.GetCurrentCpu();
  2022.     //printf("cpu %x\n",current_cpu_back);
  2023.    
  2024.    //     const int GSCPUFQ = 24000000;         // hz //12
  2025.    // extern const unsigned GSCPUINT;
  2026.     // GSINTFQ
  2027.    
  2028.         //conf.frame
  2029.         //cpu.tpi //zx?
  2030.         //printf("GSINTFQ %d\n",GSINTFQ);
  2031.         //printf("GSCPUINT %d\n",GSCPUINT);
  2032.         //printf("GSCPUFQ %d\n",z80gs::GSCPUFQ);
  2033.         //printf("frametime %d\n",frametime);
  2034.         //printf("conf.intfq %d\n",conf.intfq);
  2035.         float zx_cpu_frq = frametime * conf.intfq;
  2036.         //printf("ZX CPU %f\n",zx_cpu_frq);
  2037.         float gs_steps_per_1_zx = (float) z80gs::GSCPUFQ / zx_cpu_frq;
  2038.         float zx_steps_per_1_gs = zx_cpu_frq / (float) z80gs::GSCPUFQ;
  2039.         //printf("gs_steps_per_1_zx %f\n",gs_steps_per_1_zx);
  2040.         //printf("zx_steps_per_1_gs %f\n",zx_steps_per_1_gs);
  2041.        
  2042.     // STEP-√ эх єўшЄ√тр■Є ЄръЄ√ !!!
  2043.     // эєцэю фхырЄ№ ё єўхЄюь ЄръЄют чр яюёыхфэшщ ёЄхя
  2044.     //=========================================================================
  2045.     // ZX Step
  2046.     if (current_cpu_back == 0)
  2047.     {
  2048.         printf("ZX_STEP\n");
  2049.         mon_step_single_cpu();  // 1 ZX Step
  2050.  
  2051.         gs_step_dither += gs_steps_per_1_zx;
  2052.         //printf("gs_step_dither %f\n",gs_step_dither);
  2053.         //---------------------------------------------------------------------
  2054.        
  2055.        
  2056.         if (gs_step_dither > 1.0)
  2057.         {
  2058.             CpuMgr.SwitchCpu();
  2059.             while (gs_step_dither > 1.0)
  2060.             {
  2061.                 gs_step_dither -= 1.0;
  2062.                 printf("gs_step\n");
  2063.                 mon_step_single_cpu();
  2064.             }
  2065.             CpuMgr.SwitchCpu();
  2066.         }
  2067.         //---------------------------------------------------------------------
  2068.        
  2069.     }
  2070.     //=========================================================================
  2071.     // GS Step
  2072.     else
  2073.     {
  2074.         printf("GS_STEP\n");
  2075.         mon_step_single_cpu();  // 1 GS Step
  2076.        
  2077.         zx_step_dither += zx_steps_per_1_gs;
  2078.         //printf("zx_step_dither %f\n",zx_step_dither);
  2079.         //---------------------------------------------------------------------
  2080.         if (zx_step_dither > 1.0)
  2081.         {
  2082.             CpuMgr.SwitchCpu();
  2083.             while (zx_step_dither > 1.0)
  2084.             {
  2085.                 zx_step_dither -= 1.0;
  2086.                 printf("zx_step\n");
  2087.                 mon_step_single_cpu();
  2088.             }
  2089.             CpuMgr.SwitchCpu();
  2090.         }
  2091.         //---------------------------------------------------------------------
  2092.        
  2093.     }
  2094.     //=========================================================================
  2095.    
  2096.    
  2097.    
  2098.     CpuMgr.SetCurrentCpu( current_cpu_back);
  2099.    
  2100.     */
  2101. }
  2102. //=============================================================================
  2103.  
  2104.  
  2105.  
  2106.  
  2107. //=============================================================================
  2108. void mon_step_x( int count)
  2109. {
  2110.     mon_step();
  2111.     //-------------------------------------------------------------------------
  2112.     for (int temp_cnt = 0;    temp_cnt < count;    temp_cnt++)
  2113.     {
  2114.         debugscr();             // р яюўхьє эх яюёых?
  2115.         debugflip();
  2116.        
  2117.         mon_step();
  2118.     }
  2119.     //-------------------------------------------------------------------------
  2120. }
  2121. //=============================================================================
  2122. void mon_step_x2() {    mon_step_x(   1); }
  2123. void mon_step_x4() {    mon_step_x(   3); }
  2124. void mon_step_x8() {    mon_step_x(   7); }
  2125. void mon_step_x16() {   mon_step_x(  15); }
  2126. void mon_step_x32() {   mon_step_x(  31); }
  2127. void mon_step_x64() {   mon_step_x(  63); }
  2128. void mon_step_x128() {  mon_step_x( 127); }
  2129. void mon_step_x256() {  mon_step_x( 255); }
  2130. //=============================================================================
  2131.  
  2132.  
  2133. //#define TWF_BRANCH  0x010000U
  2134. //#define TWF_BRADDR  0x020000U
  2135. //#define TWF_LOOPCMD 0x040000U
  2136. //#define TWF_CALLCMD 0x080000U
  2137. //#define TWF_BLKCMD  0x100000U
  2138. //#define TWF_HALTCMD 0x200000U
  2139.  
  2140. //=============================================================================
  2141. void mon_stepover_flags( int flags)
  2142. {
  2143.     Z80 &cpu = CpuMgr.Cpu();
  2144.     unsigned char trace = 1;
  2145.     //-------------------------------------------------------------------------
  2146.     // call,rst
  2147.     if (cpu.pc_trflags & TWF_CALLCMD)
  2148.     {
  2149.         cpu.dbg_stopsp = cpu.sp & 0xFFFF;       //??????
  2150.         cpu.dbg_stophere = cpu.nextpc;
  2151.         trace = 0;
  2152.     }
  2153.     //-------------------------------------------------------------------------
  2154. //  else if (cpu.pc_trflags & (TWF_BLKCMD | TWF_HALTCMD))
  2155.     else if (cpu.pc_trflags & (flags))                                  // [NS]      
  2156.     {
  2157.         trace = 0;
  2158.         cpu.dbg_stophere = cpu.nextpc;
  2159.     }
  2160.     //-------------------------------------------------------------------------  
  2161. /* [vv]
  2162.     // jr cc,$-xx, jp cc,$-xx
  2163.     else if ((cpu.pc_trflags & TWF_LOOPCMD) && (cpu.pc_trflags & 0xFFFF) < (cpu.pc & 0xFFFF))
  2164.     {
  2165.         cpu.dbg_stopsp = cpu.sp & 0xFFFF;
  2166.         cpu.dbg_stophere = cpu.nextpc,
  2167.         cpu.dbg_loop_r1 = cpu.pc_trflags & 0xFFFF;
  2168.         cpu.dbg_loop_r2 = cpu.pc & 0xFFFF;
  2169.         trace = 0;
  2170.     }
  2171. */
  2172.     //-------------------------------------------------------------------------
  2173. /*  [vv]
  2174.     else if (cpu.pc_trflags & TWF_BRANCH)
  2175.         trace = 1;
  2176.     else
  2177.     {
  2178.         trace = 1;
  2179.         cpu.dbg_stophere = cpu.nextpc;
  2180.     }
  2181. */
  2182.     //-------------------------------------------------------------------------
  2183.     //step over (step) ?
  2184.     if (trace)
  2185.     {
  2186.         mon_step();
  2187.     }
  2188.     //-------------------------------------------------------------------------
  2189.     //step over (call skip)
  2190.     else
  2191.     {
  2192.         cpu.dbgbreak = 0;
  2193.         dbgbreak = 0;
  2194.         cpu.dbgchk = 1;
  2195.     }
  2196.     //-------------------------------------------------------------------------
  2197. }
  2198. //=============================================================================
  2199. void mon_stepover()                                                     // [NS]
  2200. {
  2201. // ldir/lddr|cpir/cpdr|otir/otdr|inir/indr|halt
  2202.  
  2203.     mon_stepover_flags(         TWF_BLKCMD      |
  2204.                                 TWF_HALTCMD
  2205.                         );
  2206. }
  2207. //=============================================================================
  2208. void mon_stepover_jump()                                                // [NS]
  2209. {
  2210. // Єръ цх яЁюёъръштрхЄ jr cc jp cc djnz
  2211. // ═╬ эхъюЄюЁ√х єёыютш  юўхэ№ Ёхфъшх
  2212. // ш trace over ьюцхЄ ┬═┼╟└╧═╬ яЁхтЁрЄшЄёю т run
  2213. // яю¤Єюьє юЄфхы№эющ ъэюяъющ
  2214.  
  2215.     mon_stepover_flags(         TWF_BLKCMD      |
  2216.                                 TWF_HALTCMD     |
  2217.                                 TWF_LOOPCMD
  2218.                         );
  2219. }
  2220. //=============================================================================
  2221.  
  2222.  
  2223.  
  2224.