Subversion Repositories pentevo

Rev

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

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