Subversion Repositories pentevo

Rev

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

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