Subversion Repositories pentevo

Rev

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

  1. #include "std.h"
  2.  
  3. #include "resource.h"
  4. #include "emul.h"
  5. #include "vars.h"
  6. #include "debug.h"
  7. #include "dbgbpx.h"
  8. #include "dbgcmd.h"
  9. #include "config.h"
  10. #include "util.h"
  11.  
  12. #include "emul_no_modal_windows.h"      // hwnd-ы немодальных окон [NS]
  13. #include "dx.h"                         // OnEnterGui [NS]
  14. #include "draw.h"                       // apply_video() [NS]
  15.  
  16. //=============================================================================
  17. bool group_bpx_list = TRUE;                                             // [NS]
  18. bool group_bpr_list = TRUE;
  19. bool group_bpw_list = TRUE;
  20. //=============================================================================
  21. enum
  22. {
  23.     DB_STOP = 0,
  24.     DB_CHAR,
  25.     DB_SHORT,
  26.     DB_PCHAR,
  27.     DB_PSHORT,
  28.     DB_PINT,
  29.     DB_PFUNC
  30. };
  31. //=============================================================================
  32. typedef bool (__cdecl *func_t)();
  33.  
  34. static unsigned calcerr;
  35.  
  36. //=============================================================================
  37. unsigned calc( const Z80 *cpu, uintptr_t *script)
  38. {
  39.     unsigned stack[ 64];
  40.     unsigned *sp = stack-1, x;
  41.     //-------------------------------------------------------------------------
  42.     while (*script)
  43.     {
  44.         switch (*script++)
  45.         {
  46.             case 'M':                   *sp = cpu->DirectRm(*sp);               break;
  47.             case '!':                   *sp = ! *sp;                            break;
  48.             case '~':                   *sp = ~ *sp;                            break;
  49.             case '+':                   *(sp-1) += *sp;                         goto arith;
  50.             case '-':                   *(sp-1) -= *sp;                         goto arith;
  51.             case '*':                   *(sp-1) *= *sp;                         goto arith;
  52.             case '/':   if (*sp)        *(sp-1) /= *sp;                         goto arith;
  53.             case '%':   if (*sp)        *(sp-1) %= *sp;                         goto arith;
  54.             case '&':                   *(sp-1) &= *sp;                         goto arith;
  55.             case '|':                   *(sp-1) |= *sp;                         goto arith;
  56.             case '^':                   *(sp-1) ^= *sp;                         goto arith;
  57.             case WORD2('-','>'):        *(sp-1) = cpu->DirectRm(*sp + sp[-1]);  goto arith;
  58.             case WORD2('>','>'):        *(sp-1) >>= *sp;                        goto arith;
  59.             case WORD2('<','<'):        *(sp-1) <<= *sp;                        goto arith;
  60.             case WORD2('!','='):        *(sp-1) = (sp[-1] != *sp);              goto arith;
  61.             case '=':
  62.             case WORD2('=','='):        *(sp-1) = (sp[-1] == *sp);              goto arith;
  63.             case WORD2('<','='):        *(sp-1) = (sp[-1] <= *sp);              goto arith;
  64.             case WORD2('>','='):        *(sp-1) = (sp[-1] >= *sp);              goto arith;
  65.             case WORD2('|','|'):        *(sp-1) = (sp[-1] || *sp);              goto arith;
  66.             case WORD2('&','&'):        *(sp-1) = (sp[-1] && *sp);              goto arith;
  67.             case '<':                   *(sp-1) = (sp[-1] < *sp);               goto arith;
  68.             case '>':                   *(sp-1) = (sp[-1] > *sp);               goto arith;
  69. arith:                sp--;  break;
  70.             case DB_CHAR:
  71.             case DB_SHORT:              x = unsigned(*script++);                goto push;
  72.             case DB_PCHAR:              x = *(unsigned char*)*script++;         goto push;
  73.             case DB_PSHORT:             x = 0xFFFF & *(unsigned*)*script++;     goto push;
  74.             case DB_PINT:               x = *(unsigned*)*script++;              goto push;
  75.             case DB_PFUNC:              x = ((func_t)*script++)();              goto push;
  76. push:                 *++sp = x; break;
  77.         } // switch (*script)
  78.     } // while
  79.     //-------------------------------------------------------------------------
  80.     if (sp != stack)
  81.         calcerr = 1;
  82.     //-------------------------------------------------------------------------
  83.     return *sp;
  84. }
  85. //=============================================================================
  86.  
  87.  
  88. //=============================================================================
  89. static bool __cdecl get_dos_flag()
  90. {
  91.     return (comp.flags & CF_DOSPORTS) != 0;
  92. }
  93. //=============================================================================
  94.  
  95. //=============================================================================
  96. // АХТУНХ! В ЭТОЙ КОНСТРУКЦИИ НЕЛЬЗЯ НОРМАЛЬНО КОМЕНТИТЬ !!!
  97. //
  98. // соблюдать неповторяемость начал обратной елочкой !!!
  99. // ABCD
  100. // AB2
  101. // AB
  102. // A
  103. // ибо сработает только самое первое похожее
  104. // A
  105. // ABCD = AB
  106. // AB2
  107. // AB
  108.  
  109.  
  110. #define DECL_REGS(var, cpu)                                                     \
  111.     static struct                                                               \
  112.     {                                                                           \
  113.         unsigned reg;                                                           \
  114.         const void *ptr;                                                        \
  115.         unsigned char size;                                                     \
  116.     } var[] =                                                                   \
  117.     {                                                                           \
  118.                                                                                 \
  119.         { WORD4('I','N','T', 0 ),       &cpu.iff1,   1  },       /* INT [NS] */ \
  120.         { WORD4('I','F','2', 0 ),       &cpu.iff2,   1  },       /* IF2 [NS] */ \
  121.         { WORD4('H','L','T', 0 ),       &cpu.halted, 1  },       /* HLT [NS] */ \
  122.         { WORD2('I','M'),               &cpu.im, 1 },         /* IM = 0 [NS] */ \
  123.                                                               /* IM = 1 [NS] */ \
  124.                                                               /* IM = 2 [NS] */ \
  125.                                                                                 \
  126.         { WORD4('D','O','S', 0 ), (const void *)get_dos_flag, 0 }, /* DOS */    \
  127.         { WORD4('O','U','T', 0 ),       &brk_port_out,  4  },      /* OUT */    \
  128.         { WORD2('I','N'),               &brk_port_in,   4  },      /* IN  */    \
  129.         { WORD4('V','A','L', 0 ),       &brk_port_val,  1  },      /* VAL */    \
  130.         { WORD2('F','D'),               &comp.p7FFD,    1  },      /* FD  */    \
  131.                                                                                 \
  132.         { WORD4('A','F','\'', 0 ),      &cpu.alt.af, 2  },                      \
  133.         { WORD4('B','C','\'', 0 ),      &cpu.alt.bc, 2  },                      \
  134.         { WORD4('D','E','\'', 0 ),      &cpu.alt.de, 2  },                      \
  135.         { WORD4('H','L','\'', 0 ),      &cpu.alt.hl, 2  },                      \
  136.         { WORD2('A','\''),              &cpu.alt.a,  1  },                      \
  137.         { WORD2('F','\''),              &cpu.alt.f,  1  },                      \
  138.         { WORD2('B','\''),              &cpu.alt.b,  1  },                      \
  139.         { WORD2('C','\''),              &cpu.alt.c,  1  },                      \
  140.         { WORD2('D','\''),              &cpu.alt.d,  1  },                      \
  141.         { WORD2('E','\''),              &cpu.alt.e,  1  },                      \
  142.         { WORD2('H','\''),              &cpu.alt.h,  1  },                      \
  143.         { WORD2('L','\''),              &cpu.alt.l,  1  },                      \
  144.                                                                                 \
  145.         { WORD4('a','f','\'', 0 ),      &cpu.alt.af, 2  },      /* [NS] */      \
  146.         { WORD4('b','c','\'', 0 ),      &cpu.alt.bc, 2  },      /* [NS] */      \
  147.         { WORD4('d','e','\'', 0 ),      &cpu.alt.de, 2  },      /* [NS] */      \
  148.         { WORD4('h','l','\'', 0 ),      &cpu.alt.hl, 2  },      /* [NS] */      \
  149.         { WORD4('a','F','\'', 0 ),      &cpu.alt.af, 2  },      /* [NS] */      \
  150.         { WORD4('b','C','\'', 0 ),      &cpu.alt.bc, 2  },      /* [NS] */      \
  151.         { WORD4('d','E','\'', 0 ),      &cpu.alt.de, 2  },      /* [NS] */      \
  152.         { WORD4('h','L','\'', 0 ),      &cpu.alt.hl, 2  },      /* [NS] */      \
  153.         { WORD4('A','f','\'', 0 ),      &cpu.alt.af, 2  },      /* [NS] */      \
  154.         { WORD4('B','c','\'', 0 ),      &cpu.alt.bc, 2  },      /* [NS] */      \
  155.         { WORD4('D','e','\'', 0 ),      &cpu.alt.de, 2  },      /* [NS] */      \
  156.         { WORD4('H','l','\'', 0 ),      &cpu.alt.hl, 2  },      /* [NS] */      \
  157.         { WORD2('a','\''),              &cpu.alt.a,  1  },      /* [NS] */      \
  158.         { WORD2('f','\''),              &cpu.alt.f,  1  },      /* [NS] */      \
  159.         { WORD2('b','\''),              &cpu.alt.b,  1  },      /* [NS] */      \
  160.         { WORD2('c','\''),              &cpu.alt.c,  1  },      /* [NS] */      \
  161.         { WORD2('d','\''),              &cpu.alt.d,  1  },      /* [NS] */      \
  162.         { WORD2('e','\''),              &cpu.alt.e,  1  },      /* [NS] */      \
  163.         { WORD2('h','\''),              &cpu.alt.h,  1  },      /* [NS] */      \
  164.         { WORD2('l','\''),              &cpu.alt.l,  1  },      /* [NS] */      \
  165.                                                                                 \
  166.         { WORD2('A','F'),       &cpu.af, 2      },              /* AF */        \
  167.         { WORD2('B','C'),       &cpu.bc, 2      },              /* BC */        \
  168.         { WORD2('D','E'),       &cpu.de, 2      },              /* DE */        \
  169.         { WORD2('H','L'),       &cpu.hl, 2      },              /* HL */        \
  170.         { 'A',                  &cpu.a,  1      },                              \
  171.         { 'F',                  &cpu.f,  1      },                              \
  172.         { 'B',                  &cpu.b,  1      },                              \
  173.         { 'C',                  &cpu.c,  1      },                              \
  174.         { 'D',                  &cpu.d,  1      },                              \
  175.         { 'E',                  &cpu.e,  1      },                              \
  176.         { 'H',                  &cpu.h,  1      },                              \
  177.         { 'L',                  &cpu.l,  1      },                              \
  178.                                                                                 \
  179.         { WORD2('P','C'),               &cpu.pc, 2 },           /* PC */        \
  180.         { WORD2('S','P'),               &cpu.sp, 2 },           /* SP */        \
  181.                                                                                 \
  182.         { WORD4('I','X','H', 0 ),       &cpu.xh, 1 },           /* IXH  [NS] */ \
  183.         { WORD4('I','X','L', 0 ),       &cpu.xl, 1 },           /* IXL  [NS] */ \
  184.         { WORD4('I','Y','H', 0 ),       &cpu.yh, 1 },           /* IYH  [NS] */ \
  185.         { WORD4('I','Y','L', 0 ),       &cpu.yl, 1 },           /* IYL  [NS] */ \
  186.                                                                                 \
  187.         { WORD2('X','H'),               &cpu.xh, 1 },           /* XH   [NS] */ \
  188.         { WORD2('X','L'),               &cpu.xl, 1 },           /* XL   [NS] */ \
  189.         { WORD2('Y','H'),               &cpu.yh, 1 },           /* YH   [NS] */ \
  190.         { WORD2('Y','L'),               &cpu.yl, 1 },           /* YL   [NS] */ \
  191.                                                                                 \
  192.         { WORD2('I','X'),               &cpu.ix, 2 },           /* IX */        \
  193.         { WORD2('I','Y'),               &cpu.iy, 2 },           /* IY */        \
  194.                                                                                 \
  195.         { 'I',                  &cpu.i,     1   },                              \
  196.         { 'R',                  &cpu.r_low, 1   },  /* вроде бы d7 работает */   \
  197.                                                                                 \
  198.         { 'T',                  &cpu.t,     4   },              /* T    [NS] */ \
  199.     }
  200. // АХТУНХ! В ЭТОЙ КОНСТРУКЦИИ НЕЛЬЗЯ НОРМАЛЬНО КОМЕНТИТЬ !!!
  201.  
  202. //      { WORD4('N','P','C', 0 ),       &cpu.nextpc, 2 }, - не работатет а жаль
  203. //=============================================================================
  204.  
  205.  
  206.  
  207.  
  208. //=============================================================================
  209. static unsigned char toscript( char *script, uintptr_t *dst)
  210. {
  211.     uintptr_t *d1 = dst;
  212.     //-------------------------------------------------------------------------
  213.     static struct
  214.     {
  215.         unsigned short op;
  216.         unsigned char prior;
  217.     } prio[] =
  218.     {
  219.         {       '(',      10    },
  220.         {       ')',      0     },
  221.         {       '!',      1     },
  222.         {       '~',      1     },
  223.         {       'M',      1     },
  224.         { WORD2('-','>'), 1     },
  225.         {       '*',      2     },
  226.         {       '%',      2     },
  227.         {       '/',      2     },
  228.         {       '+',      3     },
  229.         {       '-',      3     },
  230.         { WORD2('>','>'), 4     },
  231.         { WORD2('<','<'), 4     },
  232.         {       '>',      5     },
  233.         {       '<',      5     },
  234.         {       '=',      5     },
  235.         { WORD2('>','='), 5     },
  236.         { WORD2('<','='), 5     },
  237.         { WORD2('=','='), 5     },
  238.         { WORD2('!','='), 5     },
  239.         {       '&',      6     },
  240.         {       '^',      7     },
  241.         {       '|',      8     },
  242.         { WORD2('&','&'), 9     },
  243.         { WORD2('|','|'), 10    }
  244.     };
  245.     //-------------------------------------------------------------------------
  246.    
  247.     const Z80 &cpu = CpuMgr.Cpu();
  248.  
  249.     DECL_REGS( regs, cpu);
  250.  
  251.     unsigned sp = 0;
  252.     uintptr_t stack[ 128];
  253.     //-------------------------------------------------------------------------
  254.     for (char *p = script;    *p;    p++)
  255.         if (p[1] != 0x27)
  256.             *p = char( toupper( *p));
  257.     //-------------------------------------------------------------------------
  258.     while (*script)
  259.     {
  260.         //---------------------------------------------------------------------
  261.         if (*(unsigned char*) script <= ' ')
  262.         {
  263.             script++;
  264.             continue;
  265.         }
  266.         //---------------------------------------------------------------------
  267.         if (*script == '\'')
  268.         { // char
  269.             *dst++ = DB_CHAR;
  270.             *dst++ = uintptr_t( script[1]);
  271.             //-----------------------------------------------------------------
  272.             if (script[2] != '\'')
  273.                 return 0;
  274.             //-----------------------------------------------------------------
  275.             script += 3;
  276.             continue;
  277.         }
  278.         //---------------------------------------------------------------------
  279.         if (isalnum( *script) && *script != 'M')
  280.         {
  281.             unsigned r = -1U;
  282.             unsigned p = *(unsigned*) script;
  283.             unsigned ln = 0;
  284.             //-----------------------------------------------------------------
  285.             for (unsigned i = 0;    i < _countof( regs);    i++)
  286.             {
  287.                 unsigned mask = 0xFF;
  288.                 ln = 1;
  289.                 //-------------------------------------------------------------
  290.                 if (regs[i].reg & 0xFF00)
  291.                 {
  292.                     mask = 0xFFFF;
  293.                     ln = 2;
  294.                 }
  295.                 //-------------------------------------------------------------
  296.                 if (regs[i].reg & 0xFF0000)
  297.                 {
  298.                     mask = 0xFFFFFF;
  299.                     ln = 3;
  300.                 }
  301.                 //-------------------------------------------------------------
  302.                 if (regs[i].reg == (p & mask))
  303.                 {
  304.                     r = i;
  305.                     break;
  306.                 }
  307.                 //-------------------------------------------------------------
  308.             }
  309.             //-----------------------------------------------------------------
  310.             if (r != -1U)
  311.             {
  312.                 script += ln;
  313.                 //-------------------------------------------------------------
  314.                 switch (regs[r].size)
  315.                 {
  316.                     case 0:     *dst++ = DB_PFUNC;      break;
  317.                     case 1:     *dst++ = DB_PCHAR;      break;
  318.                     case 2:     *dst++ = DB_PSHORT;     break;
  319.                     case 4:     *dst++ = DB_PINT;       break;
  320.                     default:    errexit("BUG01");
  321.                 }
  322.                 //-------------------------------------------------------------
  323.                 *dst++ = (uintptr_t)regs[r].ptr;
  324.             }
  325.             //-----------------------------------------------------------------
  326.             else
  327.             { // number
  328.                 //-------------------------------------------------------------
  329.                 if (*script > 'F') return 0;
  330.                 //-------------------------------------------------------------
  331.                 for (r = 0;    isalnum( *script) && *script <= 'F';    script++)
  332.                 {
  333.                     r = r * 0x10 + unsigned( (*script >= 'A') ? *script-'A' + 10 :
  334.                                                                 *script-'0');
  335.                 }
  336.                 //-------------------------------------------------------------
  337.                 *dst++ = DB_SHORT;
  338.                 *dst++ = r;
  339.             }
  340.             //-----------------------------------------------------------------
  341.             continue;
  342.         }
  343.         //---------------------------------------------------------------------
  344.         // find operation
  345.         unsigned char pr = 0xFF;
  346.         unsigned r = (unsigned)*script++;
  347.         //---------------------------------------------------------------------
  348.         if (strchr("<>=&|-!", (char)r) && strchr("<>=&|", *script))
  349.             r += unsigned( 0x100 * (*script++));
  350.         //---------------------------------------------------------------------
  351.         for (unsigned i = 0; i < _countof( prio); i++)
  352.         {
  353.             if (prio[i].op == r)
  354.             {
  355.                 pr = prio[i].prior;
  356.                 break;
  357.             }
  358.         }
  359.         //---------------------------------------------------------------------
  360.         if (pr == 0xFF)
  361.             return 0;
  362.         //---------------------------------------------------------------------
  363.         if (r != '(')
  364.         {
  365.             while (sp && ((stack[ sp] >> 16 <= pr) || (r == ')' && (stack[ sp] & 0xFF) != '(')))
  366.             { // get from stack
  367.                 *dst++ = stack[sp--] & 0xFFFF;
  368.             }
  369.         }
  370.         //---------------------------------------------------------------------
  371.         if (r == ')')
  372.         {
  373.             sp--;                       // del opening bracket
  374.         }
  375.         //---------------------------------------------------------------------
  376.         else
  377.         {
  378.             stack[ ++sp] = r + 0x10000 * pr;    // put to stack
  379.         }
  380.         //---------------------------------------------------------------------
  381.         if ((int) sp < 0)
  382.             return 0;                   // no opening bracket
  383.         //---------------------------------------------------------------------
  384.     }
  385.     //-------------------------------------------------------------------------
  386.     // empty stack
  387.     while (sp)
  388.     {
  389.         //---------------------------------------------------------------------
  390.         if ((stack[ sp] & 0xFF) == '(')
  391.             return 0; // no closing bracket
  392.         //---------------------------------------------------------------------
  393.         *dst++ = stack[ sp--] & 0xFFFF;
  394.     }
  395.     //-------------------------------------------------------------------------
  396.     *dst = DB_STOP;
  397.  
  398.     calcerr = 0;
  399.     calc( &cpu, d1);
  400.     return u8( 1 - calcerr);
  401. }
  402. //=============================================================================
  403.  
  404. // тк дальше глюки npp подсветки
  405. // такой костыль
  406.         int npp_higlight_shit_costil = (')');   // [NS]
  407.  
  408. //=============================================================================
  409. static void script2text( char *dst, const uintptr_t *src)
  410. {
  411.     char stack[ 64][ 0x200];
  412.     char tmp[ 0x200];
  413.     unsigned sp = 0;
  414.     uintptr_t r;
  415.  
  416.     const Z80 &cpu = CpuMgr.Cpu();
  417.  
  418.     DECL_REGS( regs, cpu);
  419.     //-------------------------------------------------------------------------
  420.     while ((r = *src++))
  421.     {
  422.         //---------------------------------------------------------------------
  423.         if (r == DB_CHAR)
  424.         {
  425.             sprintf( stack[ sp++], "'%c'", int( *src++));
  426.             continue;
  427.         }
  428.         //---------------------------------------------------------------------
  429.         if (r == DB_SHORT)
  430.         {
  431.             sprintf( stack[ sp], "0%X", unsigned( *src++));
  432.             //-----------------------------------------------------------------
  433.             if (isdigit( stack[ sp][ 1]))
  434.                 strcpy( stack[ sp], stack[ sp] + 1);
  435.             //-----------------------------------------------------------------
  436.             sp++;
  437.             continue;
  438.         }
  439.         //---------------------------------------------------------------------
  440.         if ((r >= DB_PCHAR) && (r <= DB_PFUNC))
  441.         {
  442.             unsigned sz = 0;
  443.             //-----------------------------------------------------------------
  444.             switch (r)
  445.             {
  446.                 case DB_PCHAR:  sz = 1; break;
  447.                 case DB_PSHORT: sz = 2; break;
  448.                 case DB_PINT:   sz = 4; break;
  449.                 case DB_PFUNC:  sz = 0; break;
  450.             }
  451.             //-----------------------------------------------------------------
  452.             unsigned i;
  453.             for (i = 0;    i < _countof( regs);    i++)
  454.             {
  455.                 if ((*src == (uintptr_t) regs[ i].ptr) && (sz == regs[ i].size))
  456.                     break;
  457.             }
  458.             //-----------------------------------------------------------------
  459.             *(unsigned*) &(stack[ sp++]) = regs[ i].reg;
  460.             src++;
  461.             continue;
  462.         }
  463.         //---------------------------------------------------------------------
  464.         if ((r == 'M') || (r == '~') || (r == '!'))
  465.         { // unary operators
  466.             sprintf( tmp, "%c(%s)", int( r), stack[ sp - 1]);
  467.             strcpy( stack[ sp - 1], tmp);
  468.             continue;
  469.         }
  470.         //---------------------------------------------------------------------
  471.         // else binary operators
  472.         sprintf( tmp, "(%s%s%s)", stack[ sp - 2], (char*) &r, stack[ sp - 1]);
  473.         sp--;
  474.         strcpy( stack[ sp - 1], tmp);
  475.     }
  476.     //-------------------------------------------------------------------------
  477.     if (!sp)
  478.     {
  479.         *dst = 0;
  480.     }
  481.     //-------------------------------------------------------------------------
  482.     else
  483.     {
  484.         strcpy( dst, stack[ sp - 1]);
  485.     }
  486.     //-------------------------------------------------------------------------
  487. }
  488. //=============================================================================
  489.  
  490.  
  491. //=============================================================================
  492. static void SetBpxButtons( HWND dlg)
  493. {
  494.     int focus = -1;
  495.     int text = 0;
  496.     int box = 0;
  497.    
  498.     HWND focusedWnd = GetFocus();
  499.     //-------------------------------------------------------------------------
  500.     // Перевод фокуса и засерение груп при клацании
  501.     //-------------------------------------------------------------------------
  502.     // Condition BP - EDITTEXT / LISTBOX
  503.     if ( (focusedWnd == GetDlgItem( dlg, IDE_CBP))      ||
  504.          (focusedWnd == GetDlgItem( dlg, IDC_CBP))
  505.      )
  506.     {
  507.         focus = 0;
  508.         text = IDE_CBP;
  509.         box = IDC_CBP;
  510.     }
  511.     //-------------------------------------------------------------------------
  512.     // Execute BP - EDITTEXT / LISTBOX
  513.     if ( (focusedWnd == GetDlgItem( dlg, IDE_BPX))      ||
  514.          (focusedWnd == GetDlgItem( dlg, IDC_BPX))
  515.      )
  516.     {
  517.         focus = 1;
  518.         text = IDE_BPX;
  519.         box = IDC_BPX;
  520.     }
  521.     //-------------------------------------------------------------------------
  522.     // Read BP - EDITTEXT / LISTBOX
  523.     if ( (focusedWnd == GetDlgItem( dlg, IDE_MEM_RD))   ||
  524.          (focusedWnd == GetDlgItem( dlg, IDC_MEM_RD))
  525.      )
  526.     {
  527.         focus = 2;
  528.         text = IDE_MEM_RD;
  529.         box = IDC_MEM_RD;
  530.     }
  531.     //-------------------------------------------------------------------------
  532.     // Write BP - EDITTEXT / LISTBOX
  533.     if ( (focusedWnd == GetDlgItem( dlg, IDE_MEM_WR))   ||
  534.          (focusedWnd == GetDlgItem( dlg, IDC_MEM_WR))
  535.      )
  536.     {
  537.         focus = 3;
  538.         text = IDE_MEM_WR;
  539.         box = IDC_MEM_WR;
  540.     }
  541.     //-------------------------------------------------------------------------
  542.     /*
  543.             // DEPRECATED WR/RD
  544.             if (        (focusedWnd == GetDlgItem( dlg, IDE_MEM))       ||
  545.                         (focusedWnd == GetDlgItem( dlg, IDC_MEM))       ||
  546.                         (focusedWnd == GetDlgItem( dlg, IDC_MEM_R))     ||
  547.                         (focusedWnd == GetDlgItem( dlg, IDC_MEM_W))
  548.              )
  549.             {
  550.                 focus = 2;
  551.                 text = IDE_MEM;
  552.                 box = IDC_MEM;
  553.             }
  554.     */
  555.     //-------------------------------------------------------------------------
  556.     SendDlgItemMessage( dlg, IDE_CBP,    EM_SETREADONLY, (BOOL) (focus != 0), 0);
  557.     SendDlgItemMessage( dlg, IDE_BPX,    EM_SETREADONLY, (BOOL) (focus != 1), 0);
  558.     SendDlgItemMessage( dlg, IDE_MEM_RD, EM_SETREADONLY, (BOOL) (focus != 2), 0); // [NS]
  559.     SendDlgItemMessage( dlg, IDE_MEM_WR, EM_SETREADONLY, (BOOL) (focus != 3), 0); // [NS]
  560.     //-------------------------------------------------------------------------
  561.     int del0 = 0;
  562.     int add0 = 0;
  563.     int del1 = 0;
  564.     int add1 = 0;
  565.     int del2 = 0;
  566.     int add2 = 0;
  567.     int del3 = 0; // [NS]
  568.     int add3 = 0; // [NS]
  569.     //-------------------------------------------------------------------------
  570.     unsigned max = unsigned( SendDlgItemMessage( dlg, box,  LB_GETCOUNT,      0, 0));
  571.     unsigned cur = unsigned( SendDlgItemMessage( dlg, box,  LB_GETCURSEL,     0, 0));
  572.     unsigned len = unsigned( SendDlgItemMessage( dlg, text, WM_GETTEXTLENGTH, 0, 0));
  573.     //-------------------------------------------------------------------------
  574.     if (max && cur >= max)
  575.         SendDlgItemMessage( dlg, box, LB_SETCURSEL, cur = 0, 0);
  576.     //-------------------------------------------------------------------------
  577.     // Condition BP
  578.     if (focus == 0)
  579.     {
  580.         if (len && max < MAX_CBP) add0 = 1;
  581.         if (cur < max) del0 = 1;
  582.     }
  583.     //-------------------------------------------------------------------------
  584.     // Execute BP
  585.     if (focus == 1)
  586.     {
  587.         if (len) add1 = 1;
  588.         if (cur < max) del1 = 1;
  589.     }
  590.     //-------------------------------------------------------------------------
  591.     // Read BP
  592.     if (focus == 2)
  593.     {
  594.         /*
  595.         //---------------------------------------------------------------------
  596.         if (    (IsDlgButtonChecked( dlg, IDC_MEM_R) == BST_UNCHECKED) &&
  597.                 (IsDlgButtonChecked( dlg, IDC_MEM_W) == BST_UNCHECKED)
  598.          )
  599.         {
  600.             len = 0;
  601.         }
  602.         //---------------------------------------------------------------------
  603.         */
  604.         if (len) add2 = 1;
  605.         if (cur < max) del2 = 1;
  606.     }
  607.     //-------------------------------------------------------------------------
  608.     // Write BP
  609.     if (focus == 3)
  610.     {
  611.         if (len) add3 = 1;
  612.         if (cur < max) del3 = 1;
  613.     }
  614.     //-------------------------------------------------------------------------
  615.  
  616.     EnableWindow( GetDlgItem( dlg, IDB_CBP_ADD),  add0);
  617.     EnableWindow( GetDlgItem( dlg, IDB_CBP_DEL),  del0);
  618.     EnableWindow( GetDlgItem( dlg, IDB_CBP_EDIT), del0); // совпадает с del
  619.    
  620.     EnableWindow( GetDlgItem( dlg, IDB_BPX_ADD),  add1);
  621.     EnableWindow( GetDlgItem( dlg, IDB_BPX_DEL),  del1);
  622.     EnableWindow( GetDlgItem( dlg, IDB_BPX_EDIT), del1); // совпадает с del
  623.    
  624.     EnableWindow( GetDlgItem( dlg, IDB_MEM_RD_ADD),  add2); // [NS]
  625.     EnableWindow( GetDlgItem( dlg, IDB_MEM_RD_DEL),  del2);
  626.     EnableWindow( GetDlgItem( dlg, IDB_MEM_RD_EDIT), del2); // совпадает с del
  627.    
  628.     EnableWindow( GetDlgItem( dlg, IDB_MEM_WR_ADD),  add3); // [NS]
  629.     EnableWindow( GetDlgItem( dlg, IDB_MEM_WR_DEL),  del3);
  630.     EnableWindow( GetDlgItem( dlg, IDB_MEM_WR_EDIT), del3); // совпадает с del
  631.    
  632.    
  633.     unsigned defid = 0;
  634.     //-------------------------------------------------------------------------
  635.     if (add0) defid = IDB_CBP_ADD;
  636.     if (add1) defid = IDB_BPX_ADD;
  637.     if (add2) defid = IDB_MEM_RD_ADD;
  638.     if (add3) defid = IDB_MEM_WR_ADD;
  639.     //-------------------------------------------------------------------------
  640.     if (defid)
  641.         SendMessage( dlg, DM_SETDEFID, defid, 0);
  642.     //-------------------------------------------------------------------------
  643. }
  644. //=============================================================================
  645.  
  646.  
  647. //=============================================================================
  648. /*
  649. // лютейший говнокод неизвестного аффтара
  650. // даже не знание про LB_DELETESTRING не оправдание килотоннам тоннам LB_GETCOUNT
  651. static void ClearListBox( HWND box)
  652. {
  653.     //-------------------------------------------------------------------------
  654.     while (SendMessage( box, LB_GETCOUNT, 0, 0))
  655.     {
  656.         SendMessage( box, LB_DELETESTRING, 0, 0);
  657.     }
  658.     //-------------------------------------------------------------------------
  659. }
  660. */
  661. //=============================================================================
  662.  
  663.  
  664. //=============================================================================
  665. static void FillCondBox( HWND dlg, unsigned cursor)
  666. {
  667.     HWND box = GetDlgItem( dlg, IDC_CBP);
  668.    
  669.     SendMessage( box, WM_SETREDRAW, FALSE, 0);  // отключаем перерисовку списка [NS]
  670.    
  671.     //ClearListBox( box);
  672.     SendMessage( box, LB_RESETCONTENT, 0, 0);   // [NS]
  673.  
  674.     Z80 &cpu = CpuMgr.Cpu();
  675.     //-------------------------------------------------------------------------
  676.     for (unsigned i = 0;    i < cpu.cbpn;    i++)
  677.     {
  678.         char tmp[ 0x200];
  679.         script2text( tmp, cpu.cbp[ i]);
  680.         SendMessage( box, LB_ADDSTRING, 0, (LPARAM) tmp);
  681.     }
  682.     //-------------------------------------------------------------------------
  683.     SendMessage( box, LB_SETCURSEL, cursor, 0);
  684.    
  685.     SendMessage( box, WM_SETREDRAW, TRUE, 0);   // включаем перерисовку списка [NS]
  686. }
  687. //=============================================================================
  688.  
  689.  
  690. //=============================================================================
  691. static void FillBpxBox( HWND dlg, unsigned address)
  692. {
  693.     //printf("FillBpxBox ");
  694.     HWND box = GetDlgItem( dlg, IDC_BPX);
  695.  
  696.     SendMessage( box, WM_SETREDRAW, FALSE, 0);  // отключаем перерисовку списка [NS]
  697.  
  698.     //ClearListBox( box);       // очистка тоже долго с перерисовкой!!!
  699.                                 // напорядки больше чем создание !!!
  700.     SendMessage( box, LB_RESETCONTENT, 0, 0);   // [NS]
  701.    
  702.     unsigned selection = 0;
  703.  
  704.     Z80 &cpu = CpuMgr.Cpu();
  705.     unsigned end;               // Alone Coder 0.36.7
  706.     //-------------------------------------------------------------------------
  707.     for (unsigned start = 0;    start < 0x10000;    )
  708.     {
  709.         //---------------------------------------------------------------------
  710.         if (!(cpu.membits[ start] & MEMBITS_BPX))
  711.         {
  712.             start++;
  713.             continue;
  714.         }
  715.         //---------------------------------------------------------------------
  716.         for (   /*unsigned*/ end = start
  717.                 ;
  718.                 (end < 0xFFFF)                          &&      // диапазон поиска
  719.                 (group_bpx_list)                        &&      // отключение групировки
  720.                 (cpu.membits[ end + 1] & MEMBITS_BPX)   &&
  721.                 // + У блока должна быть такая же отключенность
  722.                 // иначе это разные бряки
  723.                 ((cpu.bp_disable_bits[ end + 1] & BP_DISABLE_BPX) == (cpu.bp_disable_bits[ end] & BP_DISABLE_BPX))     
  724.                 ;
  725.                 end++ );
  726.         //---------------------------------------------------------------------
  727.         char tmp[ 16];
  728.         //---------------------------------------------------------------------
  729.         if (start == end)
  730.         {
  731.             if (cpu.bp_disable_bits[ start] & BP_DISABLE_BPX)
  732.             {
  733.                 sprintf( tmp, "%04X <-- DISABLED", start);
  734.             }
  735.             else
  736.             {
  737.                 sprintf( tmp, "%04X", start);
  738.             }
  739.         }
  740.         //---------------------------------------------------------------------
  741.         else
  742.         {
  743.             // "-" между цифр нельзя менять !!!!
  744.             // тк диапазон для заливки\удаления\отключения
  745.             // ВНЕЗАПНО читаетсо прямо из этого текста
  746.             //
  747.             // по идеи весь блок с одинаковым режимом
  748.             if (cpu.bp_disable_bits[ start] & BP_DISABLE_BPX)
  749.             {
  750.                 sprintf( tmp, "%04X-%04X <-- DISABLED", start, end);
  751.             }
  752.             else
  753.             {
  754.                 sprintf( tmp, "%04X-%04X", start, end);
  755.             }
  756.         }
  757.         //---------------------------------------------------------------------
  758.         SendMessage( box, LB_ADDSTRING, 0, (LPARAM) tmp);
  759.        
  760.                 //      int i_temp = SendMessage( box, LB_ADDSTRING, 0, (LPARAM) tmp);
  761.                 //      printf("%x\n",i_temp);
  762.                 //TZT
  763.                         //SendDlgItemMessage(hDlg, id, iMsg, wParam, lParam);
  764.                         //SendMessage(hwnd, message, wParam, lParam);
  765.                 //      i_temp = SendMessage( box, LB_GETITEMDATA, i_temp, 0);
  766.                 //      printf("  %x\n",i_temp);
  767.  
  768.         //---------------------------------------------------------------------
  769.         if ((start <= address) && (address <= end))
  770.             selection = unsigned( SendMessage( box, LB_GETCOUNT, 0, 0));
  771.         //---------------------------------------------------------------------
  772.         start = end + 1;
  773.     }
  774.     //-------------------------------------------------------------------------
  775.     if (selection)
  776.         SendMessage( box, LB_SETCURSEL, selection - 1, 0);
  777.     //-------------------------------------------------------------------------
  778.     SendMessage( box, WM_SETREDRAW, TRUE, 0);   // включаем перерисовку списка [NS]
  779.  
  780.     needclr++;  // обновить окно дебагера
  781. }
  782. //=============================================================================
  783.  
  784.  
  785.  
  786.  
  787.  
  788. //=============================================================================
  789. static void Fill_Mem_RD_Box( HWND dlg, unsigned address)                // [NS]
  790. {
  791.     //printf("Fill_Mem_RD_Box ");
  792.     HWND box = GetDlgItem( dlg, IDC_MEM_RD);
  793.  
  794.     SendMessage( box, WM_SETREDRAW, FALSE, 0);  // отключаем перерисовку списка [NS]
  795.    
  796.     //ClearListBox( box);
  797.     SendMessage( box, LB_RESETCONTENT, 0, 0);   // [NS]
  798.  
  799.     unsigned selection = 0;
  800.  
  801.     Z80 &cpu = CpuMgr.Cpu();
  802.     unsigned end;               // Alone Coder 0.36.7
  803.     //-------------------------------------------------------------------------
  804.     for (unsigned start = 0;    start < 0x10000;    )
  805.     {
  806.         //---------------------------------------------------------------------
  807.         if (!(cpu.membits[ start] & MEMBITS_BPR))
  808.         {
  809.             start++;
  810.             continue;
  811.         }
  812.         //---------------------------------------------------------------------
  813.         for (   /*unsigned*/ end = start
  814.                 ;
  815.                 (end < 0xFFFF)                          &&
  816.                 (group_bpr_list)                        &&      // отключение групировки
  817.                 (cpu.membits[ end + 1] & MEMBITS_BPR)   &&
  818.                 // + У блока должна быть такая же отключенность
  819.                 // иначе это разные бряки
  820.                 ((cpu.bp_disable_bits[ end + 1] & BP_DISABLE_BPR) == (cpu.bp_disable_bits[ end] & BP_DISABLE_BPR))     
  821.                 ;
  822.                 end++ );
  823.         //---------------------------------------------------------------------
  824.         char tmp[ 16];
  825.         //---------------------------------------------------------------------
  826.         if (start == end)
  827.         {
  828.             if (cpu.bp_disable_bits[ start] & BP_DISABLE_BPR)
  829.             {
  830.                 sprintf( tmp, "%04X <-- DISABLED", start);
  831.             }
  832.             else
  833.             {
  834.                 sprintf( tmp, "%04X", start);
  835.             }
  836.         }
  837.         //---------------------------------------------------------------------
  838.         else
  839.         {
  840.             // "-" между цифр нельзя менять !!!!
  841.             // тк диапазон для заливки\удаления\отключения
  842.             // ВНЕЗАПНО читаетсо прямо из этого текста
  843.             //
  844.             // по идеи весь блок с одинаковым режимом
  845.             if (cpu.bp_disable_bits[ start] & BP_DISABLE_BPR)
  846.             {
  847.                 sprintf( tmp, "%04X-%04X <-- DISABLED", start, end);
  848.             }
  849.             else
  850.             {
  851.                 sprintf( tmp, "%04X-%04X", start, end);
  852.             }
  853.         }
  854.         //---------------------------------------------------------------------
  855.         SendMessage( box, LB_ADDSTRING, 0, (LPARAM) tmp);
  856.         //---------------------------------------------------------------------
  857.         if ((start <= address) && (address <= end))
  858.             selection = unsigned( SendMessage( box, LB_GETCOUNT, 0, 0));
  859.         //---------------------------------------------------------------------
  860.         start = end + 1;
  861.     }
  862.     //-------------------------------------------------------------------------
  863.     if (selection)
  864.         SendMessage( box, LB_SETCURSEL, selection - 1, 0);
  865.     //-------------------------------------------------------------------------
  866.     SendMessage( box, WM_SETREDRAW, TRUE, 0);   // включаем перерисовку списка [NS]
  867.    
  868.     needclr++;  // обновить окно дебагера
  869. }
  870. //=============================================================================
  871.  
  872.  
  873. //=============================================================================
  874. static void Fill_Mem_WR_Box( HWND dlg, unsigned address)                // [NS]
  875. {
  876.     HWND box = GetDlgItem( dlg, IDC_MEM_WR);
  877.  
  878.     SendMessage( box, WM_SETREDRAW, FALSE, 0);  // отключаем перерисовку списка [NS]
  879.  
  880.     //ClearListBox( box);                       // очистка тоже долго с перерисовкой!!!
  881.     SendMessage( box, LB_RESETCONTENT, 0, 0);   // [NS]
  882.  
  883.     unsigned selection = 0;
  884.  
  885.     SendMessage( box, WM_SETREDRAW, FALSE, 0);  // отключаем перерисовку списка [NS]
  886.    
  887.     Z80 &cpu = CpuMgr.Cpu();
  888.     unsigned end;               // Alone Coder 0.36.7
  889.     //-------------------------------------------------------------------------
  890.     for (unsigned start = 0;    start < 0x10000;    )
  891.     {
  892.         //---------------------------------------------------------------------
  893.         if (!(cpu.membits[ start] & MEMBITS_BPW))
  894.         {
  895.             start++;
  896.             continue;
  897.         }
  898.         //---------------------------------------------------------------------
  899.         for (   /*unsigned*/ end = start
  900.                 ;
  901.                 (end < 0xFFFF)                          &&
  902.                 (group_bpw_list)                        &&      // отключение групировки
  903.                 (cpu.membits[ end + 1] & MEMBITS_BPW)   &&
  904.                 // + У блока должна быть такая же отключенность
  905.                 // иначе это разные бряки
  906.                 ((cpu.bp_disable_bits[ end + 1] & BP_DISABLE_BPW) == (cpu.bp_disable_bits[ end] & BP_DISABLE_BPW))
  907.                 ;
  908.                 end++ );
  909.         //---------------------------------------------------------------------
  910.         char tmp[ 16];
  911.         //---------------------------------------------------------------------
  912.         if (start == end)
  913.         {
  914.             if (cpu.bp_disable_bits[ start] & BP_DISABLE_BPW)
  915.             {
  916.                 sprintf( tmp, "%04X <-- DISABLED", start);
  917.             }
  918.             else
  919.             {
  920.                 sprintf( tmp, "%04X", start);
  921.             }
  922.         }
  923.         //---------------------------------------------------------------------
  924.         else
  925.         {
  926.             // "-" между цифр нельзя менять !!!!
  927.             // тк диапазон для заливки\удаления\отключения
  928.             // ВНЕЗАПНО читаетсо прямо из этого текста
  929.             //
  930.             // по идеи весь блок с одинаковым режимом
  931.             if (cpu.bp_disable_bits[ start] & BP_DISABLE_BPW)
  932.             {
  933.                 sprintf( tmp, "%04X-%04X <-- DISABLED", start, end);
  934.             }
  935.             else
  936.             {
  937.                 sprintf( tmp, "%04X-%04X", start, end);
  938.             }
  939.         }
  940.         //---------------------------------------------------------------------
  941.         SendMessage( box, LB_ADDSTRING, 0, (LPARAM) tmp);
  942.         //---------------------------------------------------------------------
  943.         if ((start <= address) && (address <= end))
  944.             selection = unsigned( SendMessage( box, LB_GETCOUNT, 0, 0));
  945.         //---------------------------------------------------------------------
  946.         start = end + 1;
  947.     }
  948.     //-------------------------------------------------------------------------
  949.     if (selection)
  950.         SendMessage( box, LB_SETCURSEL, selection - 1, 0);
  951.     //-------------------------------------------------------------------------
  952.     SendMessage( box, WM_SETREDRAW, TRUE, 0);   // включаем перерисовку списка [NS]
  953.  
  954.     needclr++;  // обновить окно дебагера
  955. }
  956. //=============================================================================
  957.  
  958.  
  959.  
  960. //=============================================================================
  961. static char MoveBpxFromBoxToEdit( HWND dlg, unsigned box, unsigned edit)
  962. {
  963.     HWND hBox = GetDlgItem( dlg, int( box));
  964.     unsigned max = unsigned( SendDlgItemMessage( dlg, box, LB_GETCOUNT,  0, 0));
  965.     unsigned cur = unsigned( SendDlgItemMessage( dlg, box, LB_GETCURSEL, 0, 0));
  966.     //-------------------------------------------------------------------------
  967.     if (cur >= max)
  968.         return 0;
  969.     //-------------------------------------------------------------------------
  970.     char tmp[ 0x200];
  971.     SendMessage( hBox, LB_GETTEXT, cur, (LPARAM) tmp);
  972.    
  973.     char *temp_addr = strstr( tmp, " <-");
  974.     //-------------------------------------------------------------------------
  975.     // если строка не найдена то strstr возвращает 0 !!!!
  976.     if ((temp_addr) != 0)
  977.     {
  978.         //типо затираем " <-- DISABLED"
  979.         *temp_addr = 0;
  980.     }
  981.     //-------------------------------------------------------------------------
  982.     /*
  983.     if ((box == IDC_MEM) && *tmp)
  984.     {
  985.         char *last = tmp + strlen( tmp);
  986.         unsigned r = BST_UNCHECKED;
  987.         unsigned w = BST_UNCHECKED;
  988.         //---------------------------------------------------------------------
  989.         if (last[ -1] == 'W')
  990.         {
  991.             w = BST_CHECKED;
  992.             last--;
  993.         }
  994.         //---------------------------------------------------------------------
  995.         if (last[ -1] == 'R')
  996.         {
  997.             r = BST_CHECKED;
  998.             last--;
  999.         }
  1000.         //---------------------------------------------------------------------
  1001.         if (last[ -1] == ' ')
  1002.             last--;
  1003.         //---------------------------------------------------------------------
  1004.         *last = 0;
  1005.         CheckDlgButton( dlg, IDC_MEM_R, r);
  1006.         CheckDlgButton( dlg, IDC_MEM_W, w);
  1007.     }
  1008.     */
  1009.     //-------------------------------------------------------------------------
  1010.     SetDlgItemText( dlg, edit, tmp);
  1011.     return 1;
  1012. }
  1013. //=============================================================================
  1014.  
  1015.  
  1016. //=============================================================================
  1017. struct MEM_RANGE
  1018. {
  1019.     unsigned start;
  1020.     unsigned end;
  1021. };
  1022. //=============================================================================
  1023.  
  1024.  
  1025. //=============================================================================
  1026. static int GetMemRamge( char *str, MEM_RANGE &range)
  1027. {
  1028.     //-------------------------------------------------------------------------
  1029.     while (*str == ' ')
  1030.         str++;
  1031.     //-------------------------------------------------------------------------
  1032.     for (range.start = 0;    ishex( *str);    str++)
  1033.         range.start = range.start * 0x10 + hex( *str);
  1034.     //-------------------------------------------------------------------------
  1035.     if (*str == '-')
  1036.     {
  1037.         //---------------------------------------------------------------------
  1038.         for (range.end = 0, str++;    ishex( *str);    str++)
  1039.             range.end = range.end * 0x10 + hex( *str);
  1040.         //---------------------------------------------------------------------
  1041.     }
  1042.     //-------------------------------------------------------------------------
  1043.     else
  1044.     {
  1045.         range.end = range.start;
  1046.     }
  1047.     //-------------------------------------------------------------------------
  1048.     while (*str == ' ')
  1049.         str++;
  1050.     //-------------------------------------------------------------------------
  1051.     if (*str)
  1052.         return 0;
  1053.     //-------------------------------------------------------------------------
  1054.     if (range.start > range.end)                // [NS]
  1055.     {
  1056.         unsigned temp = range.end;
  1057.         range.end = range.start;
  1058.         range.start = temp;
  1059.     }
  1060.     //-------------------------------------------------------------------------
  1061.     if ((range.start > 0xFFFF) || (range.end > 0xFFFF))
  1062.         return 0;
  1063.     //-------------------------------------------------------------------------
  1064.     return 1;
  1065. }
  1066. //=============================================================================
  1067.  
  1068.  
  1069.  
  1070.  
  1071.  
  1072.  
  1073.  
  1074.  
  1075.  
  1076. //=============================================================================
  1077. void conddlg_update_texts( HWND dlg)                                    // [NS]
  1078. {
  1079.     LPCSTR temp_CPU_name;
  1080.     //-------------------------------------------------------------------------
  1081.     if ( (CpuMgr.GetCurrentCpu()) == 0 )
  1082.     {
  1083.         temp_CPU_name = "Current CPU: ZX-CPU";
  1084.     }
  1085.     //-------------------------------------------------------------------------
  1086.     else
  1087.     {
  1088.         temp_CPU_name = "Current CPU: GS-CPU";
  1089.     }
  1090.     //-------------------------------------------------------------------------
  1091.     //SetWindowText( GetDlgItem( dlg, IDT_CURRENT_CPU_INDICATOR), temp_CPU_name);
  1092.     SetWindowText( GetDlgItem( dlg, IDB_SWITCH_CPU), temp_CPU_name);
  1093. }
  1094. //=============================================================================
  1095.  
  1096.  
  1097.  
  1098.  
  1099.  
  1100.  
  1101.  
  1102.  
  1103.  
  1104.  
  1105.  
  1106.  
  1107.  
  1108.  
  1109.  
  1110.  
  1111.  
  1112.  
  1113.  
  1114.  
  1115.  
  1116.  
  1117.  
  1118. //=============================================================================
  1119.  
  1120.  
  1121.     static int conddlg_current_visible_cpu = 0;
  1122.    
  1123. //=============================================================================
  1124. // обработчик сообщений диалога breakpoint-ов
  1125.  
  1126. static INT_PTR CALLBACK conddlg( HWND dlg, UINT msg, WPARAM wp, LPARAM lp)
  1127. {
  1128.     (void) lp;
  1129.        
  1130.     // бекапим текущий CPU
  1131.     // тк conddlg ввызываетсо рекурсивно !!!!
  1132.     // нужно возвращать всегда предыдущее состояние !!
  1133.     // NOT STATIC !!!
  1134.     int current_cpu_back = CpuMgr.GetCurrentCpu();      // NOT STATIC !!!
  1135.    
  1136.     // меняем текущий CPU
  1137.     CpuMgr.SetCurrentCpu( conddlg_current_visible_cpu);
  1138.    
  1139.     Z80 &cpu = CpuMgr.Cpu();
  1140.    
  1141.     // НА ВСЕХ ВЫХОДАХ ИЗ conddlg()
  1142.     // НУЖНО ВОСТАНАВЛИВАТЬ CPU на место!!!!
  1143.     // это проще чем поправить все записи
  1144.    
  1145.     // printf("msg %x wp %x lp %x\n",msg,wp,lp);
  1146.    
  1147.     //-------------------------------------------------------------------------
  1148.     // цвета для listbox-ов
  1149.     static HBRUSH hBrushStatic;
  1150.     static COLORREF color_cbp = { RGB(   0, 100, 200) };
  1151.     static COLORREF color_bpx = { RGB(   0,   0, 255) };
  1152.     static COLORREF color_bpw = { RGB( 160,  16,  16) };
  1153.     static COLORREF color_bpr = { RGB(  16, 140,  16) };
  1154.     //-------------------------------------------------------------------------
  1155.  
  1156.     unsigned id = LOWORD( wp);
  1157.     unsigned code = HIWORD( wp);
  1158.     unsigned char mask = 0;
  1159.     unsigned char disable_bp_mask = 0;
  1160.  
  1161.     //=========================================================================
  1162.     if (msg == WM_INITDIALOG)                                           // [NS]
  1163.     {      
  1164.         // для разукрашки listbox-ов
  1165.         hBrushStatic = CreateSolidBrush( GetSysColor( COLOR_BTNHIGHLIGHT));
  1166.        
  1167.         // текущий видимый проц на момент входа
  1168.         // нужно при входе из дебагера когда активен GS по хоткею
  1169.         conddlg_current_visible_cpu = current_cpu_back;
  1170.         CpuMgr.SetCurrentCpu( conddlg_current_visible_cpu);
  1171.         Z80 &cpu = CpuMgr.Cpu();
  1172.         //printf("current_visible_cpu %x\n",current_visible_cpu);
  1173.     }
  1174.     //=========================================================================                                
  1175.     if (msg == WM_DESTROY)                                              // [NS]
  1176.     {
  1177.         DeleteObject( hBrushStatic);
  1178.     }
  1179.     //=========================================================================
  1180.  
  1181.     // ODT_LISTBOX
  1182.     // LB_GETLISTBOXINFO 0x01B2
  1183.    
  1184.  
  1185.     //=========================================================================
  1186.     // разукрашка listbox-ов методом научного тыка                       // [NS]
  1187.     // к сожалению мы не знаем как красить отдельные строки
  1188.     // так покрасим хоть шо нибудь (так лучше различаютсо колонки)
  1189.     if (msg == WM_CTLCOLORLISTBOX)
  1190.     {
  1191.         // int i;
  1192.         // i = GetWindowLong ((HWND) lp, GWL_ID);      
  1193.         //---------------------------------------------------------------------
  1194.         if      (lp == (WPARAM) GetDlgItem( dlg, IDC_CBP))
  1195.         {
  1196.             SetTextColor ((HDC) wp, color_cbp);
  1197.         }
  1198.         //---------------------------------------------------------------------
  1199.         else if (lp == (WPARAM) GetDlgItem( dlg, IDC_BPX))
  1200.         {
  1201.             SetTextColor ((HDC) wp, color_bpx);
  1202.         }
  1203.         //---------------------------------------------------------------------
  1204.         else if (lp == (WPARAM) GetDlgItem( dlg, IDC_MEM_RD))
  1205.         {
  1206.             SetTextColor ((HDC) wp, color_bpr);
  1207.         }
  1208.         //---------------------------------------------------------------------
  1209.         else if (lp == (WPARAM) GetDlgItem( dlg, IDC_MEM_WR))
  1210.         {
  1211.             SetTextColor ((HDC) wp, color_bpw);
  1212.         }
  1213.         //---------------------------------------------------------------------
  1214.         //SetBkColor ((HDC) wp, GetSysColor( COLOR_BTNHIGHLIGHT));
  1215.        
  1216.         // возвращаем CPU на место перед выходом
  1217.         CpuMgr.SetCurrentCpu( current_cpu_back);
  1218.        
  1219.         return (LRESULT) hBrushStatic;
  1220.     }
  1221.     //=========================================================================
  1222.    
  1223.  
  1224.     //=========================================================================
  1225.     // Контексные Менюшки
  1226.     //     а шо так можно мы узнали при помощи winuser.h
  1227.     //     и метода научного тыка приплясывая с бубном
  1228.     //     всякие там Педзольды молчат как партизанэн
  1229.     //     а правые клики мышой тупо сюдава недоходят о_О
  1230.     //     даже как noclient
  1231.     //
  1232.     if (msg == WM_CONTEXTMENU)  // [NS]
  1233.     {
  1234.         // wp - HWND того куда мы ткнули
  1235.         // lp - координаты куда мы ткнули в screen формате
  1236.         bool display_listbox_menu;
  1237.         int current_listbox_menu;
  1238.         //=====================================================================
  1239.         // Conditional BP
  1240.         if      (wp == (WPARAM) GetDlgItem( dlg, IDC_CBP))
  1241.         {
  1242.             display_listbox_menu = TRUE;
  1243.             current_listbox_menu = IDC_CBP;
  1244.         }
  1245.         //---------------------------------------------------------------------
  1246.         // Execute BP
  1247.         else if (wp == (WPARAM) GetDlgItem( dlg, IDC_BPX))
  1248.         {
  1249.             display_listbox_menu = TRUE;
  1250.             current_listbox_menu = IDC_BPX;
  1251.         }
  1252.         //---------------------------------------------------------------------
  1253.         // Read BP
  1254.         else if (wp == (WPARAM) GetDlgItem( dlg, IDC_MEM_RD))
  1255.         {
  1256.             display_listbox_menu = TRUE;
  1257.             current_listbox_menu = IDC_MEM_RD;
  1258.         }
  1259.         //---------------------------------------------------------------------
  1260.         // Write BP
  1261.         else if (wp == (WPARAM) GetDlgItem( dlg, IDC_MEM_WR))
  1262.         {
  1263.             display_listbox_menu = TRUE;
  1264.             current_listbox_menu = IDC_MEM_WR;
  1265.         }
  1266.         //---------------------------------------------------------------------
  1267.         else
  1268.         {
  1269.             display_listbox_menu = FALSE;       // никуда не попали
  1270.         }
  1271.         //=====================================================================
  1272.         if (display_listbox_menu)
  1273.         {
  1274.             int xPos = LOWORD( lp);     // в screen формате
  1275.             int yPos = HIWORD( lp);
  1276.             // printf("old x %d y %d\n",xPos,yPos);
  1277.             POINT click_pos;
  1278.             click_pos.x = xPos;
  1279.             click_pos.y = yPos;
  1280.            
  1281.             // переводим в формат координат listbox-а
  1282.             ScreenToClient( (HWND) wp, &click_pos);
  1283.             //printf("new x %d y %d\n",click_pos.x,click_pos.y);
  1284.             // имитируем клик чтобы переместить гребаный фокус
  1285.             // почему то отправка на на dlg на работает
  1286.             // работает только на hwnd listbox-а
  1287.             SendMessage( (HWND) wp, WM_LBUTTONDOWN, MK_LBUTTON, MAKELONG( click_pos.x, click_pos.y));
  1288.  
  1289.         //MF_END
  1290.         // MF_MENUBARBREAK
  1291.         // MF_MENUBREAK
  1292.         // MF_STRING | MF_SYSMENU смещает надпись вправо
  1293.        
  1294.             //-----------------------------------------------------------------
  1295.             // Выбираем что писать Enable или Disable
  1296.             char brk_disable_enable_text[ 16] = "Disable";
  1297.             bool brk_disable_possible = TRUE;
  1298.             bool brk_edit_possible = TRUE;
  1299.             bool brk_delete_possible = TRUE;
  1300.             bool brk_xxx_all_possible = TRUE;
  1301.             //-----------------------------------------------------------------
  1302.             if (current_listbox_menu != IDC_CBP)
  1303.             {
  1304.                 HWND hBox = GetDlgItem( dlg, int( current_listbox_menu));       //IDC_PPX
  1305.                 unsigned cur = unsigned( SendDlgItemMessage( dlg, current_listbox_menu, LB_GETCURSEL, 0, 0));
  1306.                 unsigned max = unsigned( SendDlgItemMessage( dlg, current_listbox_menu, LB_GETCOUNT,  0, 0));
  1307.                 //-------------------------------------------------------------
  1308.                 if (cur >= max)
  1309.                 {
  1310.                     brk_disable_possible = FALSE;
  1311.                     brk_edit_possible = FALSE;
  1312.                     brk_delete_possible = FALSE;
  1313.                     brk_xxx_all_possible = FALSE;
  1314.                     goto skip_disable_enable_text_printing;
  1315.                     // ДАЛЬШЕ НЕЛЬЗЯ РАБОТАТЬ С НЕВАЛИДНЫМИ ДАННЫМИ !!!
  1316.                     // или можно словить access denied с падением !!!
  1317.                 }
  1318.                 //-------------------------------------------------------------
  1319.                 char tmp_strng[ 0x200];
  1320.                 SendMessage( hBox, LB_GETTEXT, cur, (LPARAM) tmp_strng);
  1321.                 char *temp_addr = strstr( tmp_strng, "-");
  1322.                 //-------------------------------------------------------------
  1323.                 // если строка не найдена то strstr возвращает 0 !!!!
  1324.                 if ((temp_addr) != 0)
  1325.                 {
  1326.                     *temp_addr = 0;     //типо затираем "-xxxx <--..."
  1327.                 }
  1328.                 //-------------------------------------------------------------
  1329.                 unsigned cursor_addr;
  1330.                 sscanf( tmp_strng, "%X", &cursor_addr);
  1331.                 //Z80 &cpu = CpuMgr.Cpu();      // cpu.xxx = текущий CPU
  1332.                 int mask = 0;
  1333.                 //-------------------------------------------------------------
  1334.                 switch (current_listbox_menu)
  1335.                 {
  1336.                     case IDC_BPX:       mask = u8( BP_DISABLE_BPX);     break;
  1337.                     case IDC_MEM_RD:    mask = u8( BP_DISABLE_BPR);     break;
  1338.                     case IDC_MEM_WR:    mask = u8( BP_DISABLE_BPW);     break;
  1339.                 }
  1340.                 //-------------------------------------------------------------
  1341.                 if (cpu.bp_disable_bits[ cursor_addr] & mask)
  1342.                 {
  1343.                     sprintf( brk_disable_enable_text, "Enable");
  1344.                 }
  1345.                 else
  1346.                 {
  1347.                     sprintf( brk_disable_enable_text, "Disable");
  1348.                 }
  1349.                 //-------------------------------------------------------------
  1350.             } // not IDC_CBP
  1351.             //-----------------------------------------------------------------
  1352.             // IDC_CBP
  1353.             else
  1354.             {
  1355.                 unsigned cur = unsigned( SendDlgItemMessage( dlg, current_listbox_menu, LB_GETCURSEL, 0, 0));
  1356.                 unsigned max = unsigned( SendDlgItemMessage( dlg, current_listbox_menu, LB_GETCOUNT,  0, 0));
  1357.                 //-------------------------------------------------------------
  1358.                 if (cur >= max)
  1359.                 {
  1360.                     brk_disable_possible = FALSE;
  1361.                     brk_edit_possible = FALSE;
  1362.                     brk_delete_possible = FALSE;
  1363.                     brk_xxx_all_possible = FALSE;
  1364.                     goto skip_disable_enable_text_printing;
  1365.                 }
  1366.                 //-------------------------------------------------------------
  1367.             }
  1368.             //-----------------------------------------------------------------
  1369. skip_disable_enable_text_printing:
  1370.             //-----------------------------------------------------------------
  1371.            
  1372.            
  1373.             //-----------------------------------------------------------------
  1374.             HMENU context_menu = CreatePopupMenu();
  1375.                                                                
  1376.             int mf_flag;
  1377.                                                                 //=================================
  1378.             mf_flag = ( (current_listbox_menu != IDC_CBP) &&
  1379.                         (brk_disable_possible) 
  1380.                                                 )  ?  MF_STRING :
  1381.                                                       MF_STRING | MF_GRAYED;
  1382.                                                                  
  1383.             AppendMenu( context_menu, mf_flag, IDM_BRK_DISABLE, brk_disable_enable_text );
  1384.             //                                                          "Disable/Enable"
  1385.             AppendMenu( context_menu, MF_SEPARATOR, 0, nullptr); //================================
  1386.             mf_flag = (brk_edit_possible)  ?  MF_STRING :
  1387.                                               MF_STRING | MF_GRAYED;
  1388.             AppendMenu( context_menu, mf_flag, IDM_BRK_EDIT,            "Edit"         );
  1389.             //-------------------------------------------------------------------------------------
  1390.             mf_flag = (brk_delete_possible)  ?  MF_STRING :
  1391.                                                 MF_STRING | MF_GRAYED;
  1392.             AppendMenu( context_menu, mf_flag, IDM_BRK_DELETE,          "Delete"       );
  1393.             AppendMenu( context_menu, MF_SEPARATOR, 0, nullptr); //================================
  1394.             mf_flag = ( (current_listbox_menu != IDC_CBP) &&
  1395.                         (brk_xxx_all_possible) 
  1396.                                                 )  ?  MF_STRING:
  1397.                                                       MF_STRING | MF_GRAYED;
  1398.             AppendMenu( context_menu, mf_flag, IDM_BRK_ENABLE_ALL,      "Enable All"   );
  1399.             //-------------------------------------------------------------------------------------
  1400.             AppendMenu( context_menu, mf_flag, IDM_BRK_DISABLE_ALL,     "Disable All"  );
  1401.             AppendMenu( context_menu, MF_SEPARATOR, 0, nullptr); //================================
  1402.             AppendMenu( context_menu, mf_flag, IDM_BRK_DELETE_ALL,      "Delete All"   );
  1403.                                                                 //=================================
  1404.             //-----------------------------------------------------------------
  1405.             // TPM_LAYOUTRTL выравниввниие по правому краю
  1406.             int cmd = TrackPopupMenu(   context_menu,                   // handle of shortcut menu
  1407.                                         TPM_RETURNCMD | TPM_NONOTIFY | TPM_LEFTALIGN | TPM_TOPALIGN, //uFlags
  1408.                                         xPos,                           // x
  1409.                                         yPos,                           // y
  1410.                                         0,                              // nReserved
  1411.                                         dlg,    //      или (HWND) wp        // hWnd
  1412.                                         nullptr         //points to RECT that specifies no-dismissal area
  1413.                                  );
  1414.             //-----------------------------------------------------------------
  1415.             DestroyMenu( context_menu);
  1416.             //-----------------------------------------------------------------
  1417.             Z80 &cpu = CpuMgr.Cpu();    // cpu.xxx = текущий CPU
  1418.             //-----------------------------------------------------------------
  1419.             switch (cmd)
  1420.             {
  1421.                 //=============================================================
  1422.                 // Disable
  1423.                 case IDM_BRK_DISABLE:
  1424.                 {
  1425.                     //---------------------------------------------------------
  1426.                     switch (current_listbox_menu)
  1427.                     {
  1428.                         //case IDC_CBP:         goto;
  1429.                         case IDC_BPX:           goto disable_bpx;
  1430.                         case IDC_MEM_RD:        goto disable_bpr;
  1431.                         case IDC_MEM_WR:        goto disable_bpw;
  1432.                     }
  1433.                     //---------------------------------------------------------
  1434.                     break;
  1435.                 }
  1436.                 //=============================================================
  1437.                 // Edit
  1438.                 case IDM_BRK_EDIT:
  1439.                 {
  1440.                     //---------------------------------------------------------
  1441.                     switch (current_listbox_menu)
  1442.                     {
  1443.                         case IDC_CBP:           goto cbp_edit_label;
  1444.                         case IDC_BPX:           goto bpx_edit_label;
  1445.                         case IDC_MEM_RD:        goto bpr_edit_label;
  1446.                         case IDC_MEM_WR:        goto bpw_edit_label;
  1447.                     }
  1448.                     //---------------------------------------------------------
  1449.                     break;
  1450.                 }
  1451.                 //=============================================================
  1452.                 // Delete
  1453.                 case IDM_BRK_DELETE:
  1454.                 {
  1455.                     //---------------------------------------------------------
  1456.                     switch (current_listbox_menu)
  1457.                     {
  1458.                         case IDC_CBP:           goto del_cond;
  1459.                         case IDC_BPX:           goto del_bpx;
  1460.                         case IDC_MEM_RD:        goto del_mem_rd;
  1461.                         case IDC_MEM_WR:        goto del_mem_wr;
  1462.                     }
  1463.                     //---------------------------------------------------------
  1464.                     break;
  1465.                 }
  1466.                 //=============================================================
  1467.                 // Enable All
  1468.                 case IDM_BRK_ENABLE_ALL:
  1469.                 {
  1470.                     //---------------------------------------------------------
  1471.                     switch (current_listbox_menu)
  1472.                     {
  1473.                         //-----------------------------------------------------
  1474.                         case IDC_BPX: // Enable All
  1475.                         {
  1476.                             SetFocus( GetDlgItem( dlg, IDC_BPX));
  1477.                             //-------------------------------------------------
  1478.                             for (unsigned i = 0x0000;    i <= 0xFFFF;    i++)
  1479.                             {  
  1480.                                 if (cpu.membits[i] & MEMBITS_BPX)
  1481.                                 {
  1482.                                     // ставим флаг выключености
  1483.                                     cpu.bp_disable_bits[ i] &= u8( ~BP_DISABLE_BPX);
  1484.                                 }
  1485.                             }
  1486.                             //-------------------------------------------------
  1487.                             FillBpxBox(  dlg, 0);       // [NS]
  1488.                             // обновить окно дебагера
  1489.                             needclr++;
  1490.                             goto set_buttons_and_return;
  1491.                         }
  1492.                         //-----------------------------------------------------
  1493.                         case IDC_MEM_RD: // Enable All
  1494.                         {
  1495.                             SetFocus( GetDlgItem( dlg, IDE_MEM_RD));
  1496.                             //-------------------------------------------------
  1497.                             for (unsigned i = 0x0000;    i <= 0xFFFF;    i++)
  1498.                             {
  1499.                                 if (cpu.membits[i] & MEMBITS_BPR)
  1500.                                 {
  1501.                                     // ставим флаг выключености
  1502.                                     cpu.bp_disable_bits[ i] &= u8( ~BP_DISABLE_BPR);
  1503.                                 }
  1504.                             }
  1505.                             //-------------------------------------------------
  1506.                             Fill_Mem_RD_Box(  dlg, 0);  // [NS]
  1507.                             // обновить окно дебагера
  1508.                             needclr++;
  1509.                             goto set_buttons_and_return;
  1510.                         }
  1511.                         //-----------------------------------------------------
  1512.                         case IDC_MEM_WR: // Enable All
  1513.                         {
  1514.                             SetFocus( GetDlgItem( dlg, IDE_MEM_WR));
  1515.                             //-------------------------------------------------
  1516.                             for (unsigned i = 0x0000;    i <= 0xFFFF;    i++)
  1517.                             {
  1518.                                 if (cpu.membits[i] & MEMBITS_BPW)
  1519.                                 {
  1520.                                     // ставим флаг выключености
  1521.                                     cpu.bp_disable_bits[ i] &= u8( ~BP_DISABLE_BPW);
  1522.                                 }
  1523.                             }
  1524.                             //-------------------------------------------------
  1525.                             Fill_Mem_WR_Box(  dlg, 0);  // [NS]
  1526.                             // обновить окно дебагера
  1527.                             needclr++;
  1528.                             goto set_buttons_and_return;
  1529.                         }
  1530.                         //-----------------------------------------------------
  1531.                     } // switch (current_listbox_menu)
  1532.                     //---------------------------------------------------------
  1533.                     break;
  1534.                 } // case IDM_BRK_ENABLE_ALL:
  1535.                 //=============================================================
  1536.                
  1537.                
  1538.                
  1539.                 //=============================================================
  1540.                 // Disable All
  1541.                 case IDM_BRK_DISABLE_ALL:
  1542.                 {
  1543.                     // отключать НЕЛЬЗЯ простым циклом 0-FFFF !!!!!
  1544.                     // тк потом будут создаватсо отключенные бряки!!!
  1545.                     //
  1546.                     // нужно проверять стоит ли бряк
  1547.                     // и если он есть тогда только отключать !!!!
  1548.                     //---------------------------------------------------------
  1549.                     switch (current_listbox_menu)
  1550.                     {
  1551.                         //-----------------------------------------------------
  1552.                         case IDC_BPX:
  1553.                         {
  1554.                             SetFocus( GetDlgItem( dlg, IDC_BPX));
  1555.                             //-------------------------------------------------
  1556.                             for (unsigned i = 0x0000;    i <= 0xFFFF;    i++)
  1557.                             {  
  1558.                                 if (cpu.membits[i] & MEMBITS_BPX)
  1559.                                 {
  1560.                                     // ставим флаг выключености
  1561.                                     cpu.bp_disable_bits[ i] |= u8( BP_DISABLE_BPX);
  1562.                                 }
  1563.                             }
  1564.                             //-------------------------------------------------
  1565.                             FillBpxBox(  dlg, 0);       // [NS]
  1566.                             // обновить окно дебагера
  1567.                             needclr++;
  1568.                             goto set_buttons_and_return;
  1569.                         }
  1570.                         //-----------------------------------------------------
  1571.                         case IDC_MEM_RD:
  1572.                         {
  1573.                             SetFocus( GetDlgItem( dlg, IDE_MEM_RD));
  1574.                             //-------------------------------------------------
  1575.                             for (unsigned i = 0x0000;    i <= 0xFFFF;    i++)
  1576.                             {
  1577.                                 if (cpu.membits[i] & MEMBITS_BPR)
  1578.                                 {
  1579.                                     // ставим флаг выключености
  1580.                                     cpu.bp_disable_bits[ i] |= u8( BP_DISABLE_BPR);
  1581.                                 }
  1582.                             }
  1583.                             //-------------------------------------------------
  1584.                             Fill_Mem_RD_Box(  dlg, 0);  // [NS]
  1585.                             // обновить окно дебагера
  1586.                             needclr++;
  1587.                             goto set_buttons_and_return;
  1588.                         }
  1589.                         //-----------------------------------------------------
  1590.                         case IDC_MEM_WR:
  1591.                         {
  1592.                             SetFocus( GetDlgItem( dlg, IDE_MEM_WR));
  1593.                             //-------------------------------------------------
  1594.                             for (unsigned i = 0x0000;    i <= 0xFFFF;    i++)
  1595.                             {
  1596.                                 if (cpu.membits[i] & MEMBITS_BPW)
  1597.                                 {
  1598.                                     // ставим флаг выключености
  1599.                                     cpu.bp_disable_bits[ i] |= u8( BP_DISABLE_BPW);
  1600.                                 }
  1601.                             }
  1602.                             //-------------------------------------------------
  1603.                             Fill_Mem_WR_Box(  dlg, 0);  // [NS]
  1604.                             // обновить окно дебагера
  1605.                             needclr++;
  1606.                             goto set_buttons_and_return;
  1607.                         }
  1608.                         //-----------------------------------------------------
  1609.                     } // switch (current_listbox_menu)
  1610.                     //---------------------------------------------------------
  1611.                     break;
  1612.                 } // case IDM_BRK_DISABLE_ALL:
  1613.                 //=============================================================
  1614.                
  1615.                
  1616.                
  1617.                 //=============================================================
  1618.                 // Delete All
  1619.                 case IDM_BRK_DELETE_ALL:
  1620.                 {
  1621.                     //---------------------------------------------------------
  1622.                     switch (current_listbox_menu)
  1623.                     {
  1624.                         //-----------------------------------------------------
  1625.                         case IDC_BPX:
  1626.                         {
  1627.                             SetFocus( GetDlgItem( dlg, IDC_BPX));
  1628.                             //-------------------------------------------------
  1629.                             for (unsigned i = 0x0000;    i <= 0xFFFF;    i++)
  1630.                             {
  1631.                                 // удаляем бряк
  1632.                                 cpu.membits[ i] &= u8( ~(MEMBITS_BPX));        
  1633.                                 // удаляем флаг выключености
  1634.                                 cpu.bp_disable_bits[ i] &= u8( ~(BP_DISABLE_BPX));
  1635.                             }
  1636.                             //-------------------------------------------------
  1637.                             FillBpxBox(  dlg, 0);       // [NS]
  1638.                             // обновить окно дебагера
  1639.                             needclr++;
  1640.                             goto set_buttons_and_return;
  1641.                         }
  1642.                         //-----------------------------------------------------
  1643.                         case IDC_MEM_RD:
  1644.                         {
  1645.                             SetFocus( GetDlgItem( dlg, IDE_MEM_RD));
  1646.                             //-------------------------------------------------
  1647.                             for (unsigned i = 0x0000;    i <= 0xFFFF;    i++)
  1648.                             {
  1649.                                 // удаляем бряк
  1650.                                 cpu.membits[ i] &= u8( ~(MEMBITS_BPR));        
  1651.                                 // удаляем флаг выключености
  1652.                                 cpu.bp_disable_bits[ i] &= u8( ~(BP_DISABLE_BPR));
  1653.                             }
  1654.                             //-------------------------------------------------
  1655.                             Fill_Mem_RD_Box(  dlg, 0);  // [NS]
  1656.                             // обновить окно дебагера
  1657.                             needclr++;
  1658.                             goto set_buttons_and_return;
  1659.                         }
  1660.                         //-----------------------------------------------------
  1661.                         case IDC_MEM_WR:
  1662.                         {
  1663.                             SetFocus( GetDlgItem( dlg, IDE_MEM_WR));
  1664.                             //-------------------------------------------------
  1665.                             for (unsigned i = 0x0000;    i <= 0xFFFF;    i++)
  1666.                             {
  1667.                                 // удаляем бряк
  1668.                                 cpu.membits[ i] &= u8( ~(MEMBITS_BPW));        
  1669.                                 // удаляем флаг выключености
  1670.                                 cpu.bp_disable_bits[ i] &= u8( ~(BP_DISABLE_BPW));
  1671.                             }
  1672.                             //-------------------------------------------------
  1673.                             Fill_Mem_WR_Box(  dlg, 0);  // [NS]
  1674.                             // обновить окно дебагера
  1675.                             needclr++;
  1676.                             goto set_buttons_and_return;
  1677.                         }
  1678.                         //-----------------------------------------------------
  1679.                     } // switch (current_listbox_menu)
  1680.                     //---------------------------------------------------------
  1681.                     break;
  1682.                 } // case IDM_BRK_DELETE_ALL:
  1683.                 //=============================================================
  1684.                
  1685.                
  1686.                
  1687.                
  1688.             } // switch (cmd)
  1689.             //-----------------------------------------------------------------
  1690.         } // (display_listbox_menu)
  1691.         //=====================================================================
  1692.     } //if (msg == WM_CONTEXTMENU)
  1693.     //=========================================================================
  1694.  
  1695.  
  1696.     //-------------------------------------------------------------------------
  1697.     // if (msg == WM_DESTROY)
  1698.     // {
  1699.     //     printf("conddlg WM_DESTROY\n");
  1700.     // }
  1701.     //=========================================================================
  1702.     if (msg == WM_CLOSE)        // [NS]
  1703.     {
  1704.         //printf("conddlg WM_CLOSE\n");
  1705.         DestroyWindow( dlg);
  1706.         hwnd_bp_dialog = NULL;  // теперь окно можно снова вызвать
  1707.     }
  1708.     //=========================================================================
  1709.     // глушим звук (иначе буфер зацикленно играет по кругу)
  1710.     // тк дефолтный виндовый обработчик WM_MOVE
  1711.     // не возвращает управления на время перемещения
  1712.     if (msg == WM_MOVE)         // [NS]
  1713.     {
  1714.         OnEnterGui();
  1715.     }
  1716.     //=========================================================================
  1717.     // включаем обратно
  1718.     if (msg == WM_EXITSIZEMOVE) // [NS]
  1719.     {
  1720.         OnExitGui();
  1721.     }
  1722.     //=========================================================================
  1723.     if (msg == WM_INITDIALOG)
  1724.     {
  1725.         FillCondBox( dlg, 0);
  1726.         FillBpxBox(  dlg, 0);
  1727.         Fill_Mem_RD_Box(  dlg, 0);      // [NS]
  1728.         Fill_Mem_WR_Box(  dlg, 0);      // [NS]
  1729.         //FillMemBox(  dlg, 0);         // Deprecated
  1730.         conddlg_update_texts( dlg);     // [NS]
  1731.  
  1732.         // [NS]                                                        
  1733.         CheckDlgButton( dlg, IDC_BPX_GROUP,    group_bpx_list  ?  BST_CHECKED :
  1734.                                                                   BST_UNCHECKED);
  1735.         CheckDlgButton( dlg, IDC_MEM_RD_GROUP, group_bpr_list  ?  BST_CHECKED :
  1736.                                                                   BST_UNCHECKED);
  1737.         CheckDlgButton( dlg, IDC_MEM_WR_GROUP, group_bpw_list  ?  BST_CHECKED :
  1738.                                                                   BST_UNCHECKED);
  1739.        
  1740.         SetFocus( GetDlgItem( dlg, IDE_CBP));
  1741.  
  1742. set_buttons_and_return:         // вызываетсо отовсюду
  1743.         SetBpxButtons( dlg);
  1744.        
  1745.         // возвращаем CPU на место перед выходом
  1746.         CpuMgr.SetCurrentCpu( current_cpu_back);
  1747.        
  1748.         return 1;
  1749.     }
  1750.     //=========================================================================
  1751.     if ((msg == WM_SYSCOMMAND) && ((wp & 0xFFF0) == SC_CLOSE))
  1752.     {
  1753.         //printf("conddlg SC_CLOSE \n");
  1754.         EndDialog( dlg, 0);
  1755.     }
  1756.     //=========================================================================
  1757.     if (msg != WM_COMMAND)
  1758.     {
  1759.         // возвращаем CPU на место перед выходом
  1760.         CpuMgr.SetCurrentCpu( current_cpu_back);
  1761.        
  1762.         return 0;
  1763.     }
  1764.     //=========================================================================
  1765.    
  1766.    
  1767.     //=========================================================================
  1768.  
  1769.     //-------------------------------------------------------------------------
  1770.     // нет никакого OK и Cancel у этого окна [NS]
  1771.     // но эта хуита срабатывает если при входе нажать enter
  1772.     //  if (id == IDCANCEL || id == IDOK)
  1773.     //  {
  1774.     //     printf("conddlg not existed IDCANCEL IDOK \n");
  1775.     //     EndDialog( dlg, 0);
  1776.     //  }
  1777.     //    
  1778.     //-------------------------------------------------------------------------
  1779.     char tmp[ 0x200];
  1780.    
  1781.    
  1782.     //=========================================================================
  1783.     if (   (    ((id == IDE_BPX) || (id == IDE_CBP) || (id == IDE_MEM_RD) || (id == IDE_MEM_WR))        &&
  1784.                 ((code == EN_SETFOCUS) || (code == EN_CHANGE))
  1785.            )
  1786.            ||
  1787.            (    ((id == IDC_BPX) || (id == IDC_CBP) || (id == IDC_MEM_RD) || (id == IDC_MEM_WR))        &&
  1788.                 (code == LBN_SETFOCUS)
  1789.            )
  1790.       )
  1791.     {
  1792.         goto set_buttons_and_return;
  1793.     }
  1794.     //=========================================================================
  1795.     /*
  1796.     // больше нету
  1797.     if ((id == IDC_MEM_R) || (id == IDC_MEM_W))
  1798.         goto set_buttons_and_return;
  1799.     */
  1800.     //=========================================================================
  1801.    
  1802.    
  1803.                                         // [NZ]
  1804.    
  1805.    
  1806.    
  1807.    
  1808.     //=========================================================================
  1809.     if (id == IDC_BPX_GROUP)
  1810.     {
  1811.         group_bpx_list = FALSE;
  1812.         //---------------------------------------------------------------------
  1813.         if (IsDlgButtonChecked( dlg, IDC_BPX_GROUP) == BST_CHECKED)
  1814.         {
  1815.             group_bpx_list = TRUE;
  1816.         }
  1817.         //---------------------------------------------------------------------
  1818.         FillBpxBox( dlg, 0);
  1819.         goto set_buttons_and_return;
  1820.     }
  1821.     //-------------------------------------------------------------------------
  1822.     if (id == IDC_MEM_RD_GROUP)
  1823.     {
  1824.         group_bpr_list = FALSE;
  1825.         //---------------------------------------------------------------------
  1826.         if (IsDlgButtonChecked( dlg, IDC_MEM_RD_GROUP) == BST_CHECKED)
  1827.         {
  1828.             group_bpr_list = TRUE;
  1829.         }
  1830.         //---------------------------------------------------------------------
  1831.         Fill_Mem_RD_Box( dlg, 0);
  1832.         goto set_buttons_and_return;
  1833.     }
  1834.     //-------------------------------------------------------------------------
  1835.     if (id == IDC_MEM_WR_GROUP)
  1836.     {
  1837.         group_bpw_list = FALSE;
  1838.         //---------------------------------------------------------------------
  1839.         if (IsDlgButtonChecked( dlg, IDC_MEM_WR_GROUP) == BST_CHECKED)
  1840.         {
  1841.             group_bpw_list = TRUE;
  1842.         }
  1843.         //---------------------------------------------------------------------
  1844.         Fill_Mem_WR_Box( dlg, 0);
  1845.         goto set_buttons_and_return;
  1846.     }
  1847.     //=========================================================================
  1848.    
  1849.                
  1850.                
  1851.                
  1852.     //=========================================================================
  1853.     if (id == IDB_CBP_EDIT)                                             // [NS]
  1854.     {
  1855. cbp_edit_label:
  1856.         if (MoveBpxFromBoxToEdit( dlg, IDC_CBP, IDE_CBP))
  1857.         {
  1858.             goto del_cond;
  1859.         }
  1860.     }
  1861.     //-------------------------------------------------------------------------
  1862.     if (id == IDB_BPX_EDIT)                                             // [NS]
  1863.     {
  1864. bpx_edit_label:
  1865.         if (MoveBpxFromBoxToEdit( dlg, IDC_BPX, IDE_BPX))
  1866.         {
  1867.             goto del_bpx;
  1868.         }
  1869.     }
  1870.     //-------------------------------------------------------------------------
  1871.     if (id == IDB_MEM_RD_EDIT)                                          // [NS]
  1872.     {
  1873. bpr_edit_label:
  1874.         if (MoveBpxFromBoxToEdit( dlg, IDC_MEM_RD, IDE_MEM_RD))
  1875.         {
  1876.             goto del_mem_rd;
  1877.         }
  1878.     }
  1879.     //-------------------------------------------------------------------------
  1880.     if (id == IDB_MEM_WR_EDIT)                                          // [NS]
  1881.     {
  1882. bpw_edit_label:
  1883.         if (MoveBpxFromBoxToEdit( dlg, IDC_MEM_WR, IDE_MEM_WR))
  1884.         {
  1885.             goto del_mem_wr;
  1886.         }
  1887.     }
  1888.     //=========================================================================
  1889.    
  1890.    
  1891.    
  1892.    
  1893.    
  1894.    
  1895.     //=========================================================================
  1896.     // отключение бряка
  1897.     if (code == LBN_DBLCLK)
  1898.     {
  1899.         //if (id == IDC_CBP)
  1900.         //{
  1901.         //      ;
  1902.         //}
  1903.         //---------------------------------------------------------------------
  1904.         // дабл клик в execute break listbox-е
  1905.         if (id == IDC_BPX)
  1906.         {
  1907.             //printf("LBN_DBLCLK IDC_BPX\n");
  1908. disable_bpx:
  1909.             SetFocus( GetDlgItem( dlg, IDE_BPX));
  1910.             id = IDC_BPX;
  1911.             disable_bp_mask = u8( BP_DISABLE_BPX);
  1912. disable_range:
  1913.             unsigned cur = unsigned( SendDlgItemMessage( dlg, id, LB_GETCURSEL, 0, 0));
  1914.             unsigned max = unsigned( SendDlgItemMessage( dlg, id, LB_GETCOUNT,  0, 0));
  1915.             //-----------------------------------------------------------------
  1916.             if (cur >= max)
  1917.             {
  1918.                 // возвращаем CPU на место перед выходом
  1919.                 CpuMgr.SetCurrentCpu( current_cpu_back);
  1920.        
  1921.                 return 0;
  1922.             }
  1923.             //-----------------------------------------------------------------
  1924.             SendDlgItemMessage( dlg, id, LB_GETTEXT, cur, (LPARAM) tmp);
  1925.             unsigned start, end;
  1926.             sscanf( tmp, "%X", &start);
  1927.             //-----------------------------------------------------------------
  1928.             if (tmp[ 4] == '-')
  1929.             {
  1930.                 sscanf( tmp + 5, "%X", &end);
  1931.             }
  1932.             //-----------------------------------------------------------------
  1933.             else
  1934.             {
  1935.                 end = start;
  1936.             }
  1937.             //-----------------------------------------------------------------
  1938.             Z80 &cpu = CpuMgr.Cpu();
  1939.             //-----------------------------------------------------------------
  1940.             for (unsigned i = start;    i <= end;    i++)
  1941.                 cpu.bp_disable_bits[ i] ^= disable_bp_mask;
  1942.             //---------------------------------------------------------------------
  1943.          
  1944.          
  1945.                
  1946.                 // НЕ ТОЛЬКО ДЛЯ (id == IDC_BPX) !!!!
  1947.                 // ниже сюда goto
  1948.                 //---------------------------------------------------------------------
  1949.                 // Exe BP
  1950.                 if (id == IDC_BPX)
  1951.                 {
  1952.                     FillBpxBox( dlg, 0);
  1953.                 }
  1954.                 //---------------------------------------------------------------------
  1955.                 // Read BP
  1956.                 else if (id == IDC_MEM_RD)
  1957.                 {
  1958.                     Fill_Mem_RD_Box( dlg, 0);
  1959.                 }
  1960.                 //---------------------------------------------------------------------
  1961.                 // Write BP
  1962.                 else if (id == IDC_MEM_WR)
  1963.                 {
  1964.                     Fill_Mem_WR_Box( dlg, 0);
  1965.                 }
  1966.                 //---------------------------------------------------------------------
  1967.                
  1968.                
  1969.                 /*
  1970.                 // DEBUG !!!!!!!!!!!!1
  1971.                 FillBpxBox( dlg, 0);
  1972.                 Fill_Mem_RD_Box( dlg, 0);
  1973.                 Fill_Mem_WR_Box( dlg, 0);
  1974.                 */
  1975.                
  1976.             //---------------------------------------------------------------------
  1977.             if (cur && (cur == max))
  1978.                 cur--;
  1979.             //---------------------------------------------------------------------
  1980.             SendDlgItemMessage( dlg, id, LB_SETCURSEL, cur, 0);
  1981.             cpu.dbgchk = isbrk( cpu);
  1982.             goto set_buttons_and_return;
  1983.         }
  1984.         //---------------------------------------------------------------------
  1985.         // дабл клик в memory read break listbox-е
  1986.         if (id == IDC_MEM_RD)
  1987.         {
  1988. disable_bpr:
  1989.             //printf("LBN_DBLCLK IDC_MEM_RD\n");
  1990.             SetFocus( GetDlgItem( dlg, IDE_MEM_RD));
  1991.             id = IDC_MEM_RD;
  1992.             disable_bp_mask = u8( BP_DISABLE_BPR);
  1993.             goto disable_range;
  1994.         }
  1995.         //---------------------------------------------------------------------
  1996.         // дабл клик в memory write listbox-е
  1997.         if (id == IDC_MEM_WR)
  1998.         {
  1999. disable_bpw:
  2000.             //printf("LBN_DBLCLK IDC_MEM_WR\n");
  2001.             SetFocus( GetDlgItem( dlg, IDE_MEM_WR));
  2002.             id = IDC_MEM_WR;
  2003.             disable_bp_mask = u8( BP_DISABLE_BPW);
  2004.             goto disable_range;
  2005.         }
  2006.         //---------------------------------------------------------------------
  2007.     }
  2008.     //=========================================================================
  2009.     //
  2010.     if (id == IDB_SWITCH_CPU)
  2011.     {
  2012.         // бекапим текущий CPU
  2013.         ///current_cpu_back = CpuMgr.GetCurrentCpu();  
  2014.         conddlg_current_visible_cpu ^= 1;              
  2015.         // меняем текущий CPU
  2016.         CpuMgr.SetCurrentCpu( conddlg_current_visible_cpu);    
  2017.  
  2018.         //Z80 &cpu = CpuMgr.Cpu();
  2019.        
  2020.         /*
  2021.         Z80 &cpu0 = CpuMgr.Cpu();
  2022.         cpu0.dbgbreak = 0;
  2023.         CpuMgr.SwitchCpu();
  2024.         Z80 &cpu1 = CpuMgr.Cpu();
  2025.         */
  2026.        
  2027.         FillCondBox( dlg, 0);
  2028.         FillBpxBox(  dlg, 0);
  2029.         Fill_Mem_RD_Box(  dlg, 0);      // [NS]
  2030.         Fill_Mem_WR_Box(  dlg, 0);      // [NS]
  2031.        
  2032.        
  2033.         conddlg_update_texts( dlg);
  2034.        
  2035.         // возвращаем CPU на место
  2036.         //CpuMgr.SetCurrentCpu( current_cpu_back);     
  2037.  
  2038.         //needclr++;    // нужно обновить окно дебагера
  2039.                         // теперь не нужно тк не синхронно
  2040.         goto set_buttons_and_return;
  2041.     }
  2042.     //-------------------------------------------------------------------------
  2043.  
  2044.  
  2045.  
  2046.  
  2047.  
  2048.  
  2049.     /*
  2050.     // редактирование по двойному клику
  2051.     if (code == LBN_DBLCLK)
  2052.     {
  2053.         if ((id == IDC_CBP) && MoveBpxFromBoxToEdit( dlg, IDC_CBP, IDE_CBP))    goto del_cond;
  2054.         if ((id == IDC_BPX) && MoveBpxFromBoxToEdit( dlg, IDC_BPX, IDE_BPX))    goto del_bpx;
  2055.         if ((id == IDC_MEM) && MoveBpxFromBoxToEdit( dlg, IDC_MEM, IDE_MEM))    goto del_mem;
  2056.     }
  2057.     */
  2058.     //-------------------------------------------------------------------------
  2059.     if (id == IDB_CBP_ADD)
  2060.     {
  2061.         SendDlgItemMessage( dlg, IDE_CBP, WM_GETTEXT, sizeof tmp, (LPARAM) tmp);
  2062.         SetFocus( GetDlgItem( dlg, IDE_CBP));
  2063.         Z80 &cpu = CpuMgr.Cpu();
  2064.         //---------------------------------------------------------------------
  2065.         if (!toscript( tmp, cpu.cbp[ cpu.cbpn]))
  2066.         {
  2067.             MessageBox( dlg,
  2068.                         "Error in expression\nPlease do RTFM",
  2069.                         nullptr,
  2070.                         MB_ICONERROR
  2071.                      );
  2072.             // возвращаем CPU на место перед выходом
  2073.             CpuMgr.SetCurrentCpu( current_cpu_back);
  2074.            
  2075.             return 1;
  2076.         }
  2077.         //---------------------------------------------------------------------
  2078.         SendDlgItemMessage( dlg, IDE_CBP, WM_SETTEXT, 0, 0);
  2079.         FillCondBox( dlg, cpu.cbpn++);
  2080.         cpu.dbgchk = isbrk( cpu);
  2081.         goto set_buttons_and_return;
  2082.     }
  2083.     //-------------------------------------------------------------------------
  2084.     if (id == IDB_BPX_ADD)
  2085.     {
  2086.         SendDlgItemMessage( dlg, IDE_BPX, WM_GETTEXT, sizeof tmp, (LPARAM) tmp);
  2087.         SetFocus( GetDlgItem( dlg, IDE_BPX));
  2088.         MEM_RANGE range;
  2089.         //---------------------------------------------------------------------
  2090.         if (!GetMemRamge( tmp, range))
  2091.         {
  2092.             MessageBox( dlg,
  2093.                         "Invalid breakpoint address / range",
  2094.                         nullptr,
  2095.                         MB_ICONERROR
  2096.                      );
  2097.                      
  2098.             // возвращаем CPU на место перед выходом
  2099.             CpuMgr.SetCurrentCpu( current_cpu_back);
  2100.            
  2101.             return 1;
  2102.         }
  2103.         //---------------------------------------------------------------------
  2104.         Z80 &cpu = CpuMgr.Cpu();
  2105.         //---------------------------------------------------------------------
  2106.         for (unsigned i = range.start;    i <= range.end;    i++)
  2107.         {
  2108.             cpu.membits[i] |= MEMBITS_BPX;
  2109.         }
  2110.         //---------------------------------------------------------------------
  2111.         SendDlgItemMessage( dlg, IDE_BPX, WM_SETTEXT, 0, 0);
  2112.         FillBpxBox( dlg, range.start);
  2113.         cpu.dbgchk = isbrk( cpu);
  2114.         goto set_buttons_and_return;
  2115.     }
  2116.     //-------------------------------------------------------------------------
  2117.    
  2118.    
  2119.     //-------------------------------------------------------------------------
  2120.     if (id == IDB_MEM_RD_ADD)   // [NS]
  2121.     {
  2122.         SendDlgItemMessage( dlg, IDE_MEM_RD, WM_GETTEXT, sizeof tmp, (LPARAM) tmp);
  2123.         SetFocus( GetDlgItem( dlg, IDE_MEM_RD));
  2124.         MEM_RANGE range;
  2125.         //---------------------------------------------------------------------
  2126.         if (!GetMemRamge( tmp, range))
  2127.         {
  2128.             MessageBox( dlg,
  2129.                         "Invalid breakpoint address / range",
  2130.                         nullptr,
  2131.                         MB_ICONERROR
  2132.                      );
  2133.                      
  2134.             // возвращаем CPU на место перед выходом
  2135.             CpuMgr.SetCurrentCpu( current_cpu_back);
  2136.            
  2137.             return 1;
  2138.         }
  2139.         //---------------------------------------------------------------------
  2140.         Z80 &cpu = CpuMgr.Cpu();
  2141.         //---------------------------------------------------------------------
  2142.         for (unsigned i = range.start;    i <= range.end;    i++)
  2143.         {
  2144.             cpu.membits[i] |= MEMBITS_BPR;
  2145.         }
  2146.         //---------------------------------------------------------------------
  2147.         SendDlgItemMessage( dlg, IDE_MEM_RD, WM_SETTEXT, 0, 0);
  2148.         Fill_Mem_RD_Box( dlg, range.start);
  2149.         cpu.dbgchk = isbrk( cpu);
  2150.         goto set_buttons_and_return;
  2151.     }
  2152.     //-------------------------------------------------------------------------
  2153.    
  2154.    
  2155.  
  2156.     //-------------------------------------------------------------------------
  2157.     if (id == IDB_MEM_WR_ADD)
  2158.     {
  2159.         SendDlgItemMessage( dlg, IDE_MEM_WR, WM_GETTEXT, sizeof tmp, (LPARAM) tmp);
  2160.         SetFocus( GetDlgItem( dlg, IDE_MEM_WR));
  2161.         MEM_RANGE range;
  2162.         //---------------------------------------------------------------------
  2163.         if (!GetMemRamge( tmp, range))
  2164.         {
  2165.             MessageBox( dlg,
  2166.                         "Invalid breakpoint address / range",
  2167.                         nullptr,
  2168.                         MB_ICONERROR
  2169.                      );
  2170.                      
  2171.             // возвращаем CPU на место перед выходом
  2172.             CpuMgr.SetCurrentCpu( current_cpu_back);
  2173.            
  2174.             return 1;
  2175.         }
  2176.         //---------------------------------------------------------------------
  2177.         Z80 &cpu = CpuMgr.Cpu();
  2178.         //---------------------------------------------------------------------
  2179.         for (unsigned i = range.start;    i <= range.end;    i++)
  2180.         {
  2181.             cpu.membits[i] |= MEMBITS_BPW;
  2182.         }
  2183.         //---------------------------------------------------------------------
  2184.         SendDlgItemMessage( dlg, IDE_MEM_WR, WM_SETTEXT, 0, 0);
  2185.         Fill_Mem_WR_Box( dlg, range.start);
  2186.         cpu.dbgchk = isbrk( cpu);
  2187.         goto set_buttons_and_return;
  2188.     }
  2189.     //-------------------------------------------------------------------------
  2190.    
  2191.    
  2192.    
  2193.     //=========================================================================
  2194.     if (id == IDB_CBP_DEL)
  2195.     {
  2196. del_cond:
  2197.         SetFocus( GetDlgItem( dlg, IDE_CBP));
  2198.         unsigned cur = unsigned( SendDlgItemMessage( dlg, IDC_CBP, LB_GETCURSEL, 0, 0));
  2199.         Z80 &cpu = CpuMgr.Cpu();
  2200.         //---------------------------------------------------------------------
  2201.         if (cur >= cpu.cbpn)
  2202.         {
  2203.             // возвращаем CPU на место перед выходом
  2204.             CpuMgr.SetCurrentCpu( current_cpu_back);
  2205.            
  2206.             return 0;
  2207.         }
  2208.         //---------------------------------------------------------------------
  2209.         cpu.cbpn--;
  2210.         memcpy( cpu.cbp[ cur],
  2211.                 cpu.cbp[ cur + 1],
  2212.                 sizeof( cpu.cbp[ 0]) * (cpu.cbpn - cur)
  2213.             );
  2214.         //---------------------------------------------------------------------
  2215.         if (cur && cur == cpu.cbpn)
  2216.             cur--;
  2217.         //-------------------------------------------------------------------------
  2218.         FillCondBox( dlg, cur);
  2219.         cpu.dbgchk = isbrk( cpu);
  2220.         goto set_buttons_and_return;
  2221.     }
  2222.     //-------------------------------------------------------------------------
  2223.    
  2224.    
  2225.     //-------------------------------------------------------------------------
  2226.     // Удаление BPX (и за одноо BPW, BPR)
  2227.     if (id == IDB_BPX_DEL)
  2228.     {
  2229. del_bpx:
  2230.         SetFocus( GetDlgItem( dlg, IDE_BPX));
  2231.         id = IDC_BPX;
  2232.         mask = u8( ~MEMBITS_BPX);
  2233.         disable_bp_mask = u8( ~BP_DISABLE_BPX);
  2234. del_range:
  2235.         unsigned cur = unsigned( SendDlgItemMessage( dlg, id, LB_GETCURSEL, 0, 0));
  2236.         //printf("cur %d\n",cur);
  2237.         unsigned max = unsigned( SendDlgItemMessage( dlg, id, LB_GETCOUNT,  0, 0));
  2238.         //printf("max %d\n",max);
  2239.         //---------------------------------------------------------------------
  2240.         if (cur >= max)
  2241.         {
  2242.             // возвращаем CPU на место перед выходом
  2243.             CpuMgr.SetCurrentCpu( current_cpu_back);
  2244.            
  2245.             return 0;
  2246.         }
  2247.         //---------------------------------------------------------------------
  2248.         SendDlgItemMessage( dlg, id, LB_GETTEXT, cur, (LPARAM) tmp);
  2249.         unsigned start, end;
  2250.         sscanf( tmp, "%X", &start);
  2251.         //---------------------------------------------------------------------
  2252.         if (tmp[ 4] == '-')
  2253.         {
  2254.             sscanf( tmp + 5, "%X", &end);
  2255.         }
  2256.         //---------------------------------------------------------------------
  2257.         else
  2258.         {
  2259.             end = start;
  2260.         }
  2261.         //---------------------------------------------------------------------
  2262.         Z80 &cpu = CpuMgr.Cpu();
  2263.         //---------------------------------------------------------------------
  2264.         for (unsigned i = start;    i <= end;    i++)
  2265.         {
  2266.             cpu.membits[ i] &= mask;                    // удаляем бряк
  2267.             cpu.bp_disable_bits[ i] &= disable_bp_mask; // удаляем флаг выключености
  2268.         }
  2269.         //---------------------------------------------------------------------
  2270.        
  2271.            
  2272.             // не только для (id == IDB_BPX_DEL)
  2273.             // ниже goto
  2274.             //-----------------------------------------------------------------
  2275.             if (id == IDC_BPX)
  2276.             {
  2277.                 FillBpxBox( dlg, 0);
  2278.             }
  2279.             //-----------------------------------------------------------------
  2280.             else if (id == IDC_MEM_RD)                                  // [NS]
  2281.             {
  2282.                 Fill_Mem_RD_Box( dlg, 0);
  2283.             }
  2284.             //-----------------------------------------------------------------
  2285.             else if (id == IDC_MEM_WR)                                  // [NS]
  2286.             {
  2287.                 Fill_Mem_WR_Box( dlg, 0);
  2288.             }
  2289.             //-----------------------------------------------------------------
  2290.            
  2291.            
  2292.             /*
  2293.             // DEBUG !!!!!!!!!!!!!!!!!!
  2294.             FillBpxBox( dlg, 0);
  2295.             Fill_Mem_RD_Box( dlg, 0);
  2296.             Fill_Mem_WR_Box( dlg, 0);
  2297.             */
  2298.            
  2299.         //---------------------------------------------------------------------
  2300.         if (cur && (cur == max))
  2301.             cur--;
  2302.         //---------------------------------------------------------------------
  2303.         SendDlgItemMessage( dlg, id, LB_SETCURSEL, cur, 0);
  2304.         cpu.dbgchk = isbrk( cpu);
  2305.         goto set_buttons_and_return;
  2306.     }
  2307.     //-------------------------------------------------------------------------
  2308.     if (id == IDB_MEM_RD_DEL)
  2309.     {
  2310. del_mem_rd:
  2311.         SetFocus( GetDlgItem( dlg, IDE_MEM_RD));
  2312.         id = IDC_MEM_RD;
  2313.         mask = u8( ~(MEMBITS_BPR));
  2314.         disable_bp_mask = u8( ~BP_DISABLE_BPR);
  2315.         goto del_range;
  2316.     }
  2317.     //-------------------------------------------------------------------------
  2318.     if (id == IDB_MEM_WR_DEL)
  2319.     {
  2320. del_mem_wr:
  2321.         SetFocus( GetDlgItem( dlg, IDE_MEM_WR));
  2322.         id = IDC_MEM_WR;
  2323.         mask = u8( ~(MEMBITS_BPW));
  2324.         disable_bp_mask = u8( ~BP_DISABLE_BPW);
  2325.         goto del_range;
  2326.     }
  2327.  
  2328.     // возвращаем CPU на место перед выходом
  2329.     CpuMgr.SetCurrentCpu( current_cpu_back);
  2330.    
  2331.     return 0;
  2332. }
  2333. //=============================================================================
  2334. // создание диалогового окна бряков
  2335. void mon_bpdialog()
  2336. {
  2337.     // DialogBox( hIn, MAKEINTRESOURCE( IDD_COND), wnd, conddlg);       // orig
  2338.  
  2339.     //-------------------------------------------------------------------------
  2340.     // создаем окно                                                  // [NS]
  2341.     // только если оно еще не создано
  2342.     // иначе у нас обрабатываютсо сообщения только от одного окна
  2343.     // и нужен массив hwnd-овов
  2344.     if (hwnd_bp_dialog == NULL)
  2345.     {
  2346.         hwnd_bp_dialog = CreateDialog( hIn, MAKEINTRESOURCE( IDD_COND), wnd, conddlg);  // [NS]
  2347.     }
  2348.     //-------------------------------------------------------------------------
  2349.     // щас окно поверх всех унриальных окон почему то
  2350.     // а так тут нужно переводить фокус на окно
  2351.     // которрое могло потерятсо
  2352.     /*
  2353.     else
  2354.     {
  2355.         ShowWindow( hwnd_bp_dialog, SW_SHOWNORMAL);     //SW_SHOWMINNOACTIVE
  2356.     }*/
  2357. }
  2358. //=============================================================================
  2359.  
  2360.  
  2361.  
  2362.  
  2363.  
  2364.  
  2365.  
  2366.  
  2367.  
  2368.  
  2369.  
  2370.  
  2371.  
  2372.  
  2373.  
  2374.  
  2375.  
  2376.  
  2377.  
  2378.  
  2379.  
  2380.  
  2381.  
  2382.  
  2383.  
  2384.  
  2385.  
  2386.  
  2387.  
  2388.  
  2389.  
  2390.  
  2391. //=============================================================================
  2392. // обработка сообщений окна вачесов
  2393. static INT_PTR CALLBACK watchdlg( HWND dlg, UINT msg, WPARAM wp, LPARAM lp)
  2394. {
  2395.     (void) lp;
  2396.  
  2397.     char tmp[ 0x200];
  2398.     unsigned i;
  2399.     //-------------------------------------------------------------------------
  2400.     static const int ids1[] =
  2401.     {
  2402.         IDC_W1_ON,
  2403.         IDC_W2_ON,
  2404.         IDC_W3_ON,
  2405.         IDC_W4_ON
  2406.     };
  2407.     //-------------------------------------------------------------------------
  2408.     static const int ids2[] =
  2409.     {
  2410.         IDE_W1,
  2411.         IDE_W2,
  2412.         IDE_W3,
  2413.         IDE_W4
  2414.     };
  2415.     //-------------------------------------------------------------------------
  2416.     if (msg == WM_CLOSE)        // [NS]
  2417.     {
  2418.         DestroyWindow( dlg);
  2419.         hwnd_watchdlg = NULL;   // теперь окно можно снова вызвать
  2420.     }
  2421.     //-------------------------------------------------------------------------
  2422.     if (msg == WM_INITDIALOG)
  2423.     {
  2424.         //---------------------------------------------------------------------
  2425.         for (i = 0;    i < 4;    i++)
  2426.         {
  2427.             CheckDlgButton( dlg, ids1[i], watch_enabled[i]  ?   BST_CHECKED :
  2428.                                                                 BST_UNCHECKED);
  2429.             script2text( tmp, watch_script[i]);
  2430.             SetWindowText( GetDlgItem( dlg, ids2[i]), tmp);
  2431.         }
  2432.         //---------------------------------------------------------------------
  2433.         CheckDlgButton( dlg, IDC_TR_RAM,    trace_ram  ?  BST_CHECKED :
  2434.                                                           BST_UNCHECKED);
  2435.         //---------------------------------------------------------------------
  2436.         CheckDlgButton( dlg, IDC_TR_ROM,    trace_rom  ?  BST_CHECKED : // r0146 fixed было trace_ram [NS]
  2437.                                                           BST_UNCHECKED);
  2438.         //---------------------------------------------------------------------
  2439.         CheckDlgButton( dlg, IDC_LED_DEBUG, (conf.led.osw & 0x80000000)  ?  BST_CHECKED :       // [NS]
  2440.                                                                             BST_UNCHECKED);
  2441.         //---------------------------------------------------------------------
  2442. reinit:
  2443.         //---------------------------------------------------------------------
  2444.         for (i = 0;    i < 4;    i++)
  2445.             EnableWindow( GetDlgItem( dlg, ids2[ i]), watch_enabled[ i]);
  2446.         //---------------------------------------------------------------------
  2447.         return 1;
  2448.     }
  2449.     //-------------------------------------------------------------------------
  2450.     // Клацание птичек [Trace RAM banks] и [Trace ROM banks]
  2451.     if ((msg == WM_COMMAND)  &&  (      (LOWORD( wp) == IDC_TR_RAM)     ||
  2452.                                         (LOWORD( wp) == IDC_TR_ROM)
  2453.                                 )
  2454.      )
  2455.     {
  2456.         trace_ram = IsDlgButtonChecked( dlg, IDC_TR_RAM) == BST_CHECKED;
  2457.         trace_rom = IsDlgButtonChecked( dlg, IDC_TR_ROM) == BST_CHECKED;
  2458.     }
  2459.     //-------------------------------------------------------------------------
  2460.     // Клацание птички включения вачесов [NS]
  2461.     if ((msg == WM_COMMAND)  &&  (      (LOWORD( wp) == IDC_LED_DEBUG) )
  2462.      )
  2463.     {
  2464.         conf.led.osw =  (conf.led.osw & 0x7FFFFFFF)
  2465.                         |
  2466.                 ((IsDlgButtonChecked( dlg, IDC_LED_DEBUG) == BST_CHECKED)  ?  0x80000000 :
  2467.                                                                               0  );
  2468.         apply_video();  // без него не включаетсо ? [NS]
  2469.     }
  2470.     //-------------------------------------------------------------------------    
  2471.     // тк как отследить enter в поле редактирования мы не знаем
  2472.     // делаем кнопочку применить
  2473.     if ((msg == WM_COMMAND)  &&  (      (LOWORD( wp) == ID_APPLY) )
  2474.      )
  2475.     {
  2476.         //---------------------------------------------------------------------
  2477.         for (i = 0;    i < 4;    i++)
  2478.         {
  2479.             if (watch_enabled[ i])
  2480.             {
  2481.                 SendDlgItemMessage( dlg, ids2[i], WM_GETTEXT, sizeof tmp, (LPARAM)tmp);
  2482.                 //-------------------------------------------------------------
  2483.                 if (!toscript( tmp, watch_script[i]))
  2484.                 {
  2485.                     sprintf( tmp, "Watch %u: error in expression\nPlease do RTFM", i+1);
  2486.                     MessageBox( dlg, tmp, nullptr, MB_ICONERROR);
  2487.                     watch_enabled[ i] = 0;
  2488.                     SetFocus( GetDlgItem( dlg, ids2[i]));
  2489.                     return 0;
  2490.                 }
  2491.                 //-------------------------------------------------------------
  2492.             }
  2493.         }
  2494.         //---------------------------------------------------------------------
  2495.     }
  2496.     //-------------------------------------------------------------------------
  2497.    
  2498.     // видимо обработка 4-х кнопок вклюючения вачеса
  2499.     if ((msg == WM_COMMAND)  &&  (      (LOWORD( wp) == ids1[0]) ||
  2500.                                         (LOWORD( wp) == ids1[1]) ||
  2501.                                         (LOWORD( wp) == ids1[2]) ||
  2502.                                         (LOWORD( wp) == ids1[3])
  2503.                                   )
  2504.      )
  2505.     {
  2506.         //---------------------------------------------------------------------
  2507.         for (i = 0;    i < 4;    i++)
  2508.             watch_enabled[i] = IsDlgButtonChecked( dlg, ids1[ i]) == BST_CHECKED;
  2509.         //---------------------------------------------------------------------
  2510.         goto reinit;
  2511.     }    
  2512.     //-------------------------------------------------------------------------
  2513.     if (        ((msg == WM_SYSCOMMAND) && ((wp & 0xFFF0) == SC_CLOSE)) ||
  2514.                 ((msg == WM_COMMAND) && (LOWORD( wp) == IDCANCEL))
  2515.      )
  2516.     {
  2517.         trace_ram = IsDlgButtonChecked( dlg, IDC_TR_RAM) == BST_CHECKED;
  2518.         trace_rom = IsDlgButtonChecked( dlg, IDC_TR_ROM) == BST_CHECKED;
  2519.        
  2520.         // *(&conf.led.ay + 5) = ((*(&conf.led.ay + 5)) & 0x7FFFFFFF)
  2521.         conf.led.osw =  (conf.led.osw & 0x7FFFFFFF)
  2522.                         |
  2523.                 ((IsDlgButtonChecked( dlg, IDC_LED_DEBUG) == BST_CHECKED)  ?  0x80000000 :
  2524.                                                                               0  );
  2525.         apply_video();  // без него не включаетсо ? [NS]
  2526.         //---------------------------------------------------------------------
  2527.         for (i = 0;    i < 4;    i++)
  2528.         {
  2529.             if (watch_enabled[ i])
  2530.             {
  2531.                 SendDlgItemMessage( dlg, ids2[i], WM_GETTEXT, sizeof tmp, (LPARAM)tmp);
  2532.                 //-------------------------------------------------------------
  2533.                 if (!toscript( tmp, watch_script[i]))
  2534.                 {
  2535.                     sprintf( tmp, "Watch %u: error in expression\nPlease do RTFM", i+1);
  2536.                     MessageBox( dlg, tmp, nullptr, MB_ICONERROR);
  2537.                     watch_enabled[ i] = 0;
  2538.                     SetFocus( GetDlgItem( dlg, ids2[i]));
  2539.                     return 0;
  2540.                 }
  2541.                 //-------------------------------------------------------------
  2542.             }
  2543.         }
  2544.         //---------------------------------------------------------------------
  2545.         EndDialog( dlg, 0);
  2546.     }
  2547.     //-------------------------------------------------------------------------
  2548.     return 0;
  2549. }
  2550. //=============================================================================
  2551. void mon_watchdialog()
  2552. {
  2553.     //DialogBox( hIn, MAKEINTRESOURCE( IDD_OSW), wnd, watchdlg);
  2554.     //-------------------------------------------------------------------------
  2555.     // создаем окно                                                  // [NS]
  2556.     // только если оно еще не создано
  2557.     // иначе у нас обрабатываютсо сообщения только от одного окна
  2558.     // и нужен массив hwnd-овов
  2559.     if (!hwnd_watchdlg)
  2560.     {
  2561.         hwnd_watchdlg = CreateDialog( hIn, MAKEINTRESOURCE( IDD_OSW), wnd, watchdlg);   // [NS]
  2562.     }
  2563.     //-------------------------------------------------------------------------
  2564. }
  2565. //=============================================================================
  2566.  
  2567.  
  2568.  
  2569.  
  2570.  
  2571.  
  2572. //=============================================================================
  2573. static void LoadBpx()
  2574. {
  2575.     char Line[ 100];
  2576.     char BpxFileName[ FILENAME_MAX];
  2577.  
  2578.     addpath( BpxFileName, "bpx.ini");
  2579.  
  2580.     FILE *BpxFile = fopen( BpxFileName, "rt");
  2581.     //-------------------------------------------------------------------------
  2582.     if (!BpxFile)
  2583.         return;
  2584.     //-------------------------------------------------------------------------
  2585.     while (!feof( BpxFile))
  2586.     {
  2587.         fgets( Line, sizeof( Line), BpxFile);
  2588.         Line[ sizeof( Line) - 1] = 0;
  2589.         char Type = -1;
  2590.         int Start = -1;
  2591.         int End = -1;
  2592.         int CpuIdx = -1;
  2593.         int n = sscanf( Line, "%c%1d=%i-%i", &Type, &CpuIdx, &Start, &End);
  2594.         //---------------------------------------------------------------------
  2595.         if (n < 3 || CpuIdx < 0 || CpuIdx >= (int) CpuMgr.GetCount() || Start < 0)
  2596.             continue;
  2597.         //---------------------------------------------------------------------
  2598.         if (End < 0)
  2599.             End = Start;
  2600.         //---------------------------------------------------------------------
  2601.         unsigned mask = 0;
  2602.         //---------------------------------------------------------------------
  2603.         switch (Type)
  2604.         {
  2605.             case 'r':   mask |= MEMBITS_BPR;    break;
  2606.             case 'w':   mask |= MEMBITS_BPW;    break;
  2607.             case 'x':   mask |= MEMBITS_BPX;    break;
  2608.             default:    continue;
  2609.         }
  2610.         //---------------------------------------------------------------------
  2611.         Z80 &cpu = CpuMgr.Cpu( u32( CpuIdx));
  2612.         //---------------------------------------------------------------------
  2613.         for (unsigned i = unsigned( Start);    i <= unsigned( End);    i++)
  2614.             cpu.membits[ i] |= mask;
  2615.         //---------------------------------------------------------------------
  2616.         cpu.dbgchk = isbrk( cpu);
  2617.     }
  2618.     fclose( BpxFile);
  2619. }
  2620. //=============================================================================
  2621.  
  2622.  
  2623.  
  2624.  
  2625. //=============================================================================
  2626. static void SaveBpx()
  2627. {
  2628.     char BpxFileName[ FILENAME_MAX];
  2629.  
  2630.     addpath( BpxFileName, "bpx.ini");
  2631.  
  2632.     FILE *BpxFile = fopen( BpxFileName, "wt");
  2633.     //-------------------------------------------------------------------------
  2634.     if (!BpxFile)
  2635.         return;
  2636.     //-------------------------------------------------------------------------
  2637.     for (unsigned CpuIdx = 0;    CpuIdx < CpuMgr.GetCount();    CpuIdx++)
  2638.     {
  2639.         Z80 &cpu = CpuMgr.Cpu( CpuIdx);
  2640.         //---------------------------------------------------------------------
  2641.         for (int i = 0;    i < 3;    i++)
  2642.         {
  2643.             //-----------------------------------------------------------------
  2644.             for (unsigned Start = 0;    Start < 0x10000;    )
  2645.             {
  2646.                 static const unsigned Mask[] =
  2647.                 {
  2648.                     MEMBITS_BPR,
  2649.                     MEMBITS_BPW,
  2650.                     MEMBITS_BPX
  2651.                 };
  2652.                 //-------------------------------------------------------------
  2653.                 if (!(cpu.membits[ Start] & Mask[ i]))
  2654.                 {
  2655.                     Start++;
  2656.                     continue;
  2657.                 }
  2658.                 //-------------------------------------------------------------
  2659.                 unsigned active = cpu.membits[ Start];
  2660.                 unsigned End;
  2661.                 //-------------------------------------------------------------
  2662.                 for (End = Start;    End < 0xFFFF && !((active ^ cpu.membits[ End + 1]) & Mask[i]);    End++);
  2663.                 //-------------------------------------------------------------
  2664.                 static const char Type[] = { 'r', 'w', 'x' };
  2665.                 //-------------------------------------------------------------
  2666.                 if (active & Mask[i])
  2667.                 {
  2668.                     //---------------------------------------------------------
  2669.                     if (Start == End)
  2670.                     {
  2671.                         fprintf( BpxFile, "%c%1u=0x%04X\n", Type[ i], CpuIdx, Start);
  2672.                     }
  2673.                     //---------------------------------------------------------
  2674.                     else
  2675.                     {
  2676.                         fprintf( BpxFile, "%c%1u=0x%04X-0x%04X\n", Type[ i], CpuIdx, Start, End);
  2677.                     }
  2678.                     //---------------------------------------------------------
  2679.                 }
  2680.                 //-------------------------------------------------------------
  2681.                 Start = End + 1;
  2682.             }
  2683.             //-----------------------------------------------------------------
  2684.         }
  2685.         //---------------------------------------------------------------------
  2686.     }
  2687.     //-------------------------------------------------------------------------
  2688.     fclose( BpxFile);
  2689. }
  2690. //=============================================================================
  2691.  
  2692.  
  2693.  
  2694.  
  2695. //=============================================================================
  2696. void init_bpx()
  2697. {
  2698.     LoadBpx();
  2699. }
  2700. //=============================================================================
  2701.  
  2702.  
  2703. //=============================================================================
  2704. void done_bpx()
  2705. {
  2706.     SaveBpx();
  2707. }
  2708. //=============================================================================
  2709.  
  2710.  
  2711.