Subversion Repositories pentevo

Rev

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

  1. #include "std.h"
  2.  
  3. #include "emul.h"
  4. #include "vars.h"
  5. #include "debug.h"
  6. #include "dbgpaint.h"
  7. #include "dbgreg.h"
  8.  
  9.  
  10.  
  11.  
  12. //#include "dbgtrace.h" //только для теста !!!! удалть
  13.  
  14.  
  15.  
  16. //=============================================================================
  17.  
  18. //struct TRegLayout
  19. //{
  20. //   size_t offs;
  21. //   unsigned char width;
  22. //   unsigned char x,y;
  23. //   unsigned char lf,rt,up,dn;
  24. //};
  25.  
  26. //в dbgreg.h
  27. /*
  28. #define         HEX_1           0x01
  29. #define         HEX_2           0x02
  30.  
  31. #define         HEX_8           0x08
  32. #define         HEX_16          0x10
  33.  
  34. #define         HEX_IM2         0x12
  35. #define         DEC_6T          0x76
  36.  
  37. #define         BIT_0           0xB0
  38. #define         BIT_1           0xB1
  39. #define         BIT_2           0xB2
  40. #define         BIT_3           0xB3
  41. #define         BIT_4           0xB4
  42. #define         BIT_5           0xB5
  43. #define         BIT_6           0xB6
  44. #define         BIT_7           0xB7
  45. */
  46.  
  47.  
  48. //=============================================================================
  49. // REG WINDOW DESIGN    [NS]
  50. //
  51. // POS_A POS_F  POS_A1 POS_F1   POS_SP                                          POS_I           POS_R
  52. // XX    XX     XX     XX       XX XX                                           XX              XX
  53. // POS_BC       POS_BC1         POS_PC  -->     -->     -->     -->     -->     -->     -->     POS_T
  54. // XX    XX     XX     XX       XX XX                                                           X
  55. // POS_DE       POS_DE1         POS_IX  -->     -->     POS_IM  <--     -->     -->     POS_IF1 POS_IF2
  56. // XX    XX     XX     XX       XX XX                   X                               X       X
  57. // POS_HL       POS_HL1         POS_IY  POS_FSF POS_FZF POS_FF5 POS_FHF POS_FF3 POS_FPV POS_FNF POS_FCF
  58. // XX    XX     XX     XX       XX XX   X       X       X       X       X       X       X       X
  59. //
  60. //=============================================================================
  61.  
  62. //              название        порядковый номер в regs_layout[] !!! (ниже)
  63. //              позиции         
  64. #define         POS_A           0
  65. #define         POS_F           1
  66.  
  67. #define         POS_BC          2
  68. #define         POS_DE          3
  69. #define         POS_HL          4
  70.  
  71. //#define       POS_AF1         5       //NS
  72. #define         POS_A1          5
  73.        
  74. #define         POS_BC1         6
  75. #define         POS_DE1         7
  76. #define         POS_HL1         8
  77.  
  78. #define         POS_SP          9
  79. #define         POS_PC          10
  80.        
  81. #define         POS_IX          11
  82. #define         POS_IY          12
  83.        
  84. #define         POS_I           13
  85. #define         POS_R           14
  86.        
  87. #define         POS_IM          15
  88. #define         POS_IF1         16      //IFF1
  89. #define         POS_IF2         17      //IFF2
  90.  
  91. #define         POS_FSF         18
  92. #define         POS_FZF         19
  93. #define         POS_FF5         20
  94. #define         POS_FHF         21
  95. #define         POS_FF3         22
  96. #define         POS_FPV         23
  97. #define         POS_FNF         24
  98. #define         POS_FCF         25
  99.  
  100. #define         POS_T           26      //NS   
  101. #define         POS_F1          27      //NS
  102.  
  103. // regs_layout[]
  104. // с целью обратной совместимости с возможно незамеченым гофнокодом
  105. // добавление новых значений идет в конец
  106.  
  107. const TRegLayout regs_layout[] =
  108. {       //                                                      порядковый номер соседних позиций для переходов
  109.         //              ,       ,  разрядность,      X,      Y,      left,   right,  up,     down
  110.         //                         (так же для                                                                 
  111.         //                         сдвигов!!!
  112.         //                         в оригинале)                                                                                                                              
  113.     { offsetof(TZ80State, a)    ,       HEX_8,  3,      0,      POS_A,  POS_F,  POS_A,  POS_BC  }, //  0 a
  114.     { offsetof(TZ80State, f)    ,       HEX_8,  5,      0,      POS_A,  POS_A1, POS_F,  POS_BC  }, //  1 f
  115.     { offsetof(TZ80State, bc)   ,       HEX_16, 3,      1,      POS_BC, POS_BC1,POS_A,  POS_DE  }, //  2 bc
  116.     { offsetof(TZ80State, de)   ,       HEX_16, 3,      2,      POS_DE, POS_DE1,POS_BC, POS_HL  }, //  3 de
  117.     { offsetof(TZ80State, hl)   ,       HEX_16, 3,      3,      POS_HL, POS_HL1,POS_DE, POS_HL  }, //  4 hl
  118.                                                                                                        
  119. //  { offsetof(TZ80State, alt.af),      HEX_16, 11,     0,      1,      9,      5,      6       }, //  5 af'
  120.     { offsetof(TZ80State, alt.a),       HEX_8,  11,     0,      POS_F,  POS_F1, POS_A1, POS_BC1 }, //  5 a'     //NS
  121.                                                                                                        
  122.     { offsetof(TZ80State, alt.bc),      HEX_16, 11,     1,      POS_BC, POS_PC, POS_A1, POS_DE1 }, //  6 bc'
  123.     { offsetof(TZ80State, alt.de),      HEX_16, 11,     2,      POS_DE, POS_IX, POS_BC1,POS_HL1 }, //  7 de'
  124.     { offsetof(TZ80State, alt.hl),      HEX_16, 11,     3,      POS_HL, POS_IY, POS_DE1,POS_HL1 }, //  8 hl'
  125.     { offsetof(TZ80State, sp)   ,       HEX_16, 19,     0,      POS_F1, POS_I,  POS_SP, POS_PC  }, //  9 sp
  126.     { offsetof(TZ80State, pc)   ,       HEX_16, 19,     1,      POS_BC1,POS_T,  POS_SP, POS_IX  }, // 10 pc
  127.     { offsetof(TZ80State, ix)   ,       HEX_16, 19,     2,      POS_DE1,POS_IM, POS_PC, POS_IY  }, // 11 ix
  128.     { offsetof(TZ80State, iy)   ,       HEX_16, 19,     3,      POS_HL1,POS_FSF,POS_IX, POS_IY  }, // 12 iy
  129.     { offsetof(TZ80State, i)    ,       HEX_8,  27,     0,      POS_SP, POS_R,  POS_I,  POS_T   }, // 13 i
  130.     { offsetof(TZ80State, r_low) ,      HEX_8,  30,     0,      POS_I,  POS_R,  POS_R,  POS_T   }, // 14 r
  131.     { offsetof(TZ80State, im)   ,       HEX_IM2,26,     2,      POS_IX, POS_IF1,POS_T,  POS_FF5 }, // 15 im
  132.     { offsetof(TZ80State, iff1) ,       HEX_1,  30,     2,      POS_IM, POS_IF2,POS_T,  POS_FNF }, // 16 iff1
  133.     { offsetof(TZ80State, iff2) ,       HEX_1,  31,     2,      POS_IF1,POS_IF2,POS_T,  POS_FCF }, // 17 iff2
  134.     { offsetof(TZ80State, f)     ,      BIT_7,  24,     3,      POS_IY, POS_FZF,POS_IM, POS_FSF }, // 18 SF
  135.     { offsetof(TZ80State, f)     ,      BIT_6,  25,     3,      POS_FSF,POS_FF5,POS_IM, POS_FZF }, // 19 ZF
  136.     { offsetof(TZ80State, f)     ,      BIT_5,  26,     3,      POS_FZF,POS_FHF,POS_IM, POS_FF5 }, // 20 F5
  137.     { offsetof(TZ80State, f)     ,      BIT_4,  27,     3,      POS_FF5,POS_FF3,POS_IM, POS_FHF }, // 21 HF
  138.     { offsetof(TZ80State, f)     ,      BIT_3,  28,     3,      POS_FHF,POS_FPV,POS_IF1,POS_FF3 }, // 22 F3
  139.     { offsetof(TZ80State, f)     ,      BIT_2,  29,     3,      POS_FF3,POS_FNF,POS_IF1,POS_FPV }, // 23 PV
  140.     { offsetof(TZ80State, f)     ,      BIT_1,  30,     3,      POS_FPV,POS_FCF,POS_IF1,POS_FNF }, // 24 NF
  141.     { offsetof(TZ80State, f)     ,      BIT_0,  31,     3,      POS_FNF,POS_FCF,POS_IF2,POS_FCF }, // 25 CF
  142.                                                                                                        
  143.     { offsetof(TZ80State, t)     ,      DEC_6T, 26,     1,      POS_PC, POS_T,  POS_R,  POS_IF1 }, // 26 t      //NS
  144.     { offsetof(TZ80State, alt.f),       HEX_8,  13,     0,      POS_A1, POS_SP, POS_F1, POS_BC1 }, // 27 f'     //NS
  145.         //              ,       ,  разрядность,      X,      Y,      left,   right,  up,     down                   
  146.                                                                                                                        
  147.                                                                                                                        
  148. };
  149.  
  150. // [NS] раньше тут был один не читаемый набор цифор...
  151.  
  152.  
  153. //=============================================================================
  154.  
  155. const size_t regs_layout_count = _countof(regs_layout);
  156.  
  157. //=============================================================================
  158. void showregs()
  159. {
  160.  
  161. //переместить в debug.h !!!!
  162. #define DBG_ATTR_BCKGRND        0x00    //0     0
  163. #define DBG_ATTR_BCKGRND_ACTIVE 0x10    //blue  0
  164. #define DBG_ATTR_BCKGRND_BRIGHT 0X80    //br+   0
  165.  
  166. #define DBG_ATTR_REGS_NAMES     0x0C    //0             br+GREEN
  167. #define DBG_ATTR_REGS_VALUES    0x0F    //0             br+WHITE
  168. #define DBG_ATTR_REGS_CHANGED   0X0E    //0             br+YELLOW
  169. #define DBG_ATTR_REGS_SELECTED  0xB0    //br+MAGENTA    0
  170.  
  171. #define DBG_ATTR_REGS_DIHALT    0x0A    //0     br+RED
  172.  
  173. //#define DBG_ATTR_REGS_TITLE   0x51    //cyan blue
  174.  
  175. #define DBG_ATTR_TITLES         0x5D//0x71      //white blue
  176.  
  177.     Z80 &cpu = CpuMgr.Cpu();
  178.     const TZ80State &prevcpu = CpuMgr.PrevCpu();
  179.  
  180. //   unsigned char atr = (activedbg == WNDREGS) ? W_SEL :       //0x17 blue  white      (выделенное окно)
  181. //                                                W_NORM;       //0x07 black white
  182.     unsigned char current_back_attr = (activedbg == WNDREGS) ?  DBG_ATTR_BCKGRND_ACTIVE :       //(выделенное окно)
  183.                                                                 DBG_ATTR_BCKGRND;
  184.  
  185.     unsigned char attr1 = current_back_attr | DBG_ATTR_REGS_NAMES;
  186.     char line[40];
  187. //  tprint(regs_x,regs_y+0, "af:**** af'**** sp:**** ir: ****", attr1);
  188. //  tprint(regs_x,regs_y+1, "bc:**** bc'**** pc:**** t:******", attr1);
  189. //  tprint(regs_x,regs_y+2, "de:**** de'**** ix:**** im?,i:**", attr1);
  190. //  tprint(regs_x,regs_y+3, "hl:**** hl'**** iy:**** ########", attr1);
  191.    
  192.     tprint(regs_x,regs_y+0, "af:**** af'**** sp:**** ir:** **", attr1);
  193.     tprint(regs_x,regs_y+1, "bc:**** bc'**** pc:**** t:******", attr1);
  194.     tprint(regs_x,regs_y+2, "de:**** de'**** ix:**** im? i:**", attr1);
  195.     tprint(regs_x,regs_y+3, "hl:**** hl'**** iy:**** ########", attr1);
  196.    
  197. //-----------------------------------------------------------------------------
  198. unsigned char attr_values = (current_back_attr | DBG_ATTR_REGS_VALUES);
  199. //-----------------------------------------------------------------------------
  200. // Отрисовка числа тактов
  201.     if (cpu.halted && !cpu.iff1)
  202.     {
  203.         //если di:halt такты не рисуютсо
  204. //      tprint( regs_x+26,
  205. //              regs_y+1,
  206. //              "DiHALT",
  207. //              (activedbg == WNDREGS) ?        W_DIHALT1 :     //0x1A red
  208. //                                              W_DIHALT2       //0x0A
  209. //             );
  210.         tprint( regs_x+26,              //NS
  211.                 regs_y+1,
  212.                 "DiHALT",
  213.                 ( current_back_attr | DBG_ATTR_REGS_DIHALT )
  214.                );
  215.     }
  216.     else
  217.     {
  218.         sprintf(        line,
  219.                         "%6u",
  220.                         cpu.t
  221.                 );
  222.         tprint(    regs_x+26,
  223.                    regs_y+1,
  224.                    line,
  225.                    ((regs_curs == POS_T) && (activedbg == WNDREGS))  ?  (current_back_attr | DBG_ATTR_REGS_SELECTED | DBG_ATTR_BCKGRND_BRIGHT) :
  226.                                                                         attr_values
  227.                 );
  228.     }
  229.        
  230. //-----------------------------------------------------------------------------
  231. // Отрисовка значений регистров
  232.     cpu.r_low = (cpu.r_low & 0x7F) + cpu.r_hi;
  233.    
  234.     for (unsigned i = 0; i < regs_layout_count; i++)
  235.     {
  236.         unsigned mask;  // = (1 << regs_layout[i].width) - 1;
  237.         switch (regs_layout[i].width)
  238.         {
  239.             case HEX_1:         mask = 0x01;     break;
  240.             case HEX_IM2:       mask = 0x03;     break;
  241.             case HEX_8:         mask = 0xFF;     break;
  242.             case HEX_16:        mask = 0xFFFF;   break;
  243.             default:            mask = 0;
  244.                
  245.         }
  246.         //текущее значение регистра
  247.         unsigned val =  mask
  248.                         &
  249.                         *(unsigned*) ( PCHAR((TZ80State*)&cpu) + regs_layout[i].offs );
  250.  
  251.         //---------------------------------------------------------------------
  252.         // генерируем атрибут для текущего регистра
  253.         //---------------------------------------------------------------------
  254.         // подсветка изменившегося значения регистров
  255.         if (    val != (        mask
  256.                                 &
  257.                                 *(unsigned*) ( PCHAR(&prevcpu) + regs_layout[i].offs ) // пред значение регистра
  258.                         )
  259.           )
  260.         {
  261. //          atr1 |= 0x08;                              
  262.             attr1 = (current_back_attr | DBG_ATTR_REGS_CHANGED);
  263.         }
  264.         //---------------------------------------------------------------------
  265.         // регистр без изменений
  266.         else
  267.         {
  268.             attr1 = attr_values;
  269.         }
  270.         //---------------------------------------------------------------------
  271.         // подсветка/выделение ткнутых курсором регистров
  272.         if (    (activedbg == WNDREGS) &&
  273.                 (i == regs_curs)
  274.           )
  275.         {
  276. //          atr1 = W_CURS; // 0x30             
  277.             attr1 = (current_back_attr | DBG_ATTR_REGS_SELECTED | DBG_ATTR_BCKGRND_BRIGHT);
  278.         }
  279.         //---------------------------------------------------------------------
  280.         //printf("regs_curs %d\n",regs_curs);
  281.  
  282.     //-------------------------------------------------------------------------
  283.     // генерируем строку разной ширины для 8/16 битных итд значений
  284.     char bf[16];
  285.     switch (regs_layout[i].width)
  286.     {
  287.          case HEX_1:
  288.          case HEX_IM2:  sprintf(bf,     "%01X", val); break;
  289.          case HEX_8:    sprintf(bf,     "%02X", val); break;
  290.          case HEX_16:   sprintf(bf,     "%04X", val); break;
  291.         //такты рисуютсо отдельно !!
  292.          default:       *bf = 0;
  293.     }
  294.     // рисуем строку
  295.     tprint(     regs_x + regs_layout[i].x,
  296.                 regs_y + regs_layout[i].y,
  297.                 bf,
  298.                 attr1   //атрибут в зависимости от состояния регистра
  299.            );
  300.    }
  301. //-----------------------------------------------------------------------------
  302. // отрисовка флагов
  303. //  static const char flg[] = "SZ5H3PNCsz.h.pnc";       //зачем то объявляетсо каждый раз :)
  304.     static const char flg[] = "SZ5H3PNCsz_h_pnc";       //зачем то объявляетсо каждый раз :)
  305.     for (unsigned char q = 0; q < 8; q++)
  306.     {      
  307.         //---------------------------------------------------------------------
  308.         // генерируем атрибут для текущего флага
  309.         //---------------------------------------------------------------------
  310.         unsigned ln;
  311.         ln = unsigned ( flg     [ q + ( (cpu.af & (0x80>>q)) ?  0 :
  312.                                                                 8
  313.                                         )
  314.                                  ]
  315.                         );
  316.         //---------------------------------------------------------------------
  317.         // подсветка изменившегося значения регистров                   
  318.         if ( (0x80 >> q) & (cpu.f ^ prevcpu.f) )
  319.         {
  320.             //atr1 |= 0x08;     //подсветка изменившихся флагов
  321.             attr1 = (current_back_attr | DBG_ATTR_REGS_CHANGED);
  322.         }
  323.         //---------------------------------------------------------------------
  324.         // дефолтный атрибут для флагов
  325.         else
  326.         {
  327.             attr1 = attr_values;
  328.         }
  329.         //---------------------------------------------------------------------
  330.         // подсветка выделения курсором ткнутых флагов
  331.         if (    (activedbg == WNDREGS)                  &&
  332.                 (regs_curs == (unsigned)(q+18))
  333.           )
  334.         {
  335.             //atr1 = W_CURS;    //выделение флагов курсором
  336.             attr1 = (current_back_attr | DBG_ATTR_REGS_SELECTED | DBG_ATTR_BCKGRND_BRIGHT);
  337.         }
  338.         //---------------------------------------------------------------------
  339.        
  340.         // рисуем флаг       
  341.         tprint(         regs_x + 24 + q,
  342.                         regs_y + 3,
  343.                         (char*) &ln,
  344.                         attr1
  345.                );
  346.     } //for
  347. //-----------------------------------------------------------------------------
  348.     //заголовок окна
  349.     tprint(     regs_x,
  350.                 regs_y-1,
  351.                 "Regs",
  352.                 DBG_ATTR_TITLES //DBG_ATTR_REGS_TITLE   //W_TITLE               //0x59  cyan brght+blue
  353.            );
  354. //-----------------------------------------------------------------------------
  355.     //рамочка вокруг окна
  356.     frame(      regs_x,
  357.                 regs_y,
  358.                 32,
  359.                 4,
  360.                 FRAME           //0x01
  361.           );
  362. } //void showregs()
  363. //=============================================================================
  364.  
  365.  
  366. //=============================================================================
  367. void rleft() { regs_curs = regs_layout[regs_curs].lf; }         // "reg.left" хоткей
  368. //=============================================================================
  369. void rright() { regs_curs = regs_layout[regs_curs].rt; }        // "reg.right" хоткей
  370. //=============================================================================
  371. void rup() { regs_curs = regs_layout[regs_curs].up; }           // "reg.up" хоткей
  372. //=============================================================================
  373. void rdown() { regs_curs = regs_layout[regs_curs].dn; }         // "reg.down" хоткей
  374. //=============================================================================
  375.  
  376.  
  377. //=============================================================================
  378. void renter()                                           // "reg.edit" хоткей
  379. {
  380.     Z80 &cpu = CpuMgr.Cpu();
  381.    
  382.     debugscr();
  383.     debugflip();
  384.    
  385.     unsigned char sz = regs_layout[ regs_curs].width;
  386.  
  387.    
  388.     unsigned mask;                                      // [NS]
  389.     //-------------------------------------------------------------------------
  390.     switch (sz)
  391.     {
  392.         case HEX_1:             mask = 0x01;            break;
  393.         case HEX_IM2:           mask = 0x03;            break;
  394.         case HEX_8:             mask = 0xFF;            break;
  395.         case HEX_16:            mask = 0xFFFF;          break;
  396.         case DEC_6T:            mask = 0xFFFFFFFF;      break;
  397.         default:                mask = 0;      
  398.     }
  399.     //-------------------------------------------------------------------------
  400.    
  401.     unsigned val =      mask    //( (1 << sz) - 1)      // подрязка исходных значений
  402.                         &                               // перед отображением при редактировании
  403.                         *(unsigned*)( PCHAR(( TZ80State*)&cpu) + regs_layout[ regs_curs].offs);
  404.                        
  405.     unsigned char *ptr = PUCHAR(( TZ80State*)&cpu) + regs_layout[ regs_curs].offs;
  406.  
  407.     u8 Kbd[ 256];
  408.     GetKeyboardState( Kbd);
  409.     unsigned short k = 0;
  410.     //-------------------------------------------------------------------------
  411.     if ( ToAscii(       input.lastkey,
  412.                         0,
  413.                         Kbd,
  414.                         &k,
  415.                         0   )   != 1
  416.       )
  417.     {
  418.         //printf("return ");
  419.         return;    
  420.     }
  421.     //-------------------------------------------------------------------------
  422.     u8 u = u8( toupper( k));
  423.     //-------------------------------------------------------------------------
  424.     // послать повторно код клавиши
  425.     // чтобы сразу пошел ввод этой клавиши
  426.     // а не вход в режим ввода а только по след кнопке ввод
  427.     if (   (    (sz == HEX_8)   ||
  428.                 (sz == HEX_16)  ||
  429.                 (sz == DEC_6T)  ||
  430.                 (sz == HEX_IM2)
  431.             )
  432.            &&
  433.            (    (u >= '0' && u <= '9')  ||
  434.                 (u >= 'A' && u <= 'F')
  435.             )
  436.      )
  437.     {
  438.         PostThreadMessage(      GetCurrentThreadId(),   //????????
  439.                                 WM_KEYDOWN,
  440.                                 input.lastkey,
  441.                                 1
  442.                           );
  443.     }
  444.     //-------------------------------------------------------------------------
  445.     switch (sz)
  446.     {
  447.         //---------------------------------------------------------------------
  448.         case HEX_8:
  449.             val = unsigned(input2(regs_x + regs_layout[regs_curs].x, regs_y + regs_layout[regs_curs].y, val));
  450.             //-----------------------------------------------------------------
  451.             if (int(val) != -1)
  452.                 *ptr = u8(val);
  453.             //-----------------------------------------------------------------
  454.             break;
  455.         //---------------------------------------------------------------------
  456.         case HEX_16:
  457.             val = unsigned(input4(regs_x + regs_layout[regs_curs].x, regs_y + regs_layout[regs_curs].y, val));
  458.             //-----------------------------------------------------------------
  459.             if (int(val) != -1)
  460.                 *(unsigned short*)ptr = u16(val);
  461.             //-----------------------------------------------------------------
  462.             break;
  463.         //---------------------------------------------------------------------
  464.         case DEC_6T:    //24:   //редактор тактов //NS
  465.             val = unsigned(input6dec(regs_x + regs_layout[regs_curs].x, regs_y + regs_layout[regs_curs].y, val));
  466.             //printf ("val1 %x\n",val);
  467.             //-----------------------------------------------------------------
  468.             if (int(val) != -1)
  469.             {
  470.                 // *(unsigned short*)ptr = u32(val);
  471.                 if (int(val) < cpu.tpi) //frametime)    //cpu.tpi только ZX но не GS!!!!!!
  472.                 {
  473.                     *(int*)ptr = int(val);
  474.                 }
  475.                 //-------------------------------------------------------------
  476.                 else
  477.                 {
  478.                     *(int*)ptr = (cpu.tpi-1);   //(frametime-1);       
  479.                                                 // если вписать число тактов больше чем есть
  480.                                                 // то происходит какаято херня
  481.                                                 // с считанием тактов назад ~ до frametime
  482.                                                 // так же не ясно точно за frametime-1
  483.                                                 // вроде бы 0-й такт есть
  484.                 }
  485.             }
  486.             //-----------------------------------------------------------------
  487.             //printf ("val2 %x\n",val);
  488.             //printf ("frametime %d\n",frametime);
  489.             break;
  490.         //---------------------------------------------------------------------
  491.         case HEX_1:
  492.             *ptr ^= 1; break;                   //тупой ксор
  493.         //---------------------------------------------------------------------
  494.         case HEX_IM2:   //im2
  495.             //*ptr = (*ptr + 1) % 3; break;     //тупое ущербное гоняние по кругу 0,1,2,0,1...
  496.          
  497.             // нормальный ввод ручками [NS]
  498.             val = unsigned(input1(regs_x + regs_layout[regs_curs].x, regs_y + regs_layout[regs_curs].y, val));
  499.             //-----------------------------------------------------------------
  500.             if (int(val) != -1)
  501.             {
  502.                 if (int(val) < 3)
  503.                     *ptr = u8(val);
  504.             }
  505.             //-----------------------------------------------------------------
  506.             break;
  507.         //---------------------------------------------------------------------
  508.         case BIT_0:                                   //default: // flags
  509.         case BIT_1:
  510.         case BIT_2:
  511.         case BIT_3:
  512.         case BIT_4:
  513.         case BIT_5:
  514.         case BIT_6:
  515.         case BIT_7:
  516.             *ptr ^= (1 << (sz - BIT_0));
  517.         //---------------------------------------------------------------------
  518.     }
  519.     cpu.r_hi = cpu.r_low & 0x80;
  520.    
  521.    
  522.     // если редактируем то зачем следим то включаем слежение
  523.    
  524.     switch (conf.trace_follow_regs)
  525.     {
  526.         case 1:
  527.             if ((regs_layout[ regs_curs].offs) == (offsetof( TZ80State, af)))
  528.                 conf.trace_follow_request = 1;
  529.             break;
  530.         case 2:
  531.             if ((regs_layout[ regs_curs].offs) == (offsetof( TZ80State, bc)))
  532.                 conf.trace_follow_request = 1;
  533.             break;
  534.         case 3:
  535.             if ((regs_layout[ regs_curs].offs) == (offsetof( TZ80State, de)))
  536.                 conf.trace_follow_request = 1;
  537.             break;
  538.         case 4:
  539.             if ((regs_layout[ regs_curs].offs) == (offsetof( TZ80State, hl)))
  540.                 conf.trace_follow_request = 1;
  541.             break;
  542.            
  543.         case 5:
  544.             if ((regs_layout[ regs_curs].offs) == (offsetof( TZ80State, alt.af)))
  545.                 conf.trace_follow_request = 1;
  546.             break;
  547.         case 6:
  548.             if ((regs_layout[ regs_curs].offs) == (offsetof( TZ80State, alt.bc)))
  549.                 conf.trace_follow_request = 1;
  550.             break;
  551.         case 7:
  552.             if ((regs_layout[ regs_curs].offs) == (offsetof( TZ80State, alt.de)))
  553.                 conf.trace_follow_request = 1;
  554.             break;
  555.         case 8:
  556.             if ((regs_layout[ regs_curs].offs) == (offsetof( TZ80State, alt.hl)))
  557.                 conf.trace_follow_request = 1;
  558.             break;
  559.            
  560.         case 9:
  561.             if ((regs_layout[ regs_curs].offs) == (offsetof( TZ80State, ix)))
  562.                 conf.trace_follow_request = 1;
  563.             break;
  564.         case 10:
  565.             if ((regs_layout[ regs_curs].offs) == (offsetof( TZ80State, iy)))
  566.                 conf.trace_follow_request = 1;
  567.             break;
  568.            
  569.         case 11:
  570.             if ((regs_layout[ regs_curs].offs) == (offsetof( TZ80State, sp)))
  571.                 conf.trace_follow_request = 1;
  572.             break;
  573.         case 12:
  574.             if ((regs_layout[ regs_curs].offs) == (offsetof( TZ80State, pc)))
  575.                 conf.trace_follow_request = 1;
  576.             break;
  577.     }
  578.  
  579.  
  580.  
  581.  
  582.  
  583.  
  584.  
  585.  //   conf.trace_follow_request = 1;    //следовать за чем нибудь   // [NS]
  586.         //printf("showtrace\n");
  587.         //showtrace();
  588.        //debugflip();   //tst
  589. }
  590. //=============================================================================
  591.  
  592.  
  593. // в us0.38.0 и ниже это было переход и редактирование
  594. // с us0.38.1 это работает как только выделение
  595. // в Unreal TS это тоже работает как переход и редактирование
  596. //=============================================================================
  597. void ra() { regs_curs = 0; input.lastkey = 0; renter(); }       // "reg.a" хоткей
  598. //=============================================================================
  599. void rf() { regs_curs = 1; input.lastkey = 0; renter(); }       // "reg.f" хоткей
  600. //=============================================================================
  601. void rbc() { regs_curs = 2; input.lastkey = 0; renter(); }      // "reg.bc" хоткей
  602. //=============================================================================
  603. void rde() { regs_curs = 3; input.lastkey = 0; renter(); }      // "reg.de" хоткей
  604. //=============================================================================
  605. void rhl() { regs_curs = 4; input.lastkey = 0; renter(); }      // "reg.hl" хоткей
  606. //=============================================================================
  607. void rsp() { regs_curs = 9; input.lastkey = 0; renter(); }      // "reg.sp" хоткей
  608. //=============================================================================
  609. void rpc() { regs_curs = 10; input.lastkey = 0; renter(); }     // "reg.pc" хоткей
  610. //=============================================================================
  611. void rix() { regs_curs = 11; input.lastkey = 0; renter(); }     // "reg.ix" хоткей
  612. //=============================================================================
  613. void riy() { regs_curs = 12; input.lastkey = 0; renter(); }     // "reg.iy" хоткей
  614. //=============================================================================
  615. void ri() { regs_curs = 13; input.lastkey = 0; renter(); }      // "reg.i" хоткей
  616. //=============================================================================
  617. void rr() { regs_curs = 14; input.lastkey = 0; renter(); }      // "reg.r" хоткей
  618. //=============================================================================
  619. void rm() { regs_curs = 15; renter(); }                         // "reg.im" хоткей
  620. //=============================================================================
  621. void r_1() { regs_curs = 16; renter(); }                        // "reg.iff1" хоткей
  622. //=============================================================================
  623. void r_2() { regs_curs = 17; renter(); }                        // "reg.iff2" хоткей
  624. //=============================================================================
  625. void rSF() { regs_curs = 18; renter(); }                        // "reg.SF" хоткей
  626. //=============================================================================
  627. void rZF() { regs_curs = 19; renter(); }                        // "reg.ZF" хоткей
  628. //=============================================================================
  629. void rF5() { regs_curs = 20; renter(); }                        // "reg.F5" хоткей
  630. //=============================================================================
  631. void rHF() { regs_curs = 21; renter(); }                        // "reg.HF" хоткей
  632. //=============================================================================
  633. void rF3() { regs_curs = 22; renter(); }                        // "reg.F3" хоткей
  634. //=============================================================================
  635. void rPF() { regs_curs = 23; renter(); }                        // "reg.PF" хоткей
  636. //=============================================================================
  637. void rNF() { regs_curs = 24; renter(); }                        // "reg.NF" хоткей
  638. //=============================================================================
  639. void rCF() { regs_curs = 25; renter(); }                        // "reg.CF" хоткей
  640. //=============================================================================
  641.  
  642.  
  643. //=============================================================================
  644. // goto address in code window under cursor             // в меню WNDREGS
  645. void rcodejump()                                        // и "reg.codejump" хоткей
  646. {
  647.     Z80 &cpu = CpuMgr.Cpu();
  648.    
  649.     if (        (regs_layout[regs_curs].width == HEX_16)        ||
  650.                 (regs_curs == POS_A)                    ||      //a, f по своему правилу
  651.                 (regs_curs == POS_F)                    ||
  652.                 (regs_curs == POS_A1)                   ||
  653.                 (regs_curs == POS_F1)
  654.       )
  655.     {
  656.                 // НЕ ЛОЖИТ В СТЕК ПЕРЕХОДОВ !!!!!!
  657.                 // тут ничего не объявлено надо подключать из dbgtrace и править makefile
  658.                 // push_pos();
  659.                 // memmove(&stack_pos[1], &stack_pos[0], sizeof stack_pos - sizeof *stack_pos);
  660.                 // memmove(&stack_cur[1], &stack_cur[0], sizeof stack_cur - sizeof *stack_cur);
  661.                 // stack_pos[0] = cpu.trace_top; stack_cur[0] = cpu.trace_curs;
  662.  
  663.          activedbg = WNDTRACE;
  664.          
  665.         if (    (regs_curs == POS_A)    ||      //половнки регов трактуем как весь AF       [NS]
  666.                 (regs_curs == POS_F)            //думаю чаще надо будет смотреть (AF) чем (A) или (F)
  667.           )
  668.         {
  669.             cpu.trace_curs = cpu.trace_top = *(unsigned short*)(PCHAR((TZ80State*)&cpu) + offsetof(TZ80State, af));
  670.         }
  671.         else if ( (regs_curs == POS_A1) ||
  672.                   (regs_curs == POS_F1)
  673.           )
  674.         {
  675.             cpu.trace_curs = cpu.trace_top = *(unsigned short*)(PCHAR((TZ80State*)&cpu) + offsetof(TZ80State, alt.af));
  676.         }
  677.         else
  678.         {
  679.             cpu.trace_curs = cpu.trace_top = *(unsigned short*)(PCHAR((TZ80State*)&cpu) + regs_layout[regs_curs].offs);
  680.         }
  681.          
  682.     }
  683.     // НУЖНА ОБРАБОТКА 8 БИТНЫХ AF
  684.     //          влоб работает как goto (00Aa) и goto (AaFf)
  685.     //          а не как goto (00Aa) и goto (00Ff)
  686.     //          и не как goto (AaFf) в обоих случаях
  687.     //          что не есть предсказуеммо
  688.    
  689.     // НЕ ЗАКИДЫВАЕТ АДРЕС В СТЕК!!!!
  690. }
  691. //=============================================================================
  692.  
  693.  
  694. //=============================================================================
  695. // goto address in data window under cursor                     // в меню WNDREGS
  696. void rdatajump()                                                // "reg.datajump" хоткей
  697. {
  698.     Z80 &cpu = CpuMgr.Cpu();
  699.     if (        (regs_layout[regs_curs].width == HEX_16)        ||
  700.                 (regs_curs == POS_A)                            ||      //a, f по своему правилу
  701.                 (regs_curs == POS_F)                            ||
  702.                 (regs_curs == POS_A1)                           ||
  703.                 (regs_curs == POS_F1)
  704.       )
  705.     {
  706.         activedbg = WNDMEM;
  707.         editor = ED_MEM;
  708.         if (    (regs_curs == POS_A)    ||      //половнки регов трактуем как весь AF       [NS]
  709.                 (regs_curs == POS_F)            //думаю чаще надо будет смотреть (AF) чем (A) или (F)
  710.           )
  711.         {
  712.             cpu.mem_curs = *(unsigned short*)(PCHAR((TZ80State*)&cpu) + offsetof(TZ80State, af));
  713.         }
  714.         else if ( (regs_curs == POS_A1) ||
  715.                   (regs_curs == POS_F1)
  716.           )
  717.         {
  718.             cpu.mem_curs = *(unsigned short*)(PCHAR((TZ80State*)&cpu) + offsetof(TZ80State, alt.af));
  719.         }
  720.         else
  721.         {
  722.             cpu.mem_curs = *(unsigned short*)(PCHAR((TZ80State*)&cpu) + regs_layout[regs_curs].offs);
  723.         }
  724.        
  725.        
  726.     }
  727. }
  728. //=============================================================================
  729.  
  730.  
  731. //=============================================================================
  732. // начало правки в окне регистров
  733. char dispatch_regs()
  734. {
  735.     if ((input.lastkey >= '0' && input.lastkey <= '9') || (input.lastkey >= 'A' && input.lastkey <= 'F'))
  736.     {
  737.         renter();
  738.         return 1;
  739.     }
  740.     return 0;
  741. }
  742. //=============================================================================
  743.  
  744.