Subversion Repositories pentevo

Rev

Rev 1090 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

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