Subversion Repositories Kolibri OS

Rev

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

  1. format binary
  2. include '../../macros.inc'
  3. use32
  4.         db      'MENUET01'
  5.         dd      1
  6.         dd      start
  7.         dd      i_end
  8.         dd      used_mem
  9.         dd      used_mem
  10.         dd      i_param
  11.         dd      0
  12.  
  13. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  14. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; GUI ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  15. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  16.  
  17. data_width equ 80
  18. data_x_pos equ 12
  19. data_x_size equ data_width*6
  20.  
  21. title_x_pos equ 30
  22. title_y_pos equ 32
  23. title_y_size equ 10
  24.  
  25. registers_x_pos equ data_x_pos
  26. registers_y_pos equ (title_y_pos + title_y_size)
  27. registers_y_size equ 30
  28.  
  29. dump_y_pos equ (registers_y_pos + registers_y_size + 5)
  30. dump_height equ 4
  31. dump_y_size equ (dump_height*10)
  32.  
  33. disasm_y_pos equ (dump_y_pos + dump_y_size + 4)
  34. disasm_height equ 16
  35. disasm_y_size equ (disasm_height*10)
  36.  
  37. messages_width equ data_width
  38. messages_height equ 12
  39. messages_x_pos equ data_x_pos
  40. messages_y_pos equ (disasm_y_pos + disasm_y_size + 4)
  41. messages_x_size equ messages_width*6
  42. messages_y_size equ messages_height*10
  43.  
  44. cmdline_width equ data_width
  45. cmdline_x_pos equ data_x_pos
  46. cmdline_y_pos equ (messages_y_pos + messages_y_size + 10)
  47. cmdline_x_size equ messages_x_size
  48. cmdline_y_size equ 10
  49.  
  50. wnd_x_size equ (data_x_pos + messages_x_size + data_x_pos)
  51. wnd_y_size equ (cmdline_y_pos + cmdline_y_size + data_x_pos)
  52.  
  53. start:
  54.         mcall   68, 11
  55.         mov     edi, messages
  56.         mov     ecx, messages_width*messages_height
  57.         mov     al, ' '
  58.         rep     stosb
  59.         xor     eax, eax
  60.         mov     [messages_pos], eax
  61.         mov     [cmdline_len], eax
  62.         mov     [cmdline_pos], eax
  63.         mov     edi, needzerostart
  64.         mov     ecx, (needzeroend-needzerostart+3)/4
  65.         rep     stosd
  66.         mov     esi, begin_str
  67.         call    put_message_nodraw
  68. ; set event mask - default events and debugging events
  69.         push    40
  70.         pop     eax
  71.         mov     ebx, 0x107
  72.         mcall
  73. ; set debug messages buffer
  74.         mov     ecx, dbgbufsize
  75.         mov     dword [ecx], 256
  76.         xor     ebx, ebx
  77.         mov     [ecx+4], ebx
  78.         mov     al, 69
  79.         mcall
  80.         mov     esi, i_param
  81.         call    skip_spaces
  82.         test    al, al
  83.         jz      dodraw
  84.         push    esi
  85.         call    draw_window
  86.         pop     esi
  87.         call    OnLoadInit
  88.         jmp     waitevent
  89. dodraw:
  90.         call    draw_window
  91. waitevent:
  92.         push    10
  93.         pop     eax
  94.         mcall
  95.         cmp     al, 9
  96.         jz      debugmsg
  97.         dec     eax
  98.         jz      dodraw
  99.         dec     eax
  100.         jz      keypressed
  101.         dec     eax
  102.         jnz     waitevent
  103. ; button pressed - we have only one button (close)
  104.         push    -1
  105.         pop     eax
  106.         mcall
  107. keypressed:
  108.         mov     al, 2
  109.         mcall
  110.         shr     eax, 8
  111.         cmp     al, 8
  112.         jz      .backspace
  113.         cmp     al, 0xB0
  114.         jz      .left
  115.         cmp     al, 0xB3
  116.         jz      .right
  117.         cmp     al, 0x0D
  118.         jz      .enter
  119.         cmp     al, 0xB6
  120.         jz      .del
  121.         cmp     al, 0xB4
  122.         jz      .home
  123.         cmp     al, 0xB5
  124.         jz      .end
  125.         cmp     al, 0xB1
  126.         jz      .down
  127.         cmp     al, 0xB2
  128.         jz      .up
  129.         cmp     al, 0xD8
  130.         jz      CtrlF7
  131.         cmp     al, 0xD9
  132.         jz      CtrlF8
  133.         cmp     [cmdline_len], cmdline_width
  134.         jae     waitevent
  135.         push    eax
  136.         call    clear_cmdline_end
  137.         pop     eax
  138.         mov     edi, cmdline
  139.         mov     ecx, [cmdline_len]
  140.         add     edi, ecx
  141.         lea     esi, [edi-1]
  142.         sub     ecx, [cmdline_pos]
  143.         std
  144.         rep     movsb
  145.         cld
  146.         stosb
  147.         inc     [cmdline_len]
  148.         call    draw_cmdline_end
  149.         inc     [cmdline_pos]
  150.         call    draw_cursor
  151.         jmp     waitevent
  152. .backspace:
  153.         cmp     [cmdline_pos], 0
  154.         jz      waitevent
  155.         dec     [cmdline_pos]
  156. .delchar:
  157.         call    clear_cmdline_end
  158.         mov     edi, [cmdline_pos]
  159.         dec     [cmdline_len]
  160.         mov     ecx, [cmdline_len]
  161.         sub     ecx, edi
  162.         add     edi, cmdline
  163.         lea     esi, [edi+1]
  164.         rep     movsb
  165.         call    draw_cmdline_end
  166.         call    draw_cursor
  167.         jmp     waitevent
  168. .del:
  169.         mov     eax, [cmdline_pos]
  170.         cmp     eax, [cmdline_len]
  171.         jae     waitevent
  172.         jmp     .delchar
  173. .left:
  174.         cmp     [cmdline_pos], 0
  175.         jz      waitevent
  176.         call    hide_cursor
  177.         dec     [cmdline_pos]
  178.         call    draw_cursor
  179.         jmp     waitevent
  180. .right:
  181.         mov     eax, [cmdline_pos]
  182.         cmp     eax, [cmdline_len]
  183.         jae     waitevent
  184.         call    hide_cursor
  185.         inc     [cmdline_pos]
  186.         call    draw_cursor
  187.         jmp     waitevent
  188. .home:
  189.         call    hide_cursor
  190.         and     [cmdline_pos], 0
  191.         call    draw_cursor
  192.         jmp     waitevent
  193. .end:
  194.         call    hide_cursor
  195.         mov     eax, [cmdline_len]
  196.         mov     [cmdline_pos], eax
  197.         call    draw_cursor
  198. .up:
  199. .down:
  200.         jmp     waitevent
  201. .enter:
  202.         mov     ecx, [cmdline_len]
  203.         test    ecx, ecx
  204.         jz      waitevent
  205.         mov     esi, cmdline
  206.         mov     byte [esi+ecx], 0
  207.         and     [cmdline_pos], 0
  208.         push    esi
  209.         call    clear_cmdline_end
  210.         call    draw_cursor
  211.         pop     esi
  212.         and     [cmdline_len], 0
  213. ; skip leading spaces
  214.         call    skip_spaces
  215.         cmp     al, 0
  216.         jz      waitevent
  217. ; now esi points to command
  218.         push    esi
  219.         mov     esi, prompt
  220.         call    put_message_nodraw
  221.         pop     esi
  222.         push    esi
  223.         call    put_message_nodraw
  224. z1:     mov     esi, newline
  225.         call    put_message
  226.         pop     esi
  227.         push    esi
  228.         call    get_arg
  229.         mov     [curarg], esi
  230.         pop     edi
  231.         mov     esi, commands
  232.         call    find_cmd
  233.         mov     eax, aUnknownCommand
  234.         jc      .x11
  235. ; check command requirements
  236. ; flags field:
  237. ; &1: command may be called without parameters
  238. ; &2: command may be called with parameters
  239. ; &4: command may be called without loaded program
  240. ; &8: command may be called with loaded program
  241.         mov     eax, [esi+8]
  242.         mov     ecx, [curarg]
  243.         cmp     byte [ecx], 0
  244.         jz      .noargs
  245.         test    byte [esi+16], 2
  246.         jz      .x11
  247.         jmp     @f
  248. .noargs:
  249.         test    byte [esi+16], 1
  250.         jz      .x11
  251. @@:
  252.         cmp     [debuggee_pid], 0
  253.         jz      .nodebuggee
  254.         mov     eax, aAlreadyLoaded
  255.         test    byte [esi+16], 8
  256.         jz      .x11
  257.         jmp     .x9
  258. .nodebuggee:
  259.         mov     eax, need_debuggee
  260.         test    byte [esi+16], 4
  261.         jnz     .x9
  262. .x11:
  263.         xchg    esi, eax
  264.         call    put_message
  265. .x10:
  266.         jmp     waitevent
  267. .x9:
  268.         call    dword [esi+4]
  269.         jmp     .x10
  270.  
  271. find_cmd:
  272. ; all commands are case-insensitive
  273.         push    edi
  274. .x4:
  275.         mov     al, [edi]
  276.         cmp     al, 0
  277.         jz      .x5
  278.         cmp     al, 'A'
  279.         jb      @f
  280.         cmp     al, 'Z'
  281.         ja      @f
  282.         or      al, 20h
  283. @@:
  284.         stosb
  285.         jmp     .x4
  286. .x5:
  287. ; find command
  288.         pop     edi
  289. .x6:
  290.         cmp     dword [esi], 0
  291.         jz      .x7
  292.         push    esi
  293.         mov     esi, [esi]
  294.         lodsb
  295.         movzx   ecx, al
  296.         push    edi
  297.         repz    cmpsb
  298.         pop     edi
  299.         pop     esi
  300.         jz      .x8
  301.         add     esi, 17
  302.         jmp     .x6
  303. .x7:
  304.         stc
  305. .x8:
  306.         ret
  307.  
  308. get_arg:
  309.         lodsb
  310.         cmp     al, ' '
  311.         ja      get_arg
  312.         mov     byte [esi-1], 0
  313.         cmp     al, 0
  314.         jnz     skip_spaces
  315.         dec     esi
  316. skip_spaces:
  317.         lodsb
  318.         cmp     al, 0
  319.         jz      @f
  320.         cmp     al, ' '
  321.         jbe     skip_spaces
  322. @@:     dec     esi
  323.         ret
  324.  
  325. clear_cmdline_end:
  326.         mov     ebx, [cmdline_pos]
  327.         mov     ecx, [cmdline_len]
  328.         sub     ecx, ebx
  329.         push    13
  330.         pop     eax
  331.         imul    ebx, 6
  332.         imul    ecx, 6
  333.         inc     ecx
  334.         add     ebx, cmdline_x_pos
  335.         shl     ebx, 16
  336.         or      ebx, ecx
  337.         mov     ecx, cmdline_y_pos*10000h + cmdline_y_size
  338.         mov     edx, 0xFFFFFF
  339.         mcall
  340.         ret
  341.  
  342. draw_cmdline:
  343.         xor     ebx, ebx
  344.         jmp     @f
  345. draw_cmdline_end:
  346.         mov     ebx, [cmdline_pos]
  347. @@:
  348.         mov     esi, [cmdline_len]
  349.         sub     esi, ebx
  350.         push    4
  351.         pop     eax
  352.         xor     ecx, ecx
  353.         lea     edx, [cmdline+ebx]
  354.         imul    ebx, 6
  355.         add     ebx, cmdline_x_pos
  356.         shl     ebx, 16
  357.         or      ebx, cmdline_y_pos+1
  358.         mcall
  359.         ret
  360.  
  361. put_message_nodraw:
  362. ; in: esi->ASCIZ message
  363.         mov     edx, [messages_pos]
  364. .m:
  365.         lea     edi, [messages+edx]
  366. .l:
  367.         lodsb
  368.         cmp     al, 0
  369.         jz      .done
  370.         call    test_scroll
  371.         cmp     al, 10
  372.         jz      .newline
  373.         cmp     al, '%'
  374.         jnz     @f
  375.         cmp     dword [esp], z1
  376.         jnz     .format
  377. @@:
  378.         stosb
  379.         inc     edx
  380.         jmp     .l
  381. .newline:
  382.         push    edx
  383.         mov     ecx, messages_width
  384.         xor     eax, eax
  385.         xchg    eax, edx
  386.         div     ecx
  387.         xchg    eax, edx
  388.         pop     edx
  389.         test    eax, eax
  390.         jz      .m
  391.         sub     edx, eax
  392.         add     edx, ecx
  393.         jmp     .m
  394. .done:
  395.         mov     [messages_pos], edx
  396.         ret
  397. .format:
  398. ; at moment all format specs must be %<digit>X
  399.         lodsb   ; get <digit>
  400.         sub     al, '0'
  401.         movzx   ecx, al
  402.         lodsb
  403.         pop     eax
  404.         pop     ebp
  405.         push    eax
  406. ; write number in ebp with ecx digits
  407.         dec     ecx
  408.         shl     ecx, 2
  409. .writenibble:
  410.         push    ecx
  411.         call    test_scroll
  412.         pop     ecx
  413.         mov     eax, ebp
  414.         shr     eax, cl
  415.         and     al, 0xF
  416.         cmp     al, 10
  417.         sbb     al, 69h
  418.         das
  419.         stosb
  420.         inc     edx
  421.         sub     ecx, 4
  422.         jns     .writenibble
  423.         jmp     .l
  424.  
  425. test_scroll:
  426.         cmp     edx, messages_width*messages_height
  427.         jnz     .ret
  428.         push    esi
  429.         mov     edi, messages
  430.         lea     esi, [edi+messages_width]
  431.         mov     ecx, (messages_height-1)*messages_width/4
  432.         rep     movsd
  433.         push    eax
  434.         mov     al, ' '
  435.         push    edi
  436.         push    messages_width
  437.         pop     ecx
  438.         sub     edx, ecx
  439.         rep     stosb
  440.         pop     edi
  441.         pop     eax
  442.         pop     esi
  443. .ret:   ret
  444.  
  445. put_message:
  446.         call    put_message_nodraw
  447.  
  448. draw_messages:
  449.         push    13
  450.         pop     eax
  451.         mov     edx, 0xFFFFFF
  452.         mov     ebx, messages_x_pos*10000h+messages_x_size
  453.         mov     ecx, messages_y_pos*10000h+messages_y_size
  454.         mcall
  455.         mov     edx, messages
  456.         push    messages_width
  457.         pop     esi
  458.         xor     ecx, ecx
  459.         mov     al, 4
  460.         mov     ebx, messages_x_pos*10000h+messages_y_pos
  461. @@:
  462.         mcall
  463.         add     edx, esi
  464.         add     ebx, 10
  465.         cmp     edx, messages+messages_width*messages_height
  466.         jb      @b
  467.         ret
  468.  
  469. draw_cursor:
  470.         push    38
  471.         pop     eax
  472.         mov     ecx, cmdline_y_pos*10001h+cmdline_y_size-1
  473.         mov     ebx, [cmdline_pos]
  474.         imul    ebx, 6
  475.         add     ebx, cmdline_x_pos
  476.         mov     edx, ebx
  477.         shl     ebx, 16
  478.         or      ebx, edx
  479.         xor     edx, edx
  480.         mcall
  481.         ret
  482. hide_cursor:
  483.         mov     ebx, [cmdline_pos]
  484.         push    13
  485.         pop     eax
  486.         imul    ebx, 6
  487.         add     ebx, cmdline_x_pos
  488.         shl     ebx, 16
  489.         inc     ebx
  490.         mov     ecx, cmdline_y_pos*10000h + cmdline_y_size
  491.         mov     edx, 0xFFFFFF
  492.         mcall
  493.         mov     ebx, [cmdline_pos]
  494.         cmp     ebx, [cmdline_len]
  495.         jae     .ret
  496.         mov     al, 4
  497.         xor     ecx, ecx
  498.         lea     edx, [cmdline+ebx]
  499.         imul    ebx, 6
  500.         add     ebx, cmdline_x_pos
  501.         shl     ebx, 16
  502.         or      ebx, cmdline_y_pos+1
  503.         push    1
  504.         pop     esi
  505.         mcall
  506. .ret:
  507.         ret
  508.  
  509. redraw_title:
  510.         push    13
  511.         pop     eax
  512.         mov     edx, 0xFFFFFF
  513.         mov     ebx, title_x_pos*10000h + data_x_pos+data_x_size-title_x_pos
  514.         mov     ecx, title_y_pos*10000h + title_y_size
  515.         mcall
  516. draw_title:
  517.         mov     al, 38
  518.         mov     ebx, (data_x_pos-2)*10000h + title_x_pos-5
  519.         mov     ecx, (title_y_pos+5)*10001h
  520.         xor     edx, edx
  521.         mcall
  522.         push    NoPrgLoaded_len
  523.         pop     esi
  524.         cmp     [debuggee_pid], 0
  525.         jz      @f
  526.         mov     esi, [prgname_len]
  527. @@:     imul    ebx, esi, 6
  528.         add     ebx, title_x_pos+4
  529.         shl     ebx, 16
  530.         mov     bx, data_x_pos+data_x_size-10-5-6*7
  531.         cmp     [bSuspended], 0
  532.         jz      @f
  533.         add     ebx, 6
  534. @@:
  535.         mcall
  536.         mov     ebx, (data_x_pos+data_x_size-10+4)*0x10000 + data_x_pos+data_x_size+2
  537.         mcall
  538.         mov     al, 4
  539.         mov     ebx, title_x_pos*10000h+title_y_pos
  540.         xor     ecx, ecx
  541.         mov     edx, NoPrgLoaded_str
  542.         cmp     [debuggee_pid], 0
  543.         jz      @f
  544.         mov     edx, [prgname_ptr]
  545. @@:
  546.         mcall
  547.         cmp     [debuggee_pid], 0
  548.         jz      .nodebuggee
  549.         mov     ebx, (data_x_pos+data_x_size-10-6*7)*10000h + title_y_pos
  550.         mov     edx, aRunning
  551.         push    7
  552.         pop     esi
  553.         cmp     [bSuspended], 0
  554.         jz      @f
  555.         add     ebx, 6*10000h
  556.         mov     edx, aPaused
  557.         dec     esi
  558. @@:
  559.         mcall
  560.         ret
  561. .nodebuggee:
  562.         mov     al, 38
  563.         mov     ebx, (data_x_pos+data_x_size-10-6*7-5)*0x10000 + data_x_pos+data_x_size+2
  564.         mov     ecx, (title_y_pos+5)*10001h
  565.         xor     edx, edx
  566.         jmp     @b
  567.  
  568. draw_register:
  569. ; in: esi->value, edx->string, ecx=string len, ebx=coord
  570.         push    edx
  571.         push    ecx
  572.         push    esi
  573.         mov     eax, esi
  574.         mov     esi, ecx
  575. ; color
  576.         mov     ecx, 808080h
  577.         cmp     [debuggee_pid], 0
  578.         jz      .cd
  579.         cmp     [bSuspended], 0
  580.         jz      .cd
  581.         xor     ecx, ecx
  582.         mov     edi, [eax]
  583.         cmp     dword [eax+oldcontext-context], edi
  584.         jz      .cd
  585.         mov     ecx, 0x00AA00
  586. .cd:
  587.         push    4
  588.         pop     eax
  589.         mcall
  590.         imul    esi, 60000h
  591.         lea     edx, [ebx+esi]
  592.         mov     al, 47
  593.         mov     ebx, 80101h
  594.         mov     esi, ecx
  595.         pop     ecx
  596.         mcall
  597.         lea     ebx, [edx+60000h*18]
  598.         mov     esi, ecx
  599.         pop     ecx
  600.         pop     edx
  601.         add     edx, ecx
  602.         ret
  603. draw_flag:
  604.         movzx   edi, byte [edx+7]
  605.         bt      [_eflags], edi
  606.         jc      .on
  607.         or      byte [edx], 20h
  608.         jmp     .onoff
  609. .on:
  610.         and     byte [edx], not 20h
  611. .onoff:
  612.         mov     ecx, 808080h
  613.         cmp     [debuggee_pid], 0
  614.         jz      .doit
  615.         cmp     [bSuspended], 0
  616.         jz      .doit
  617.         xor     ecx, ecx
  618.         bt      [_eflags], edi
  619.         lahf
  620.         bt      dword [_eflags + oldcontext - context], edi
  621.         rcl     ah, 1
  622.         test    ah, 3
  623.         jp      .doit
  624.         mov     ecx, 0x00AA00
  625. .doit:
  626.         mov     ah, 0
  627.         mcall
  628.         ret
  629.  
  630. redraw_registers:
  631.         push    13
  632.         pop     eax
  633.         mov     edx, 0xFFFFFF
  634.         mov     ebx, data_x_pos*10000h + data_x_size
  635.         mov     ecx, registers_y_pos*10000h + registers_y_size
  636.         mcall
  637. draw_registers:
  638.         mov     esi, _eax
  639.         push    4
  640.         pop     ecx
  641.         mov     edx, regs_strs
  642.         mov     ebx, registers_x_pos*10000h+registers_y_pos
  643.         call    draw_register
  644.         add     esi, _ebx-_eax
  645.         call    draw_register
  646.         add     esi, _ecx-_ebx
  647.         call    draw_register
  648.         add     esi, _edx-_ecx
  649.         call    draw_register
  650.         mov     ebx, registers_x_pos*10000h+registers_y_pos+10
  651.         add     esi, _esi-_edx
  652.         call    draw_register
  653.         add     esi, _edi-_esi
  654.         call    draw_register
  655.         add     esi, _ebp-_edi
  656.         call    draw_register
  657.         add     esi, _esp-_ebp
  658.         call    draw_register
  659.         mov     ebx, registers_x_pos*10000h+registers_y_pos+20
  660.         add     esi, _eip-_esp
  661.         call    draw_register
  662.         mov     cl, 7
  663.         add     esi, _eflags-_eip
  664.         call    draw_register
  665.         mov     al, 4
  666.         mov     ecx, 808080h
  667.         cmp     [debuggee_pid], 0
  668.         jz      @f
  669.         cmp     [bSuspended], 0
  670.         jz      @f
  671.         xor     ecx, ecx
  672. @@:
  673.         mov     edx, aColon
  674.         xor     esi, esi
  675.         inc     esi
  676.         mov     ebx, (registers_x_pos+37*6)*10000h + registers_y_pos+20
  677.         mcall
  678.         mov     edx, flags
  679. @@:
  680.         add     ebx, 2*6*10000h
  681.         call    draw_flag
  682.         inc     edx
  683.         cmp     dl, flags_bits and 0xFF
  684.         jnz     @b
  685.         ret
  686.  
  687. redraw_dump:
  688.         push    13
  689.         pop     eax
  690.         mov     edx, 0xFFFFFF
  691.         mov     ebx, data_x_pos*10000h + data_x_size
  692.         mov     ecx, dump_y_pos*10000h + dump_y_size
  693.         mcall
  694. draw_dump:
  695. ; addresses
  696.         mov     al, 47
  697.         mov     ebx, 80100h
  698.         mov     edx, data_x_pos*10000h + dump_y_pos
  699.         mov     ecx, [dumppos]
  700.         mov     esi, 808080h
  701.         cmp     [debuggee_pid], 0
  702.         jz      @f
  703.         cmp     [bSuspended], 0
  704.         jz      @f
  705.         xor     esi, esi
  706. @@:
  707.         mcall
  708.         add     ecx, 10h
  709.         add     edx, 10
  710.         cmp     dl, dump_y_pos + dump_y_size
  711.         jb      @b
  712. ; hex dump of data
  713.         mov     ebx, 20101h
  714.         mov     ecx, dumpdata
  715.         push    ecx
  716.         xor     edi, edi
  717.         mov     edx, (data_x_pos+12*6)*10000h + dump_y_pos
  718.         cmp     [dumpread], edi
  719.         jz      .hexdumpdone1
  720. .hexdumploop1:
  721.         mcall
  722.         add     edx, 3*6*10000h
  723.         inc     ecx
  724.         inc     edi
  725.         test    edi, 15
  726.         jz      .16
  727.         test    edi, 7
  728.         jnz     @f
  729.         add     edx, 2*6*10000h - 10 + 6*(3*10h+2)*10000h
  730. .16:
  731.         add     edx, 10 - 6*(3*10h+2)*10000h
  732. @@:
  733.         cmp     edi, [dumpread]
  734.         jb      .hexdumploop1
  735. .hexdumpdone1:
  736.         mov     al, 4
  737.         mov     ecx, esi
  738.         mov     ebx, edx
  739.         push    2
  740.         pop     esi
  741.         mov     edx, aQuests
  742. .hexdumploop2:
  743.         cmp     edi, dump_height*10h
  744.         jae     .hexdumpdone2
  745.         mcall
  746.         add     ebx, 3*6*10000h
  747.         inc     edi
  748.         test    edi, 15
  749.         jz      .16x
  750.         test    edi, 7
  751.         jnz     .hexdumploop2
  752.         add     ebx, 2*6*10000h - 10 + 6*(3*10h+2)*10000h
  753. .16x:
  754.         add     ebx, 10 - 6*(3*10h+2)*10000h
  755.         jmp     .hexdumploop2
  756. .hexdumpdone2:
  757.         dec     esi
  758. ; colon, minus signs
  759.         mov     ebx, (data_x_pos+8*6)*10000h + dump_y_pos
  760.         mov     edx, aColon
  761. @@:
  762.         mcall
  763.         add     ebx, 10
  764.         cmp     bl, dump_y_pos+dump_height*10
  765.         jb      @b
  766.         mov     ebx, (data_x_pos+(12+3*8)*6)*10000h + dump_y_pos
  767.         mov     edx, aMinus
  768. @@:
  769.         mcall
  770.         add     ebx, 10
  771.         cmp     bl, dump_y_pos+dump_height*10
  772.         jb      @b
  773. ; ASCII data
  774.         mov     ebx, (data_x_pos+(12+3*10h+2+2)*6)*10000h + dump_y_pos
  775.         mov     edi, dump_height*10h
  776.         pop     edx
  777. .asciiloop:
  778.         push    edx
  779.         cmp     byte [edx], 20h
  780.         jae     @f
  781.         mov     edx, aPoint
  782. @@:
  783.         mcall
  784.         pop     edx
  785.         inc     edx
  786.         add     ebx, 6*10000h
  787.         dec     edi
  788.         jz      .asciidone
  789.         test    edi, 15
  790.         jnz     .asciiloop
  791.         add     ebx, 10 - 6*10h*10000h
  792.         jmp     .asciiloop
  793. .asciidone:
  794.         ret
  795.  
  796. redraw_disasm:
  797.         push    13
  798.         pop     eax
  799.         mov     edx, 0xFFFFFF
  800.         mov     ebx, data_x_pos*10000h + data_x_size
  801.         mov     ecx, (disasm_y_pos-1)*10000h + (disasm_y_size+1)
  802.         mcall
  803. draw_disasm:
  804.         mov     eax, [disasm_start_pos]
  805.         mov     [disasm_cur_pos], eax
  806.         and     [disasm_cur_str], 0
  807. .loop:
  808.         mov     eax, [disasm_cur_pos]
  809.         call    find_symbol
  810.         jc      .nosymb
  811.         mov     ebx, [disasm_cur_str]
  812.         imul    ebx, 10
  813.         add     ebx, (data_x_pos+6*2)*10000h + disasm_y_pos
  814.         mov     edx, esi
  815. @@:     lodsb
  816.         test    al, al
  817.         jnz     @b
  818.         mov     byte [esi-1], ':'
  819.         sub     esi, edx
  820.         xor     ecx, ecx
  821.         push    4
  822.         pop     eax
  823.         mcall
  824.         mov     byte [esi+edx-1], 0
  825.         inc     [disasm_cur_str]
  826.         cmp     [disasm_cur_str], disasm_height
  827.         jae     .loopend
  828. .nosymb:
  829.         push    [disasm_cur_pos]
  830.         call    disasm_instr
  831.         pop     ebp
  832.         jc      .loopend
  833.         xor     esi, esi        ; default color: black
  834.         mov     ebx, data_x_pos*10000h + data_x_size
  835.         mov     ecx, [disasm_cur_str]
  836.         imul    ecx, 10*10000h
  837.         add     ecx, (disasm_y_pos-1)*10000h + 10
  838.         mov     eax, ebp
  839.         pushad
  840.         call    find_enabled_breakpoint
  841.         popad
  842.         jnz     .nored
  843.         push    13
  844.         pop     eax
  845.         mov     edx, 0xFF0000
  846.         mcall
  847. .nored:
  848.         mov     eax, [_eip]
  849.         cmp     eax, ebp
  850.         jnz     .noblue
  851.         push    13
  852.         pop     eax
  853.         mov     edx, 0x0000FF
  854.         mcall
  855.         mov     esi, 0xFFFFFF   ; on blue bgr, use white color
  856. .noblue:
  857.         push    47
  858.         pop     eax
  859.         mov     ebx, 80100h
  860.         mov     edx, [disasm_cur_str]
  861.         imul    edx, 10
  862.         add     edx, data_x_pos*10000h + disasm_y_pos
  863.         mov     ecx, ebp
  864.         mcall
  865.         mov     al, 4
  866.         lea     ebx, [edx+8*6*10000h]
  867.         mov     ecx, esi
  868.         push    1
  869.         pop     esi
  870.         mov     edx, aColon
  871.         mcall
  872.         push    9
  873.         pop     edi
  874.         lea     edx, [ebx+2*6*10000h]
  875.         mov     esi, ecx
  876.         mov     al, 47
  877.         mov     ebx, 20101h
  878.         mov     ecx, ebp
  879.         sub     ecx, [disasm_start_pos]
  880.         add     ecx, disasm_buffer
  881. .drawhex:
  882.         mcall
  883.         add     edx, 6*3*10000h
  884.         inc     ecx
  885.         inc     ebp
  886.         cmp     ebp, [disasm_cur_pos]
  887.         jae     .hexdone
  888.         dec     edi
  889.         jnz     .drawhex
  890.         push    esi
  891.         mov     esi, [disasm_cur_pos]
  892.         dec     esi
  893.         cmp     esi, ebp
  894.         pop     esi
  895.         jbe     .drawhex
  896.         mov     al, 4
  897.         lea     ebx, [edx-6*10000h]
  898.         mov     ecx, esi
  899.         push    3
  900.         pop     esi
  901.         mov     edx, aDots
  902.         mcall
  903.         mov     esi, ecx
  904. .hexdone:
  905.         xor     eax, eax
  906.         mov     edi, disasm_string
  907.         mov     edx, edi
  908.         or      ecx, -1
  909.         repnz   scasb
  910.         not     ecx
  911.         dec     ecx
  912.         xchg    ecx, esi
  913.         mov     ebx, [disasm_cur_str]
  914.         imul    ebx, 10
  915.         add     ebx, (data_x_pos+6*40)*10000h+disasm_y_pos
  916.         mov     al, 4
  917.         mcall
  918.         inc     [disasm_cur_str]
  919.         cmp     [disasm_cur_str], disasm_height
  920.         jb      .loop
  921. .loopend:
  922.         ret
  923.  
  924. update_disasm_eip:
  925. ; test if instruction at eip is showed
  926.         mov     ecx, disasm_height
  927.         mov     eax, [disasm_start_pos]
  928.         mov     [disasm_cur_pos], eax
  929. .l:
  930.         mov     eax, [disasm_cur_pos]
  931.         call    find_symbol
  932.         jc      @f
  933.         dec     ecx
  934.         jz      .m
  935. @@:
  936.         cmp     [_eip], eax
  937.         jz      redraw_disasm
  938.         push    ecx
  939.         call    disasm_instr
  940.         pop     ecx
  941.         jc      .m
  942.         loop    .l
  943. .m:
  944. update_disasm_eip_force:
  945.         mov     eax, [_eip]
  946.         mov     [disasm_start_pos], eax
  947. update_disasm:
  948.         cmp     [debuggee_pid], 0
  949.         jz      .no
  950.         push    69
  951.         pop     eax
  952.         push    6
  953.         pop     ebx
  954.         mov     ecx, [debuggee_pid]
  955.         mov     edi, disasm_buffer
  956.         mov     edx, 256
  957.         mov     esi, [disasm_start_pos]
  958.         mcall
  959.         cmp     eax, -1
  960.         jnz     @f
  961.         mov     esi, read_mem_err
  962.         call    put_message
  963. .no:
  964.         xor     eax, eax
  965. @@:
  966.         mov     [disasm_buf_size], eax
  967.         call    restore_from_breaks
  968.         jmp     redraw_disasm
  969.  
  970. draw_window:
  971. ; start redraw
  972.         push    12
  973.         pop     eax
  974.         push    1
  975.         pop     ebx
  976.         mcall
  977. ; define window
  978.         xor     eax, eax
  979.         mov     ebx, wnd_x_size
  980.         mov     ecx, wnd_y_size
  981.         mov     edx, 14FFFFFFh
  982.         mov     edi, caption_str
  983.         mcall
  984. ; messages frame
  985.         mov     al, 38
  986.         mov     ebx, (messages_x_pos-2)*10000h + (messages_x_pos+messages_x_size+2)
  987.         push    ebx
  988.         mov     ecx, (messages_y_pos-2)*10001h
  989.         xor     edx, edx
  990.         mcall
  991.         mov     ecx, (messages_y_pos+messages_y_size+2)*10001h
  992.         mcall
  993.         mov     ebx, (messages_x_pos-2)*10001h
  994.         push    ebx
  995.         mov     ecx, (messages_y_pos-2)*10000h + (messages_y_pos+messages_y_size+2)
  996.         mcall
  997.         mov     ebx, (messages_x_pos+messages_x_size+2)*10001h
  998.         push    ebx
  999.         mcall
  1000. ; command line frame
  1001.         mov     ecx, (cmdline_y_pos-2)*10000h + (cmdline_y_pos+cmdline_y_size+2)
  1002.         pop     ebx
  1003.         mcall
  1004.         pop     ebx
  1005.         mcall
  1006.         pop     ebx
  1007.         mov     ecx, (cmdline_y_pos+cmdline_y_size+2)*10001h
  1008.         mcall
  1009.         mov     ecx, (cmdline_y_pos-2)*10001h
  1010.         mcall
  1011. ; messages
  1012.         call    draw_messages
  1013. ; command line & cursor
  1014.         call    draw_cmdline
  1015.         call    draw_cursor
  1016. ; title & registers & dump & disasm
  1017.         mov     al, 38
  1018.         mov     ebx, (data_x_pos-2)*10001h
  1019.         mov     ecx, (title_y_pos+5)*10000h + (messages_y_pos-2)
  1020.         mcall
  1021.         mov     ebx, (data_x_pos+data_x_size+2)*10001h
  1022.         mcall
  1023.         mov     ebx, (data_x_pos-2)*10000h + (data_x_pos+data_x_size+2)
  1024.         mov     ecx, (dump_y_pos-3)*10001h
  1025.         mcall
  1026.         mov     ecx, (disasm_y_pos-4)*10001h
  1027.         mcall
  1028.         call    draw_title
  1029.         call    draw_registers
  1030.         call    draw_dump
  1031.         call    draw_disasm
  1032. ; end redraw
  1033.         push    12
  1034.         pop     eax
  1035.         push    2
  1036.         pop     ebx
  1037.         mcall
  1038.         ret
  1039.  
  1040. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1041. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; DEBUGGING ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1042. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1043.  
  1044. OnHelp:
  1045.         mov     esi, help_msg
  1046.         mov     edi, [curarg]
  1047.         cmp     byte [edi], 0
  1048.         jz      .x
  1049.         mov     esi, help_groups
  1050.         call    find_cmd
  1051.         jc      .nocmd
  1052.         mov     esi, [esi+12]
  1053. .x:
  1054.         jmp     put_message
  1055. .nocmd:
  1056.         mov     esi, aUnknownCommand
  1057.         jmp     .x
  1058.  
  1059. OnQuit:
  1060.         push    -1
  1061.         pop     eax
  1062.         mcall
  1063.  
  1064. get_new_context:
  1065.         mov     esi, context
  1066.         mov     edi, oldcontext
  1067.         mov     ecx, 10
  1068.         rep     movsd
  1069. get_context:
  1070.         push    1
  1071.         pop     ebx
  1072.         push    69
  1073.         pop     eax
  1074.         mov     ecx, [debuggee_pid]
  1075.         mov     esi, context
  1076.         push    28h
  1077.         pop     edx
  1078.         mcall
  1079.         ret
  1080. set_context:
  1081.         push    2
  1082.         pop     ebx
  1083.         push    69
  1084.         pop     eax
  1085.         mov     ecx, [debuggee_pid]
  1086.         mov     esi, context
  1087.         push    28h
  1088.         pop     edx
  1089.         mcall
  1090.         ret
  1091.  
  1092. get_dump:
  1093.         mov     edi, dumpdata
  1094.         mov     esi, [edi-4]
  1095.         mov     edx, dump_height*10h
  1096.         mov     ecx, edx
  1097.         xor     eax, eax
  1098.         push    edi
  1099.         rep     stosb
  1100.         pop     edi
  1101.         mov     ecx, [debuggee_pid]
  1102.         mov     al, 69
  1103.         push    6
  1104.         pop     ebx
  1105.         mcall
  1106.         cmp     eax, -1
  1107.         jnz     @f
  1108.         mov     esi, read_mem_err
  1109.         call    put_message
  1110.         xor     eax, eax
  1111. @@:
  1112.         mov     [edi-8], eax
  1113. ;       call    restore_from_breaks
  1114. ;       ret
  1115. restore_from_breaks:
  1116. ; in: edi=buffer,eax=size,esi=address
  1117.         mov     ebx, breakpoints
  1118. @@:
  1119.         test    byte [ebx+4], 1
  1120.         jz      .cont           ; ignore invalid
  1121.         test    byte [ebx+4], 2 or 8
  1122.         jnz     .cont           ; ignore disabled and memory breaks
  1123.         mov     ecx, [ebx]
  1124.         sub     ecx, esi
  1125.         cmp     ecx, eax
  1126.         jae     .cont
  1127.         mov     dl, [ebx+5]
  1128.         mov     [edi+ecx], dl
  1129. .cont:
  1130.         add     ebx, 6
  1131.         cmp     ebx, breakpoints+breakpoints_n*6
  1132.         jb      @b
  1133.         ret
  1134.  
  1135. OnLoad:
  1136.         mov     esi, [curarg]
  1137. OnLoadInit:
  1138.         mov     edi, loadname
  1139.         or      [prgname_len], -1
  1140.         mov     [prgname_ptr], edi
  1141. .copyname:
  1142.         lodsb
  1143.         stosb
  1144.         inc     [prgname_len]
  1145.         cmp     al, '/'
  1146.         jnz     @f
  1147.         or      [prgname_len], -1
  1148.         mov     [prgname_ptr], edi
  1149. @@:
  1150.         cmp     al, ' '
  1151.         ja      .copyname
  1152.         mov     byte [edi-1], 0
  1153.         and     [load_params], 0
  1154.         dec     esi
  1155.         call    skip_spaces
  1156.         cmp     al, 0
  1157.         jz      @f
  1158.         mov     [load_params], esi
  1159. @@:
  1160.         and     [dumppos], 0
  1161.         mov     ecx, [symbols]
  1162.         jecxz   do_reload
  1163.         mcall   68, 13
  1164.         and     [symbols], 0
  1165.         and     [num_symbols], 0
  1166. do_reload:
  1167.         push    18
  1168.         pop     eax
  1169.         push    7
  1170.         pop     ebx
  1171.         mcall
  1172.         mov     [dbgwnd], eax
  1173.         xchg    ecx, eax
  1174.         push    70
  1175.         pop     eax
  1176.         mov     ebx, fn70_load_block
  1177.         mcall
  1178.         test    eax, eax
  1179.         jns     .load_ok
  1180. .load_err:
  1181.         push    eax
  1182.         mov     esi, load_err_msg
  1183.         call    put_message
  1184.         pop     eax
  1185.         not     eax
  1186.         cmp     eax, 0x20
  1187.         jae     .unk_err
  1188.         mov     esi, [load_err_msgs+eax*4]
  1189.         test    esi, esi
  1190.         jnz     put_message
  1191. .unk_err:
  1192.         mov     esi, unk_err_msg
  1193.         inc     eax
  1194.         push    eax
  1195.         call    put_message_nodraw
  1196.         jmp     draw_messages
  1197. .load_ok:
  1198.         mov     [debuggee_pid], eax
  1199.         mov     [bSuspended], 1
  1200.         push    ecx
  1201.         call    get_context
  1202.         mov     edi, oldcontext
  1203.         mov     ecx, 10
  1204.         rep     movsd
  1205. ; activate debugger window
  1206.         pop     ecx
  1207.         mov     bl, 3
  1208.         push    18
  1209.         pop     eax
  1210.         mcall
  1211.         call    redraw_title
  1212.         call    redraw_registers
  1213.         call    get_dump
  1214.         call    redraw_dump
  1215.         call    update_disasm_eip_force
  1216.         mov     esi, load_succ_msg
  1217.         push    [debuggee_pid]
  1218.         call    put_message_nodraw
  1219.         call    draw_messages
  1220. ; try to load symbols
  1221.         mov     esi, loadname
  1222.         mov     edi, symbolsfile
  1223.         push    edi
  1224. @@:
  1225.         lodsb
  1226.         stosb
  1227.         test    al, al
  1228.         jnz     @b
  1229.         lea     ecx, [edi-1]
  1230. @@:
  1231.         dec     edi
  1232.         cmp     edi, symbolsfile
  1233.         jb      @f
  1234.         cmp     byte [edi], '/'
  1235.         jz      @f
  1236.         cmp     byte [edi], '.'
  1237.         jnz     @b
  1238.         mov     ecx, edi
  1239. @@:
  1240.         mov     dword [ecx], '.dbg'
  1241.         mov     byte [ecx+4], 0
  1242.         pop     esi
  1243.         mov     ebp, esi
  1244.         call    OnLoadSymbols.silent
  1245. ; now test for packed progs
  1246.         cmp     [disasm_buf_size], 100h
  1247.         jz      @f
  1248.         ret
  1249. @@:
  1250.         mov     esi, mxp_nrv_sig
  1251.         mov     ebp, disasm_buffer
  1252.         mov     edi, ebp
  1253.         push    3
  1254.         pop     ecx
  1255.         repz    cmpsb
  1256.         jnz     .not_mxp_nrv
  1257.         cmpsb
  1258.         mov     cl, mxp_nrv_sig_size-4
  1259.         repz    cmpsb
  1260.         mov     esi, mxp_nrv_name
  1261.         jz      .packed
  1262. .not_mxp_nrv:
  1263.         mov     esi, mxp_sig
  1264.         mov     edi, ebp
  1265.         mov     cl, mxp_sig_size
  1266.         repz    cmpsb
  1267.         mov     esi, mxp_name
  1268.         jz      .packed
  1269. .not_mxp:
  1270.         mov     esi, mxp_lzo_sig1
  1271.         mov     edi, ebp
  1272.         mov     cl, mxp_lzo_sig1_size
  1273.         repz    cmpsb
  1274.         mov     esi, mxp_lzo_name
  1275.         jz      .packed
  1276.         mov     esi, mxp_lzo_sig2
  1277.         mov     edi, ebp
  1278.         mov     cl, 8
  1279.         repz    cmpsb
  1280.         jnz     .not_mxp_lzo
  1281.         cmpsb
  1282.         mov     cl, mxp_lzo_sig2_size - 9
  1283.         repz    cmpsb
  1284.         mov     esi, mxp_lzo_name
  1285.         jz      .packed
  1286. .not_mxp_lzo:
  1287.         mov     esi, mtappack_name
  1288.         cmp     dword [ebp], 0xBF5E246A
  1289.         jnz     .not_mtappack
  1290.         cmp     dword [ebp+8], 0xEC4E8B57
  1291.         jnz     .not_mtappack1
  1292.         cmp     dword [ebp+12], 0x8D5EA4F3
  1293.         jnz     .not_mtappack1
  1294.         cmp     byte [ebp+12h], 0xE9
  1295.         jz      .packed
  1296. .not_mtappack1:
  1297.         cmp     word [ebp+8], 0xB957
  1298.         jnz     .not_mtappack
  1299.         cmp     dword [ebp+14], 0x575EA4F3
  1300.         jnz     .not_mtappack2
  1301.         cmp     byte [ebp+17h], 0xE9
  1302.         jz      .packed
  1303. .not_mtappack2:
  1304.         cmp     dword [ebp+14], 0x5F8DA4F3
  1305.         jnz     .not_mtappack3
  1306.         cmp     word [ebp+18], 0xE9FC
  1307.         jz      .packed
  1308. .not_mtappack3:
  1309.         cmp     word [ebp+14], 0xA4F3
  1310.         jnz     .not_mtappack
  1311.         cmp     byte [ebp+15h], 0xE9
  1312.         jz      .packed
  1313. .not_mtappack:
  1314.         ret
  1315. .packed:
  1316.         push    esi
  1317.         mov     esi, aPacked1
  1318.         call    put_message_nodraw
  1319.         pop     esi
  1320.         call    put_message_nodraw
  1321.         mov     esi, aPacked2
  1322.         call    put_message
  1323.         call    hide_cursor
  1324.         push    40
  1325.         pop     eax
  1326.         push    7
  1327.         pop     ebx
  1328.         mcall
  1329. .wait:
  1330.         push    10
  1331.         pop     eax
  1332.         mcall
  1333.         dec     eax
  1334.         jz      .redraw
  1335.         dec     eax
  1336.         jz      .key
  1337.         or      eax, -1
  1338.         mcall
  1339. .redraw:
  1340.         call    draw_window
  1341.         call    hide_cursor
  1342.         jmp     .wait
  1343. .key:
  1344.         mov     al, 2
  1345.         mcall
  1346.         cmp     ah, 'y'
  1347.         jz      .yes
  1348.         cmp     ah, 'Y'
  1349.         jz      .yes
  1350.         cmp     ah, 0xD
  1351.         jz      .yes
  1352.         cmp     ah, 'n'
  1353.         jz      .no
  1354.         cmp     ah, 'N'
  1355.         jnz     .wait
  1356. .no:
  1357.         push    40
  1358.         pop     eax
  1359.         mov     ebx, 0x107
  1360.         mcall
  1361.         call    draw_cursor
  1362.         mov     esi, aN_str
  1363.         jmp     put_message
  1364. .yes:
  1365.         push    40
  1366.         pop     eax
  1367.         mov     ebx, 0x107
  1368.         mcall
  1369.         call    draw_cursor
  1370.         mov     esi, aY_str
  1371.         call    put_message
  1372.         call    OnUnpack
  1373.         ret
  1374.  
  1375. mxp_nrv_sig:
  1376.         xor     eax, eax
  1377.         mov     ecx, 0x95       ; 0xA1 for programs with parameters
  1378.         mov     [eax], ecx
  1379.         add     ecx, [eax+24h]
  1380.         push    40h
  1381.         pop     esi
  1382.         mov     edi, [eax+20h]
  1383.         push    edi
  1384.         rep     movsb
  1385.         jmp     dword [esp]
  1386.         pop     esi
  1387.         add     esi, [eax]
  1388.         xor     edi, edi
  1389. mxp_nrv_sig_size = $ - mxp_nrv_sig
  1390.  
  1391. mxp_sig:
  1392.         mov     ecx, 1CBh
  1393.         push    46h
  1394.         pop     esi
  1395.         mov     edi, [20h]
  1396.         rep     movsb
  1397.         mov     ecx, [24h]
  1398.         rep     movsb
  1399.         jmp     dword [20h]
  1400.         mov     eax, [20h]
  1401.         add     eax, 1CBh
  1402.         push    eax
  1403.         push    dword [24h]
  1404.         push    0
  1405.         push    8
  1406.         call    $+0x25
  1407. mxp_sig_size = $ - mxp_sig
  1408.  
  1409. mxp_lzo_sig1:
  1410.         xor     eax, eax
  1411.         mov     ebp, 0FFh
  1412.         mov     ecx, 175h
  1413.         mov     [eax], ecx
  1414.         add     ecx, [eax+24h]
  1415.         push    45h
  1416.         pop     esi
  1417.         mov     edi, [eax+20h]
  1418.         push    edi
  1419.         rep     movsb
  1420.         jmp     dword [esp]
  1421.         pop     ebx
  1422.         add     ebx, [eax]
  1423.         xor     edi, edi
  1424.         cmp     byte [ebx], 11h
  1425.         jbe     $+0x1A
  1426. mxp_lzo_sig1_size = $ - mxp_lzo_sig1
  1427. mxp_lzo_sig2:
  1428.         xor     eax, eax
  1429.         mov     ebp, 0FFh
  1430.         mov     ecx, 188h       ; or 177h
  1431.         mov     [eax], ecx
  1432.         add     ecx, [eax+24h]
  1433.         push    44h
  1434.         pop     esi
  1435.         mov     edi, [eax+20h]
  1436.         rep     movsb
  1437.         jmp     dword [eax+20h]
  1438.         mov     ebx, [eax+20h]
  1439.         add     ebx, [eax]
  1440. mxp_lzo_sig2_size = $ - mxp_lzo_sig2
  1441.  
  1442. OnReload:
  1443.         cmp     [debuggee_pid], 0
  1444.         jnz     terminate_reload
  1445.         mov     esi, need_debuggee
  1446.         cmp     byte [loadname], 0
  1447.         jnz     do_reload
  1448.         jz      put_message
  1449. terminate_reload:
  1450.         mov     [bReload], 1
  1451. OnTerminate:
  1452.         mov     ecx, [debuggee_pid]
  1453.         push    8
  1454.         pop     ebx
  1455.         push    69
  1456.         pop     eax
  1457.         mcall
  1458.         ret
  1459.  
  1460. AfterSuspend:
  1461.         mov     [bSuspended], 1
  1462.         call    get_new_context
  1463.         call    get_dump
  1464.         call    redraw_title
  1465.         call    redraw_registers
  1466.         call    redraw_dump
  1467.         call    update_disasm_eip
  1468.         ret
  1469.  
  1470. OnSuspend:
  1471.         mov     ecx, [debuggee_pid]
  1472.         push    4
  1473.         pop     ebx
  1474.         push    69
  1475.         pop     eax
  1476.         mcall
  1477.         call    AfterSuspend
  1478.         mov     esi, aSuspended
  1479.         jmp     put_message
  1480. DoResume:
  1481.         mov     ecx, [debuggee_pid]
  1482.         push    5
  1483.         pop     ebx
  1484.         push    69
  1485.         pop     eax
  1486.         mcall
  1487.         mov     [bSuspended], 0
  1488.         ret
  1489. OnResume:
  1490.         mov     esi, [curarg]
  1491.         cmp     byte [esi], 0
  1492.         jz      GoOn
  1493.         call    calc_expression
  1494.         jc      .ret
  1495.         mov     eax, ebp
  1496.         push    eax
  1497.         call    find_enabled_breakpoint
  1498.         pop     eax
  1499.         jz      GoOn
  1500.         mov     bl, 5   ; valid enabled one-shot
  1501.         call    add_breakpoint
  1502.         jnc     GoOn
  1503.         mov     esi, aBreakpointLimitExceeded
  1504.         call    put_message
  1505. .ret:
  1506.         ret
  1507. GoOn:
  1508. ; test for enabled breakpoint at eip
  1509.         mov     eax, [_eip]
  1510.         call    find_enabled_breakpoint
  1511.         jnz     .nobreak
  1512. ; temporarily disable breakpoint, make step, enable breakpoint, continue
  1513.         inc     eax
  1514.         mov     [temp_break], eax
  1515.         mov     [bAfterGo], 1
  1516.         dec     eax
  1517.         call    disable_breakpoint
  1518.         call    get_context
  1519.         or      byte [_eflags+1], 1             ; set TF
  1520.         call    set_context
  1521.         and     byte [_eflags+1], not 1
  1522.         call    DoResume
  1523.         ret
  1524. .nobreak:
  1525.         call    DoResume
  1526.         call    redraw_title
  1527.         call    redraw_registers
  1528.         call    redraw_dump
  1529.         ret
  1530. OnDetach:
  1531.         mov     ecx, [debuggee_pid]
  1532.         push    3
  1533.         pop     ebx
  1534.         push    69
  1535.         pop     eax
  1536.         mcall
  1537.         and     [debuggee_pid], 0
  1538.         call    redraw_title
  1539.         call    redraw_registers
  1540.         call    redraw_dump
  1541.         call    free_symbols
  1542.         mov     esi, aContinued
  1543.         jmp     put_message
  1544.  
  1545. after_go_exception:
  1546.         push    eax
  1547.         mov     eax, [temp_break]
  1548.         dec     eax
  1549.         push    esi
  1550.         call    enable_breakpoint
  1551. ; in any case, clear TF and RF
  1552.         call    get_new_context
  1553.         and     [_eflags], not 10100h           ; clear TF,RF
  1554.         call    set_context
  1555.         xor     edx, edx
  1556.         mov     [temp_break], edx
  1557.         xchg    dl, [bAfterGo]
  1558.         pop     esi
  1559.         pop     eax
  1560.         cmp     dl, 2
  1561.         jnz     @f
  1562.         lodsd
  1563.         push    esi
  1564.         call    get_dump
  1565.         jmp     exception.done
  1566. @@:     test    eax, eax
  1567.         jz      .notint1
  1568. ; if exception is result of single step, simply ignore it and continue
  1569.         test    dword [esi], 0xF
  1570.         jnz     dbgmsgstart.5
  1571.         lodsd
  1572.         push    esi
  1573.         mov     esi, oldcontext
  1574.         mov     edi, context
  1575.         mov     ecx, 28h/4
  1576.         rep     movsd
  1577.         call    DoResume
  1578.         jmp     dbgmsgend
  1579. .notint1:
  1580. ; in other case, work as without temp_break
  1581.         lodsd
  1582.         push    esi
  1583.         push    eax
  1584.         jmp     exception.4
  1585. .notour:
  1586.  
  1587. debugmsg:
  1588.         neg     [dbgbufsize]
  1589.         mov     esi, dbgbuf
  1590. dbgmsgstart:
  1591.         lodsd
  1592. ;       push    eax esi
  1593. ;       push    dword [esi]
  1594. ;       mov     esi, dbgmsg_str
  1595. ;       call    put_message_nodraw
  1596. ;       pop     esi eax
  1597.         add     esi, 4
  1598.         dec     eax
  1599.         jz      exception
  1600.         dec     eax
  1601.         jz      terminated
  1602.         mov     [bSuspended], 1
  1603.         cmp     [bAfterGo], 0
  1604.         jnz     after_go_exception
  1605.         push    esi
  1606.         call    get_new_context
  1607.         and     [_eflags], not 10100h           ; clear TF,RF
  1608.         call    set_context
  1609.         pop     esi
  1610. .5:
  1611.         push    esi
  1612.         call    get_dump
  1613.         pop     esi
  1614.         lodsd
  1615.         xor     ecx, ecx
  1616. .6:
  1617.         bt      eax, ecx
  1618.         jnc     .7
  1619.         mov     ebx, [drx_break+ecx*4]
  1620.         test    ebx, ebx
  1621.         jz      .7
  1622.         pushad
  1623.         dec     ebx
  1624.         push    ebx
  1625.         mov     esi, aBreakStop
  1626.         call    put_message_nodraw
  1627.         popad
  1628. .7:
  1629.         inc     ecx
  1630.         cmp     cl, 4
  1631.         jb      .6
  1632.         push    esi
  1633.         jmp     exception.done_draw
  1634. terminated:
  1635.         push    esi
  1636.         mov     esi, terminated_msg
  1637.         call    put_message
  1638.         and     [debuggee_pid], 0
  1639.         and     [temp_break], 0
  1640.         mov     [bAfterGo], 0
  1641.         xor     eax, eax
  1642.         mov     ecx, breakpoints_n*6/4+4
  1643.         mov     edi, breakpoints
  1644.         rep     stosd
  1645.         cmp     [bReload], 1
  1646.         sbb     [bReload], -1
  1647.         jnz     exception.done
  1648.         call    free_symbols
  1649.         jmp     exception.done
  1650. exception:
  1651.         mov     [bSuspended], 1
  1652.         cmp     [bAfterGo], 0
  1653.         jnz     after_go_exception
  1654.         lodsd
  1655.         push    esi
  1656.         push    eax
  1657.         call    get_new_context
  1658.         and     [_eflags], not 10100h           ; clear TF,RF
  1659.         call    set_context
  1660. .4:
  1661.         call    get_dump
  1662.         pop     eax
  1663. ; int3 command generates exception 0D, #GP
  1664.         push    eax
  1665.         cmp     al, 0Dh
  1666.         jnz     .notdbg
  1667. ; check for 0xCC byte at eip
  1668.         push    0
  1669.         push    69
  1670.         pop     eax
  1671.         push    6
  1672.         pop     ebx
  1673.         mov     ecx, [debuggee_pid]
  1674.         mov     edi, esp
  1675.         mov     esi, [_eip]
  1676.         push    1
  1677.         pop     edx
  1678.         mcall
  1679.         pop     eax
  1680.         cmp     al, 0xCC
  1681.         jnz     .notdbg
  1682. ; this is either dbg breakpoint or int3 cmd in debuggee
  1683.         mov     eax, [_eip]
  1684.         call    find_enabled_breakpoint
  1685.         jnz     .user_int3
  1686. ; dbg breakpoint; clear if one-shot
  1687.         pop     ecx
  1688.         push    eax
  1689.         mov     esi, aBreakStop
  1690.         test    byte [edi+4], 4
  1691.         jz      .put_msg_eax
  1692.         pop     ecx
  1693.         call    clear_breakpoint
  1694.         jmp     .done
  1695. .user_int3:
  1696.         mov     eax, [_eip]
  1697.         inc     [_eip]
  1698.         pop     ecx
  1699.         push    eax
  1700.         call    set_context
  1701.         mov     esi, aUserBreak
  1702.         jmp     .put_msg_eax
  1703. .notdbg:
  1704.         mov     esi, aException
  1705. .put_msg_eax:
  1706.         call    put_message_nodraw
  1707. .done_draw:
  1708.         call    draw_messages
  1709. .done:
  1710.         push    18
  1711.         pop     eax
  1712.         push    3
  1713.         pop     ebx
  1714.         mov     ecx, [dbgwnd]
  1715.         mcall   ; activate dbg window
  1716.         call    redraw_title
  1717.         call    redraw_registers
  1718.         call    redraw_dump
  1719.         call    update_disasm_eip
  1720. dbgmsgend:
  1721.         pop     esi
  1722.         mov     ecx, [dbgbuflen]
  1723.         add     ecx, dbgbuf
  1724.         cmp     esi, ecx
  1725.         jnz     dbgmsgstart
  1726.         and     [dbgbuflen], 0
  1727.         neg     [dbgbufsize]
  1728.         cmp     [bReload], 2
  1729.         jnz     @f
  1730.         mov     [bReload], 0
  1731.         call    do_reload
  1732. @@:
  1733.         jmp     waitevent
  1734.  
  1735. CtrlF7:
  1736.         cmp     [debuggee_pid], 0
  1737.         jz      .no
  1738.         call    OnStep
  1739. .no:
  1740.         jmp     waitevent
  1741. CtrlF8:
  1742.         cmp     [debuggee_pid], 0
  1743.         jz      CtrlF7.no
  1744.         call    OnProceed
  1745.         jmp     CtrlF7.no
  1746.  
  1747. OnStep:
  1748.         cmp     [bSuspended], 0
  1749.         jz      .running
  1750.         call    get_context
  1751.         or      byte [_eflags+1], 1             ; set TF
  1752.         call    set_context
  1753.         and     byte [_eflags+1], not 1
  1754. ; if instruction at eip is "int xx", set one-shot breakpoint immediately after
  1755.         mov     eax, [_eip]
  1756.         call    find_enabled_breakpoint
  1757.         jnz     @f
  1758.         cmp     byte [edi+5], 0xCD
  1759.         jz      .int
  1760. @@:
  1761.         push    0
  1762.         push    69
  1763.         pop     eax
  1764.         push    6
  1765.         pop     ebx
  1766.         mov     ecx, [debuggee_pid]
  1767.         push    3
  1768.         pop     edx
  1769.         mov     edi, esp
  1770.         mov     esi, [_eip]
  1771.         mcall
  1772.         cmp     eax, edx
  1773.         pop     eax
  1774.         jnz     .doit
  1775.         cmp     al, 0xCD
  1776.         jz      .int
  1777.         cmp     ax, 0x050F
  1778.         jz      .syscall
  1779.         cmp     ax, 0x340F
  1780.         jz      .sysenter
  1781. ; resume process
  1782. .doit:
  1783.         call    GoOn
  1784.         cmp     [bAfterGo], 0
  1785.         jz      @f
  1786.         mov     [bAfterGo], 2
  1787. @@:
  1788.         ret
  1789. .sysenter:      ; return address is [ebp-4]
  1790.         push    0
  1791.         push    69
  1792.         pop     eax
  1793.         inc     edx     ; read 4 bytes
  1794.         mov     esi, [_ebp]
  1795.         sub     esi, 4
  1796.         mcall
  1797.         cmp     eax, edx
  1798.         pop     eax
  1799.         jnz     .syscall
  1800.         push    eax
  1801.         and     byte [_eflags+1], not 1
  1802.         call    set_context
  1803.         pop     eax
  1804.         jmp     @f
  1805. .syscall:
  1806.         and     byte [_eflags+1], not 1 ; clear TF - avoid system halt (!)
  1807.         call    set_context
  1808. .int:
  1809.         mov     eax, [_eip]
  1810.         inc     eax
  1811.         inc     eax
  1812. @@:
  1813.         push    eax
  1814.         call    find_enabled_breakpoint
  1815.         pop     eax
  1816.         jz      .doit
  1817. ; there is no enabled breakpoint yet; set temporary breakpoint
  1818.         mov     bl, 5
  1819.         call    add_breakpoint
  1820.         jmp     .doit
  1821. .running:
  1822.         mov     esi, aRunningErr
  1823.         jmp     put_message
  1824.  
  1825. OnProceed:
  1826.         cmp     [bSuspended], 0
  1827.         jz      OnStep.running
  1828.         mov     esi, [_eip]
  1829. @@:
  1830.         call    get_byte_nobreak
  1831.         jc      OnStep
  1832.         inc     esi
  1833. ; skip prefixes
  1834.         call    is_prefix
  1835.         jz      @b
  1836.         cmp     al, 0xE8        ; call
  1837.         jnz     @f
  1838.         add     esi, 4
  1839.         jmp     .doit
  1840. @@:     ; A4,A5 = movs, A6,A7=cmps
  1841.         cmp     al, 0xA4
  1842.         jb      @f
  1843.         cmp     al, 0xA8
  1844.         jb      .doit
  1845. @@:     ; AA,AB=stos, AC,AD=lods, AE,AF=scas
  1846.         cmp     al, 0xAA
  1847.         jb      @f
  1848.         cmp     al, 0xB0
  1849.         jb      .doit
  1850. @@:     ; E0=loopnz,E1=loopz,E2=loop
  1851.         cmp     al, 0xE0
  1852.         jb      .noloop
  1853.         cmp     al, 0xE2
  1854.         ja      .noloop
  1855.         inc     esi
  1856.         jmp     .doit
  1857. .noloop:        ; FF /2 = call
  1858.         cmp     al, 0xFF
  1859.         jnz     OnStep
  1860.         call    get_byte_nobreak
  1861.         jc      OnStep
  1862.         inc     esi
  1863.         mov     cl, al
  1864.         and     al, 00111000b
  1865.         cmp     al, 00010000b
  1866.         jnz     OnStep
  1867. ; skip instruction
  1868.         mov     al, cl
  1869.         and     eax, 7
  1870.         shr     cl, 6
  1871.         jz      .mod0
  1872.         jp      .doit
  1873.         cmp     al, 4
  1874.         jnz     @f
  1875.         inc     esi
  1876. @@:
  1877.         inc     esi
  1878.         dec     cl
  1879.         jz      @f
  1880.         add     esi, 3
  1881. @@:
  1882.         jmp     .doit
  1883. .mod0:
  1884.         cmp     al, 4
  1885.         jnz     @f
  1886.         call    get_byte_nobreak
  1887.         jc      OnStep
  1888.         inc     esi
  1889.         and     al, 7
  1890. @@:
  1891.         cmp     al, 5
  1892.         jnz     .doit
  1893.         add     esi, 4
  1894. .doit:
  1895. ; insert one-shot breakpoint at esi and resume
  1896.         call    get_byte_nobreak
  1897.         jc      OnStep
  1898.         mov     eax, esi
  1899.         call    find_enabled_breakpoint
  1900.         jz      .ret
  1901.         mov     eax, esi
  1902.         mov     bl, 5
  1903.         call    add_breakpoint
  1904.         jmp     OnStep.doit
  1905. .ret:
  1906.         ret
  1907.  
  1908. get_byte_nobreak:
  1909.         mov     eax, esi
  1910.         call    find_enabled_breakpoint
  1911.         jnz     .nobreak
  1912.         mov     al, [edi+5]
  1913.         clc
  1914.         ret
  1915. .nobreak:
  1916.         push    69
  1917.         pop     eax
  1918.         push    6
  1919.         pop     ebx
  1920.         mov     ecx, [debuggee_pid]
  1921.         xor     edx, edx
  1922.         push    edx
  1923.         inc     edx
  1924.         mov     edi, esp
  1925.         mcall
  1926.         dec     eax
  1927.         clc
  1928.         jz      @f
  1929.         stc
  1930. @@:     pop     eax
  1931.         ret
  1932.  
  1933. is_prefix:
  1934.         cmp     al, 0x64        ; fs:
  1935.         jz      .ret
  1936.         cmp     al, 0x65        ; gs:
  1937.         jz      .ret
  1938.         cmp     al, 0x66        ; use16/32
  1939.         jz      .ret
  1940.         cmp     al, 0x67        ; addr16/32
  1941.         jz      .ret
  1942.         cmp     al, 0xF0        ; lock
  1943.         jz      .ret
  1944.         cmp     al, 0xF2        ; repnz
  1945.         jz      .ret
  1946.         cmp     al, 0xF3        ; rep(z)
  1947.         jz      .ret
  1948.         cmp     al, 0x2E        ; cs:
  1949.         jz      .ret
  1950.         cmp     al, 0x36        ; ss:
  1951.         jz      .ret
  1952.         cmp     al, 0x3E        ; ds:
  1953.         jz      .ret
  1954.         cmp     al, 0x26        ; es:
  1955. .ret:   ret
  1956.  
  1957. token_end       equ     1
  1958. token_reg       equ     2
  1959. token_hex       equ     3
  1960. token_add       equ     4
  1961. token_sub       equ     5
  1962. token_mul       equ     6
  1963. token_div       equ     7
  1964. token_lp        equ     8
  1965. token_rp        equ     9
  1966. token_err       equ     -1
  1967.  
  1968. is_hex_digit:
  1969.         cmp     al, '0'
  1970.         jb      .no
  1971.         cmp     al, '9'
  1972.         jbe     .09
  1973.         cmp     al, 'A'
  1974.         jb      .no
  1975.         cmp     al, 'F'
  1976.         jbe     .AF
  1977.         cmp     al, 'a'
  1978.         jb      .no
  1979.         cmp     al, 'f'
  1980.         jbe     .af
  1981. .no:
  1982.         stc
  1983.         ret
  1984. .09:
  1985.         sub     al, '0'
  1986. ;       clc
  1987.         ret
  1988. .AF:
  1989.         sub     al, 'A'-10
  1990. ;       clc
  1991.         ret
  1992. .af:
  1993.         sub     al, 'a'-10
  1994. ;       clc
  1995.         ret
  1996.  
  1997. find_reg:
  1998.         mov     edi, reg_table
  1999. .findreg:
  2000.         movzx   ecx, byte [edi]
  2001.         stc
  2002.         jecxz   .regnotfound
  2003.         inc     edi
  2004.         push    esi edi ecx
  2005. @@:
  2006.         lodsb
  2007.         or      al, 20h
  2008.         scasb
  2009.         loopz   @b
  2010.         pop     ecx edi esi
  2011.         lea     edi, [edi+ecx+1]
  2012.         jnz     .findreg
  2013.         movzx   edi, byte [edi-1]
  2014.         add     esi, ecx
  2015. .regnotfound:
  2016.         ret
  2017.  
  2018. expr_get_token:
  2019.         lodsb
  2020.         cmp     al, 0
  2021.         jz      .end_token
  2022.         cmp     al, ' '
  2023.         jbe     expr_get_token
  2024.         cmp     al, '+'
  2025.         jz      .add
  2026.         cmp     al, '-'
  2027.         jz      .sub
  2028.         cmp     al, '*'
  2029.         jz      .mul
  2030.         cmp     al, '/'
  2031.         jz      .div
  2032.         cmp     al, '('
  2033.         jz      .lp
  2034.         cmp     al, ')'
  2035.         jnz     .notsign
  2036. .rp:
  2037.         mov     al, token_rp
  2038.         ret
  2039. .div:
  2040.         mov     al, token_div
  2041.         ret
  2042. .end_token:
  2043.         mov     al, token_end
  2044.         ret
  2045. .add:
  2046.         mov     al, token_add
  2047.         ret
  2048. .sub:
  2049.         mov     al, token_sub
  2050.         ret
  2051. .mul:
  2052.         mov     al, token_mul
  2053.         ret
  2054. .lp:
  2055.         mov     al, token_lp
  2056.         ret
  2057. .notsign:
  2058.         dec     esi
  2059.         call    find_reg
  2060.         jc      .regnotfound
  2061.         mov     al, token_reg
  2062.         ret
  2063. .regnotfound:
  2064. ; test for symbol
  2065.         push    esi
  2066. @@:
  2067.         lodsb
  2068.         cmp     al, ' '
  2069.         ja      @b
  2070.         push    eax
  2071.         mov     byte [esi], 0
  2072.         xchg    esi, [esp+4]
  2073.         call    find_symbol_name
  2074.         mov     edi, eax
  2075.         pop     eax
  2076.         xchg    esi, [esp]
  2077.         mov     byte [esi], al
  2078.         jc      @f
  2079.         add     esp, 4
  2080.         mov     al, token_hex
  2081.         ret
  2082. @@:
  2083.         pop     esi
  2084. ; test for hex number
  2085.         xor     ecx, ecx
  2086.         xor     edi, edi
  2087.         xor     eax, eax
  2088. @@:
  2089.         lodsb
  2090.         call    is_hex_digit
  2091.         jc      @f
  2092.         shl     edi, 4
  2093.         or      edi, eax
  2094.         inc     ecx
  2095.         jmp     @b
  2096. @@:
  2097.         dec     esi
  2098.         jecxz   .err
  2099.         cmp     ecx, 8
  2100.         ja      .err
  2101.         mov     al, token_hex
  2102.         ret
  2103. .err:
  2104.         mov     al, token_err
  2105.         mov     esi, aParseError
  2106.         ret
  2107.  
  2108. expr_read2:
  2109.         cmp     al, token_hex
  2110.         jz      .hex
  2111.         cmp     al, token_reg
  2112.         jz      .reg
  2113.         cmp     al, token_lp
  2114.         jz      .lp
  2115.         mov     al, token_err
  2116.         mov     esi, aParseError
  2117.         ret
  2118. .hex:
  2119.         mov     ebp, edi
  2120. .ret:
  2121.         jmp     expr_get_token
  2122. .reg:
  2123.         cmp     edi, 24
  2124.         jz      .eip
  2125.         sub     edi, 4
  2126.         jb      .8lo
  2127.         sub     edi, 4
  2128.         jb      .8hi
  2129.         sub     edi, 8
  2130.         jb      .16
  2131.         mov     ebp, [_eax+edi*4]
  2132.         jmp     .ret
  2133. .16:
  2134.         movzx   ebp, word [_eax+(edi+8)*4]
  2135.         jmp     .ret
  2136. .8lo:
  2137.         movzx   ebp, byte [_eax+(edi+4)*4]
  2138.         jmp     .ret
  2139. .8hi:
  2140.         movzx   ebp, byte [_eax+(edi+4)*4+1]
  2141.         jmp     .ret
  2142. .eip:
  2143.         mov     ebp, [_eip]
  2144.         jmp     .ret
  2145. .lp:
  2146.         call    expr_get_token
  2147.         call    expr_read0
  2148.         cmp     al, token_err
  2149.         jz      @f
  2150.         cmp     al, token_rp
  2151.         jz      expr_get_token
  2152.         mov     al, token_err
  2153.         mov     esi, aParseError
  2154. @@:     ret
  2155.  
  2156. expr_read1:
  2157.         call    expr_read2
  2158. .1:
  2159.         cmp     al, token_mul
  2160.         jz      .mul
  2161.         cmp     al, token_div
  2162.         jz      .div
  2163.         ret
  2164. .mul:
  2165.         push    ebp
  2166.         call    expr_get_token
  2167.         call    expr_read2
  2168.         pop     edx
  2169. ; ebp := edx*ebp
  2170.         imul    ebp, edx
  2171.         jmp     .1
  2172. .div:
  2173.         push    ebp
  2174.         call    expr_get_token
  2175.         call    expr_read2
  2176.         pop     edx
  2177. ; ebp := edx/ebp
  2178.         test    ebp, ebp
  2179.         jz      .div0
  2180.         push    eax
  2181.         xor     eax, eax
  2182.         xchg    eax, edx
  2183.         div     ebp
  2184.         xchg    eax, ebp
  2185.         pop     eax
  2186.         jmp     .1
  2187. .div0:
  2188.         mov     al, token_err
  2189.         mov     esi, aDivByZero
  2190.         ret
  2191.  
  2192. expr_read0:
  2193.         xor     ebp, ebp
  2194.         cmp     al, token_add
  2195.         jz      .add
  2196.         cmp     al, token_sub
  2197.         jz      .sub
  2198.         call    expr_read1
  2199. .1:
  2200.         cmp     al, token_add
  2201.         jz      .add
  2202.         cmp     al, token_sub
  2203.         jz      .sub
  2204.         ret
  2205. .add:
  2206.         push    ebp
  2207.         call    expr_get_token
  2208.         call    expr_read1
  2209.         pop     edx
  2210. ; ebp := edx+ebp
  2211.         add     ebp, edx
  2212.         jmp     .1
  2213. .sub:
  2214.         push    ebp
  2215.         call    expr_get_token
  2216.         call    expr_read1
  2217.         pop     edx
  2218. ; ebp := edx-ebp
  2219.         xchg    edx, ebp
  2220.         sub     ebp, edx
  2221.         jmp     .1
  2222.  
  2223. calc_expression:
  2224. ; in: esi->expression
  2225. ; out: CF=1 if error
  2226. ;      CF=0 and ebp=value if ok
  2227.         call    expr_get_token
  2228.         call    expr_read0
  2229.         cmp     al, token_end
  2230.         jz      .end
  2231.         cmp     al, token_err
  2232.         jz      @f
  2233.         mov     esi, aParseError
  2234. @@:
  2235.         call    put_message
  2236.         stc
  2237.         ret
  2238. .end:
  2239.         clc
  2240.         ret
  2241.  
  2242. OnCalc:
  2243.         mov     esi, [curarg]
  2244.         call    calc_expression
  2245.         jc      .ret
  2246.         push    ebp
  2247.         mov     esi, calc_string
  2248.         call    put_message_nodraw
  2249.         jmp     draw_messages
  2250. .ret:
  2251.         ret
  2252.  
  2253. OnDump:
  2254.         mov     esi, [curarg]
  2255.         cmp     byte [esi], 0
  2256.         jnz     .param
  2257.         add     [dumppos], dump_height*10h
  2258.         jmp     .doit
  2259. .param:
  2260.         call    calc_expression
  2261.         jc      .ret
  2262.         mov     [dumppos], ebp
  2263. .doit:
  2264.         call    get_dump
  2265.         call    redraw_dump
  2266. .ret:
  2267.         ret
  2268.  
  2269. OnUnassemble:
  2270.         mov     esi, [curarg]
  2271.         cmp     byte [esi], 0
  2272.         jnz     .param
  2273.         mov     eax, [disasm_start_pos]
  2274.         mov     ecx, disasm_height
  2275.         mov     [disasm_cur_pos], eax
  2276. .l:
  2277.         mov     eax, [disasm_cur_pos]
  2278.         call    find_symbol
  2279.         jc      @f
  2280.         dec     ecx
  2281.         jz      .m
  2282. @@:
  2283.         push    ecx
  2284.         call    disasm_instr
  2285.         pop     ecx
  2286.         jc      .err
  2287.         loop    .l
  2288. .m:
  2289.         mov     eax, [disasm_cur_pos]
  2290.         jmp     .doit
  2291. .param:
  2292.         call    calc_expression
  2293.         jc      .ret
  2294.         mov     eax, ebp
  2295. .doit:
  2296.         push    eax
  2297.         push    [disasm_start_pos]
  2298.         mov     [disasm_start_pos], eax
  2299.         call    update_disasm
  2300.         pop     [disasm_start_pos]
  2301.         pop     eax
  2302.         cmp     [disasm_cur_str], 0
  2303.         jz      @f
  2304.         mov     [disasm_start_pos], eax
  2305. .ret:
  2306.         ret
  2307. @@:
  2308.         call    update_disasm
  2309. .err:
  2310.         mov     esi, aInvAddr
  2311.         jmp     put_message
  2312.  
  2313. OnReg:
  2314.         mov     esi, [curarg]
  2315.         call    skip_spaces
  2316.         call    find_reg
  2317.         jnc     @f
  2318. .err:
  2319.         mov     esi, RSyntax
  2320.         jmp     put_message
  2321. @@:
  2322.         call    skip_spaces
  2323.         test    al, al
  2324.         jz      .err
  2325.         cmp     al, '='
  2326.         jnz     @f
  2327.         inc     esi
  2328.         call    skip_spaces
  2329.         test    al, al
  2330.         jz      .err
  2331. @@:
  2332.         push    edi
  2333.         call    calc_expression
  2334.         pop     edi
  2335.         jc      .ret
  2336. ; now edi=register id, ebp=value
  2337.         cmp     [bSuspended], 0
  2338.         mov     esi, aRunningErr
  2339.         jz      put_message
  2340.         xchg    eax, ebp
  2341.         cmp     edi, 24
  2342.         jz      .eip
  2343.         sub     edi, 4
  2344.         jb      .8lo
  2345.         sub     edi, 4
  2346.         jb      .8hi
  2347.         sub     edi, 8
  2348.         jb      .16
  2349.         mov     [_eax+edi*4], eax
  2350.         jmp     .ret
  2351. .16:
  2352.         mov     word [_eax+(edi+8)*4], ax
  2353.         jmp     .ret
  2354. .8lo:
  2355.         mov     byte [_eax+(edi+4)*4], al
  2356.         jmp     .ret
  2357. .8hi:
  2358.         mov     byte [_eax+(edi+4)*4+1], al
  2359.         jmp     .ret
  2360. .eip:
  2361.         mov     [_eip], eax
  2362.         call    update_disasm_eip
  2363. .ret:
  2364.         call    set_context
  2365.         jmp     redraw_registers
  2366.  
  2367. ; Breakpoints manipulation
  2368. OnBp:
  2369.         mov     esi, [curarg]
  2370.         call    calc_expression
  2371.         jc      .ret
  2372.         xchg    eax, ebp
  2373.         push    eax
  2374.         call    find_breakpoint
  2375.         inc     eax
  2376.         pop     eax
  2377.         jz      .notfound
  2378.         mov     esi, aDuplicateBreakpoint
  2379.         jmp     .sayerr
  2380. .notfound:
  2381.         mov     bl, 1
  2382.         call    add_breakpoint
  2383.         jnc     .ret
  2384.         mov     esi, aBreakpointLimitExceeded
  2385. .sayerr:
  2386.         call    put_message
  2387. .ret:
  2388.         jmp     redraw_disasm
  2389.  
  2390. OnBpmb:
  2391.         mov     dh, 0011b
  2392.         jmp     DoBpm
  2393. OnBpmw:
  2394.         mov     dh, 0111b
  2395.         jmp     DoBpm
  2396. OnBpmd:
  2397.         mov     dh, 1111b
  2398. DoBpm:
  2399.         mov     esi, [curarg]
  2400.         cmp     byte [esi], 'w'
  2401.         jnz     @f
  2402.         and     dh, not 2
  2403.         inc     esi
  2404. @@:
  2405.         push    edx
  2406.         call    calc_expression
  2407.         pop     edx
  2408.         jnc     @f
  2409.         ret
  2410. @@:
  2411. ; ebp=expression, dh=flags
  2412.         movzx   eax, dh
  2413.         shr     eax, 2
  2414.         test    ebp, eax
  2415.         jz      @f
  2416.         mov     esi, aUnaligned
  2417.         jmp     put_message
  2418. @@:
  2419.         mov     eax, ebp
  2420.         mov     bl, 0Bh
  2421.         call    add_breakpoint
  2422.         jnc     @f
  2423.         mov     esi, aBreakpointLimitExceeded
  2424.         jmp     put_message
  2425. @@:
  2426. ; now find index
  2427.         push    eax
  2428.         xor     ecx, ecx
  2429. .l1:
  2430.         cmp     [drx_break+ecx*4], 0
  2431.         jnz     .l2
  2432.         push    69
  2433.         pop     eax
  2434.         push    ecx
  2435.         mov     dl, cl
  2436.         mov     ecx, [debuggee_pid]
  2437.         mov     esi, ebp
  2438.         push    9
  2439.         pop     ebx
  2440.         mcall
  2441.         test    eax, eax
  2442.         jz      .ok
  2443.         pop     ecx
  2444. .l2:
  2445.         inc     ecx
  2446.         cmp     ecx, 4
  2447.         jb      .l1
  2448.         pop     eax
  2449.         call    clear_breakpoint
  2450.         mov     esi, aBreakpointLimitExceeded
  2451.         jmp     put_message
  2452. .ok:
  2453.         pop     ecx
  2454.         pop     eax
  2455.         and     byte [edi], not 2       ; breakpoint is enabled
  2456.         shl     dl, 6
  2457.         or      dl, dh
  2458.         mov     byte [edi+1], dl
  2459.         inc     eax
  2460.         mov     [drx_break+ecx*4], eax
  2461.         ret
  2462.  
  2463. OnBc:
  2464.         mov     esi, [curarg]
  2465. @@:     call    get_hex_number
  2466.         jc      OnBp.ret
  2467.         call    clear_breakpoint
  2468.         jmp     @b
  2469.  
  2470. OnBd:
  2471.         mov     esi, [curarg]
  2472. @@:     call    get_hex_number
  2473.         jc      OnBp.ret
  2474.         call    disable_breakpoint
  2475.         jmp     @b
  2476.  
  2477. OnBe:
  2478.         mov     esi, [curarg]
  2479. @@:     call    get_hex_number
  2480.         jc      OnBp.ret
  2481.         push    eax
  2482.         call    find_enabled_breakpoint
  2483.         pop     eax
  2484.         jz      .err
  2485.         call    enable_breakpoint
  2486.         jmp     @b
  2487. .err:
  2488.         mov     esi, OnBeErrMsg
  2489.         jmp     put_message
  2490.  
  2491. get_hex_number:
  2492.         call    skip_spaces
  2493.         xor     ecx, ecx
  2494.         xor     edx, edx
  2495. @@:
  2496.         lodsb
  2497.         call    is_hex_digit
  2498.         jc      .ret
  2499.         shl     edx, 4
  2500.         or      dl, al
  2501.         inc     ecx
  2502.         jmp     @b
  2503. .ret:
  2504.         dec     esi
  2505.         cmp     ecx, 1
  2506.         xchg    eax, edx
  2507.         ret
  2508.  
  2509. OnBl:
  2510.         mov     esi, [curarg]
  2511.         cmp     byte [esi], 0
  2512.         jz      .listall
  2513.         call    get_hex_number
  2514.         jc      .ret
  2515.         cmp     eax, breakpoints_n
  2516.         jae     .err
  2517.         push    eax
  2518.         add     eax, eax
  2519.         lea     edi, [breakpoints + eax + eax*2]
  2520.         pop     eax
  2521.         test    byte [edi+4], 1
  2522.         jz      .err
  2523.         call    show_break_info
  2524. .ret:
  2525.         ret
  2526. .err:
  2527.         mov     esi, aInvalidBreak
  2528.         jmp     put_message
  2529. .listall:
  2530.         mov     edi, breakpoints
  2531.         xor     eax, eax
  2532. @@:
  2533.         test    byte [edi+4], 1
  2534.         jz      .cont
  2535.         push    edi eax
  2536.         call    show_break_info
  2537.         pop     eax edi
  2538. .cont:
  2539.         add     edi, 6
  2540.         inc     eax
  2541.         cmp     eax, breakpoints_n
  2542.         jb      @b
  2543.         ret
  2544.  
  2545. show_break_info:
  2546.         push    edi
  2547.         test    byte [edi+4], 8
  2548.         jnz     .dr
  2549.         push    dword [edi]
  2550.         push    eax
  2551.         mov     esi, aBreakNum
  2552.         call    put_message_nodraw
  2553.         jmp     .cmn
  2554. .dr:
  2555.         push    eax
  2556.         mov     esi, aMemBreak1
  2557.         call    put_message_nodraw
  2558.         pop     edi
  2559.         push    edi
  2560.         mov     esi, aMemBreak2
  2561.         test    byte [edi+5], 2
  2562.         jz      @f
  2563.         mov     esi, aMemBreak3
  2564. @@:
  2565.         call    put_message_nodraw
  2566.         pop     edi
  2567.         push    edi
  2568.         mov     esi, aMemBreak6
  2569.         test    byte [edi+5], 8
  2570.         jnz     @f
  2571.         mov     esi, aMemBreak5
  2572.         test    byte [edi+5], 4
  2573.         jnz     @f
  2574.         mov     esi, aMemBreak4
  2575. @@:
  2576.         call    put_message_nodraw
  2577.         pop     edi
  2578.         push    edi
  2579.         push    dword [edi]
  2580.         mov     esi, aMemBreak7
  2581.         call    put_message_nodraw
  2582. .cmn:
  2583.         pop     edi
  2584.         test    byte [edi+4], 2
  2585.         jz      @f
  2586.         push    edi
  2587.         mov     esi, aDisabled
  2588.         call    put_message_nodraw
  2589.         pop     edi
  2590. @@:
  2591.         test    byte [edi+4], 4
  2592.         jz      @f
  2593.         mov     esi, aOneShot
  2594.         call    put_message_nodraw
  2595. @@:
  2596.         mov     esi, newline
  2597.         jmp     put_message
  2598.  
  2599. add_breakpoint:
  2600. ; in: eax=address, bl=flags
  2601. ; out: CF=1 => error, CF=0 => eax=breakpoint number
  2602.         xor     ecx, ecx
  2603.         mov     edi, breakpoints
  2604. @@:
  2605.         test    byte [edi+4], 1
  2606.         jz      .found
  2607.         add     edi, 6
  2608.         inc     ecx
  2609.         cmp     ecx, breakpoints_n
  2610.         jb      @b
  2611.         stc
  2612.         ret
  2613. .found:
  2614.         stosd
  2615.         xchg    eax, ecx
  2616.         mov     [edi], bl
  2617.         test    bl, 2
  2618.         jnz     @f
  2619.         or      byte [edi], 2
  2620.         push    eax
  2621.         call    enable_breakpoint
  2622.         pop     eax
  2623. @@:
  2624.         clc
  2625.         ret
  2626.  
  2627. clear_breakpoint:
  2628.         cmp     eax, breakpoints_n
  2629.         jae     .ret
  2630.         mov     ecx, 4
  2631.         inc     eax
  2632. .1:
  2633.         cmp     [drx_break-4+ecx*4], eax
  2634.         jnz     @f
  2635.         and     [drx_break-4+ecx*4], 0
  2636. @@:     loop    .1
  2637.         dec     eax
  2638.         push    eax
  2639.         add     eax, eax
  2640.         lea     edi, [breakpoints + eax + eax*2 + 4]
  2641.         test    byte [edi], 1
  2642.         pop     eax
  2643.         jz      .ret
  2644.         push    edi
  2645.         call    disable_breakpoint
  2646.         pop     edi
  2647.         mov     byte [edi], 0
  2648. .ret:
  2649.         ret
  2650.  
  2651. disable_breakpoint:
  2652.         cmp     eax, breakpoints_n
  2653.         jae     .ret
  2654.         add     eax, eax
  2655.         lea     edi, [breakpoints + eax + eax*2 + 5]
  2656.         test    byte [edi-1], 1
  2657.         jz      .ret
  2658.         test    byte [edi-1], 2
  2659.         jnz     .ret
  2660.         or      byte [edi-1], 2
  2661.         test    byte [edi-1], 8
  2662.         jnz     .dr
  2663.         push    esi
  2664.         push    7
  2665.         pop     ebx
  2666.         push    69
  2667.         pop     eax
  2668.         mov     ecx, [debuggee_pid]
  2669.         xor     edx, edx
  2670.         inc     edx
  2671.         mov     esi, [edi-5]
  2672.         mcall
  2673.         pop     esi
  2674. .ret:
  2675.         ret
  2676. .dr:
  2677.         mov     dl, [edi]
  2678.         shr     dl, 6
  2679.         mov     dh, 80h
  2680.         push    69
  2681.         pop     eax
  2682.         push    9
  2683.         pop     ebx
  2684.         mov     ecx, [debuggee_pid]
  2685.         mcall
  2686.         ret
  2687.  
  2688. enable_breakpoint:
  2689.         push    esi
  2690.         cmp     eax, breakpoints_n
  2691.         jae     .ret
  2692.         add     eax, eax
  2693.         lea     edi, [breakpoints + eax + eax*2 + 5]
  2694.         test    byte [edi-1], 1
  2695.         jz      .ret
  2696.         test    byte [edi-1], 2
  2697.         jz      .ret
  2698.         and     byte [edi-1], not 2
  2699.         test    byte [edi-1], 8
  2700.         jnz     .dr
  2701.         push    6
  2702.         pop     ebx
  2703.         push    69
  2704.         pop     eax
  2705.         mov     esi, [edi-5]
  2706.         mov     ecx, [debuggee_pid]
  2707.         xor     edx, edx
  2708.         inc     edx
  2709.         mcall
  2710.         dec     eax
  2711.         jnz     .err
  2712.         mov     al, 69
  2713.         push    0xCC
  2714.         mov     edi, esp
  2715.         inc     ebx
  2716.         mcall
  2717.         pop     eax
  2718. .ret:
  2719.         pop     esi
  2720.         ret
  2721. .err:
  2722.         or      byte [edi-1], 2
  2723.         mov     esi, aBreakErr
  2724.         call    put_message
  2725.         pop     esi
  2726.         ret
  2727. .dr:
  2728.         push    9
  2729.         pop     ebx
  2730.         push    69
  2731.         pop     eax
  2732.         mov     esi, [edi-5]
  2733.         mov     ecx, [debuggee_pid]
  2734.         mov     dl, [edi]
  2735.         shr     dl, 6
  2736.         mov     dh, [edi]
  2737.         and     dh, 0xF
  2738.         mcall
  2739.         test    eax, eax
  2740.         jnz     .err
  2741.         pop     esi
  2742.         ret
  2743.  
  2744. find_breakpoint:
  2745.         xor     ecx, ecx
  2746.         xchg    eax, ecx
  2747.         mov     edi, breakpoints
  2748. @@:
  2749.         test    byte [edi+4], 1
  2750.         jz      .cont
  2751.         test    byte [edi+4], 8
  2752.         jnz     .cont
  2753.         cmp     [edi], ecx
  2754.         jz      .found
  2755. .cont:
  2756.         add     edi, 6
  2757.         inc     eax
  2758.         cmp     eax, breakpoints_n
  2759.         jb      @b
  2760.         or      eax, -1
  2761. .found:
  2762.         ret
  2763.  
  2764. find_enabled_breakpoint:
  2765.         xor     ecx, ecx
  2766.         xchg    eax, ecx
  2767.         mov     edi, breakpoints
  2768. @@:
  2769.         test    byte [edi+4], 1
  2770.         jz      .cont
  2771.         test    byte [edi+4], 2 or 8
  2772.         jnz     .cont
  2773.         cmp     [edi], ecx
  2774.         jz      .found
  2775. .cont:
  2776.         add     edi, 6
  2777.         inc     eax
  2778.         cmp     eax, breakpoints_n
  2779.         jb      @b
  2780.         or      eax, -1
  2781. .found:
  2782.         ret
  2783.  
  2784. OnUnpack:
  2785. ; program must be loaded - checked when command was parsed
  2786. ; program must be stopped
  2787.         mov     esi, aRunningErr
  2788.         cmp     [bSuspended], 0
  2789.         jz      put_message
  2790. ; all breakpoints must be disabled
  2791.         mov     edi, breakpoints
  2792. @@:
  2793.         test    byte [edi+4], 1
  2794.         jz      .cont
  2795.         test    byte [edi+4], 2
  2796.         jnz     .cont
  2797.         mov     esi, aEnabledBreakErr
  2798.         jmp     put_message
  2799. .cont:
  2800.         add     edi, 6
  2801.         cmp     edi, breakpoints+breakpoints_n*6
  2802.         jb      @b
  2803. ; ok, now do it
  2804. ; set breakpoint on 0xC dword access
  2805.         push    9
  2806.         pop     ebx
  2807.         mov     ecx, [debuggee_pid]
  2808.         mov     dx, 1111b*256
  2809.         push    0xC
  2810.         pop     esi
  2811. @@:
  2812.         push    69
  2813.         pop     eax
  2814.         mcall
  2815.         test    eax, eax
  2816.         jz      .breakok
  2817.         inc     edx
  2818.         cmp     dl, 4
  2819.         jb      @b
  2820. .breakok:
  2821.         call    GoOn
  2822. ; now wait for event