Subversion Repositories Kolibri OS

Rev

Rev 485 | Rev 551 | 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, 13FFFFFFh
  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.         mov     al, 12
  1034.         push    2
  1035.         pop     ebx
  1036.         mcall
  1037.         ret
  1038.  
  1039. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1040. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; DEBUGGING ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1041. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  1042.  
  1043. OnHelp:
  1044.         mov     esi, help_msg
  1045.         mov     edi, [curarg]
  1046.         cmp     byte [edi], 0
  1047.         jz      .x
  1048.         mov     esi, help_groups
  1049.         call    find_cmd
  1050.         jc      .nocmd
  1051.         mov     esi, [esi+12]
  1052. .x:
  1053.         jmp     put_message
  1054. .nocmd:
  1055.         mov     esi, aUnknownCommand
  1056.         jmp     .x
  1057.  
  1058. OnQuit:
  1059.         push    -1
  1060.         pop     eax
  1061.         mcall
  1062.  
  1063. get_new_context:
  1064.         mov     esi, context
  1065.         mov     edi, oldcontext
  1066.         mov     ecx, 10
  1067.         rep     movsd
  1068. get_context:
  1069.         push    1
  1070.         pop     ebx
  1071.         push    69
  1072.         pop     eax
  1073.         mov     ecx, [debuggee_pid]
  1074.         mov     esi, context
  1075.         push    28h
  1076.         pop     edx
  1077.         mcall
  1078.         ret
  1079. set_context:
  1080.         push    2
  1081.         pop     ebx
  1082.         push    69
  1083.         pop     eax
  1084.         mov     ecx, [debuggee_pid]
  1085.         mov     esi, context
  1086.         push    28h
  1087.         pop     edx
  1088.         mcall
  1089.         ret
  1090.  
  1091. get_dump:
  1092.         mov     edi, dumpdata
  1093.         mov     esi, [edi-4]
  1094.         mov     edx, dump_height*10h
  1095.         mov     ecx, edx
  1096.         xor     eax, eax
  1097.         push    edi
  1098.         rep     stosb
  1099.         pop     edi
  1100.         mov     ecx, [debuggee_pid]
  1101.         mov     al, 69
  1102.         push    6
  1103.         pop     ebx
  1104.         mcall
  1105.         cmp     eax, -1
  1106.         jnz     @f
  1107.         mov     esi, read_mem_err
  1108.         call    put_message
  1109.         xor     eax, eax
  1110. @@:
  1111.         mov     [edi-8], eax
  1112. ;       call    restore_from_breaks
  1113. ;       ret
  1114. restore_from_breaks:
  1115. ; in: edi=buffer,eax=size,esi=address
  1116.         mov     ebx, breakpoints
  1117. @@:
  1118.         test    byte [ebx+4], 1
  1119.         jz      .cont           ; ignore invalid
  1120.         test    byte [ebx+4], 2 or 8
  1121.         jnz     .cont           ; ignore disabled and memory breaks
  1122.         mov     ecx, [ebx]
  1123.         sub     ecx, esi
  1124.         cmp     ecx, eax
  1125.         jae     .cont
  1126.         mov     dl, [ebx+5]
  1127.         mov     [edi+ecx], dl
  1128. .cont:
  1129.         add     ebx, 6
  1130.         cmp     ebx, breakpoints+breakpoints_n*6
  1131.         jb      @b
  1132.         ret
  1133.  
  1134. OnLoad:
  1135.         mov     esi, [curarg]
  1136. OnLoadInit:
  1137.         mov     edi, loadname
  1138.         or      [prgname_len], -1
  1139.         mov     [prgname_ptr], edi
  1140. .copyname:
  1141.         lodsb
  1142.         stosb
  1143.         inc     [prgname_len]
  1144.         cmp     al, '/'
  1145.         jnz     @f
  1146.         or      [prgname_len], -1
  1147.         mov     [prgname_ptr], edi
  1148. @@:
  1149.         cmp     al, ' '
  1150.         ja      .copyname
  1151.         mov     byte [edi-1], 0
  1152.         and     [load_params], 0
  1153.         dec     esi
  1154.         call    skip_spaces
  1155.         cmp     al, 0
  1156.         jz      @f
  1157.         mov     [load_params], esi
  1158. @@:
  1159.         and     [dumppos], 0
  1160.         mov     ecx, [symbols]
  1161.         jecxz   do_reload
  1162.         mcall   68, 13
  1163.         and     [symbols], 0
  1164.         and     [num_symbols], 0
  1165. do_reload:
  1166.         push    18
  1167.         pop     eax
  1168.         push    7
  1169.         pop     ebx
  1170.         mcall
  1171.         mov     [dbgwnd], eax
  1172.         xchg    ecx, eax
  1173.         push    70
  1174.         pop     eax
  1175.         mov     ebx, fn70_load_block
  1176.         mcall
  1177.         test    eax, eax
  1178.         jns     .load_ok
  1179. .load_err:
  1180.         push    eax
  1181.         mov     esi, load_err_msg
  1182.         call    put_message
  1183.         pop     eax
  1184.         not     eax
  1185.         cmp     eax, 0x20
  1186.         jae     .unk_err
  1187.         mov     esi, [load_err_msgs+eax*4]
  1188.         test    esi, esi
  1189.         jnz     put_message
  1190. .unk_err:
  1191.         mov     esi, unk_err_msg
  1192.         inc     eax
  1193.         push    eax
  1194.         call    put_message_nodraw
  1195.         jmp     draw_messages
  1196. .load_ok:
  1197.         mov     [debuggee_pid], eax
  1198.         mov     [bSuspended], 1
  1199.         push    ecx
  1200.         call    get_context
  1201.         mov     edi, oldcontext
  1202.         mov     ecx, 10
  1203.         rep     movsd
  1204. ; activate debugger window
  1205.         pop     ecx
  1206.         mov     bl, 3
  1207.         push    18
  1208.         pop     eax
  1209.         mcall
  1210.         call    redraw_title
  1211.         call    redraw_registers
  1212.         call    get_dump
  1213.         call    redraw_dump
  1214.         call    update_disasm_eip_force
  1215.         mov     esi, load_succ_msg
  1216.         push    [debuggee_pid]
  1217.         call    put_message_nodraw
  1218.         call    draw_messages
  1219. ; try to load symbols
  1220.         mov     esi, loadname
  1221.         mov     edi, symbolsfile
  1222.         push    edi
  1223. @@:
  1224.         lodsb
  1225.         stosb
  1226.         test    al, al
  1227.         jnz     @b
  1228.         lea     ecx, [edi-1]
  1229. @@:
  1230.         dec     edi
  1231.         cmp     edi, symbolsfile
  1232.         jb      @f
  1233.         cmp     byte [edi], '/'
  1234.         jz      @f
  1235.         cmp     byte [edi], '.'
  1236.         jnz     @b
  1237.         mov     ecx, edi
  1238. @@:
  1239.         mov     dword [ecx], '.dbg'
  1240.         mov     byte [ecx+4], 0
  1241.         pop     esi
  1242.         mov     ebp, esi
  1243.         call    OnLoadSymbols.silent
  1244. ; now test for packed progs
  1245.         cmp     [disasm_buf_size], 100h
  1246.         jz      @f
  1247.         ret
  1248. @@:
  1249.         mov     esi, mxp_nrv_sig
  1250.         mov     ebp, disasm_buffer
  1251.         mov     edi, ebp
  1252.         push    3
  1253.         pop     ecx
  1254.         repz    cmpsb
  1255.         jnz     .not_mxp_nrv
  1256.         cmpsb
  1257.         mov     cl, mxp_nrv_sig_size-4
  1258.         repz    cmpsb
  1259.         mov     esi, mxp_nrv_name
  1260.         jz      .packed
  1261. .not_mxp_nrv:
  1262.         mov     esi, mxp_sig
  1263.         mov     edi, ebp
  1264.         mov     cl, mxp_sig_size
  1265.         repz    cmpsb
  1266.         mov     esi, mxp_name
  1267.         jz      .packed
  1268. .not_mxp:
  1269.         mov     esi, mxp_lzo_sig1
  1270.         mov     edi, ebp
  1271.         mov     cl, mxp_lzo_sig1_size
  1272.         repz    cmpsb
  1273.         mov     esi, mxp_lzo_name
  1274.         jz      .packed
  1275.         mov     esi, mxp_lzo_sig2
  1276.         mov     edi, ebp
  1277.         mov     cl, 8
  1278.         repz    cmpsb
  1279.         jnz     .not_mxp_lzo
  1280.         cmpsb
  1281.         mov     cl, mxp_lzo_sig2_size - 9
  1282.         repz    cmpsb
  1283.         mov     esi, mxp_lzo_name
  1284.         jz      .packed
  1285. .not_mxp_lzo:
  1286.         mov     esi, mtappack_name
  1287.         cmp     dword [ebp], 0xBF5E246A
  1288.         jnz     .not_mtappack
  1289.         cmp     dword [ebp+8], 0xEC4E8B57
  1290.         jnz     .not_mtappack1
  1291.         cmp     dword [ebp+12], 0x8D5EA4F3
  1292.         jnz     .not_mtappack1
  1293.         cmp     byte [ebp+12h], 0xE9
  1294.         jz      .packed
  1295. .not_mtappack1:
  1296.         cmp     word [ebp+8], 0xB957
  1297.         jnz     .not_mtappack
  1298.         cmp     dword [ebp+14], 0x575EA4F3
  1299.         jnz     .not_mtappack2
  1300.         cmp     byte [ebp+17h], 0xE9
  1301.         jz      .packed
  1302. .not_mtappack2:
  1303.         cmp     dword [ebp+14], 0x5F8DA4F3
  1304.         jnz     .not_mtappack3
  1305.         cmp     word [ebp+18], 0xE9FC
  1306.         jz      .packed
  1307. .not_mtappack3:
  1308.         cmp     word [ebp+14], 0xA4F3
  1309.         jnz     .not_mtappack
  1310.         cmp     byte [ebp+15h], 0xE9
  1311.         jz      .packed
  1312. .not_mtappack:
  1313.         ret
  1314. .packed:
  1315.         push    esi
  1316.         mov     esi, aPacked1
  1317.         call    put_message_nodraw
  1318.         pop     esi
  1319.         call    put_message_nodraw
  1320.         mov     esi, aPacked2
  1321.         call    put_message
  1322.         call    hide_cursor
  1323.         push    40
  1324.         pop     eax
  1325.         push    7
  1326.         pop     ebx
  1327.         mcall
  1328. .wait:
  1329.         push    10
  1330.         pop     eax
  1331.         mcall
  1332.         dec     eax
  1333.         jz      .redraw
  1334.         dec     eax
  1335.         jz      .key
  1336.         or      eax, -1
  1337.         mcall
  1338. .redraw:
  1339.         call    draw_window
  1340.         call    hide_cursor
  1341.         jmp     .wait
  1342. .key:
  1343.         mov     al, 2
  1344.         mcall
  1345.         cmp     ah, 'y'
  1346.         jz      .yes
  1347.         cmp     ah, 'Y'
  1348.         jz      .yes
  1349.         cmp     ah, 0xD
  1350.         jz      .yes
  1351.         cmp     ah, 'n'
  1352.         jz      .no
  1353.         cmp     ah, 'N'
  1354.         jnz     .wait
  1355. .no:
  1356.         push    40
  1357.         pop     eax
  1358.         mov     ebx, 0x107
  1359.         mcall
  1360.         call    draw_cursor
  1361.         mov     esi, aN_str
  1362.         jmp     put_message
  1363. .yes:
  1364.         push    40
  1365.         pop     eax
  1366.         mov     ebx, 0x107
  1367.         mcall
  1368.         call    draw_cursor
  1369.         mov     esi, aY_str
  1370.         call    put_message
  1371.         call    OnUnpack
  1372.         ret
  1373.  
  1374. mxp_nrv_sig:
  1375.         xor     eax, eax
  1376.         mov     ecx, 0x95       ; 0xA1 for programs with parameters
  1377.         mov     [eax], ecx
  1378.         add     ecx, [eax+24h]
  1379.         push    40h
  1380.         pop     esi
  1381.         mov     edi, [eax+20h]
  1382.         push    edi
  1383.         rep     movsb
  1384.         jmp     dword [esp]
  1385.         pop     esi
  1386.         add     esi, [eax]
  1387.         xor     edi, edi
  1388. mxp_nrv_sig_size = $ - mxp_nrv_sig
  1389.  
  1390. mxp_sig:
  1391.         mov     ecx, 1CBh
  1392.         push    46h
  1393.         pop     esi
  1394.         mov     edi, [20h]
  1395.         rep     movsb
  1396.         mov     ecx, [24h]
  1397.         rep     movsb
  1398.         jmp     dword [20h]
  1399.         mov     eax, [20h]
  1400.         add     eax, 1CBh
  1401.         push    eax
  1402.         push    dword [24h]
  1403.         push    0
  1404.         push    8
  1405.         call    $+0x25
  1406. mxp_sig_size = $ - mxp_sig
  1407.  
  1408. mxp_lzo_sig1:
  1409.         xor     eax, eax
  1410.         mov     ebp, 0FFh
  1411.         mov     ecx, 175h
  1412.         mov     [eax], ecx
  1413.         add     ecx, [eax+24h]
  1414.         push    45h
  1415.         pop     esi
  1416.         mov     edi, [eax+20h]
  1417.         push    edi
  1418.         rep     movsb
  1419.         jmp     dword [esp]
  1420.         pop     ebx
  1421.         add     ebx, [eax]
  1422.         xor     edi, edi
  1423.         cmp     byte [ebx], 11h
  1424.         jbe     $+0x1A
  1425. mxp_lzo_sig1_size = $ - mxp_lzo_sig1
  1426. mxp_lzo_sig2:
  1427.         xor     eax, eax
  1428.         mov     ebp, 0FFh
  1429.         mov     ecx, 188h       ; or 177h
  1430.         mov     [eax], ecx
  1431.         add     ecx, [eax+24h]
  1432.         push    44h
  1433.         pop     esi
  1434.         mov     edi, [eax+20h]
  1435.         rep     movsb
  1436.         jmp     dword [eax+20h]
  1437.         mov     ebx, [eax+20h]
  1438.         add     ebx, [eax]
  1439. mxp_lzo_sig2_size = $ - mxp_lzo_sig2
  1440.  
  1441. OnReload:
  1442.         cmp     [debuggee_pid], 0
  1443.         jnz     terminate_reload
  1444.         mov     esi, need_debuggee
  1445.         cmp     byte [loadname], 0
  1446.         jnz     do_reload
  1447.         jz      put_message
  1448. terminate_reload:
  1449.         mov     [bReload], 1
  1450. OnTerminate:
  1451.         mov     ecx, [debuggee_pid]
  1452.         push    8
  1453.         pop     ebx
  1454.         push    69
  1455.         pop     eax
  1456.         mcall
  1457.         ret
  1458.  
  1459. AfterSuspend:
  1460.         mov     [bSuspended], 1
  1461.         call    get_new_context
  1462.         call    get_dump
  1463.         call    redraw_title
  1464.         call    redraw_registers
  1465.         call    redraw_dump
  1466.         call    update_disasm_eip
  1467.         ret
  1468.  
  1469. OnSuspend:
  1470.         mov     ecx, [debuggee_pid]
  1471.         push    4
  1472.         pop     ebx
  1473.         push    69
  1474.         pop     eax
  1475.         mcall
  1476.         call    AfterSuspend
  1477.         mov     esi, aSuspended
  1478.         jmp     put_message
  1479. DoResume:
  1480.         mov     ecx, [debuggee_pid]
  1481.         push    5
  1482.         pop     ebx
  1483.         push    69
  1484.         pop     eax
  1485.         mcall
  1486.         mov     [bSuspended], 0
  1487.         ret
  1488. OnResume:
  1489.         mov     esi, [curarg]
  1490.         cmp     byte [esi], 0
  1491.         jz      GoOn
  1492.         call    calc_expression
  1493.         jc      .ret
  1494.         mov     eax, ebp
  1495.         push    eax
  1496.         call    find_enabled_breakpoint
  1497.         pop     eax
  1498.         jz      GoOn
  1499.         mov     bl, 5   ; valid enabled one-shot
  1500.         call    add_breakpoint
  1501.         jnc     GoOn
  1502.         mov     esi, aBreakpointLimitExceeded
  1503.         call    put_message
  1504. .ret:
  1505.         ret
  1506. GoOn:
  1507. ; test for enabled breakpoint at eip
  1508.         mov     eax, [_eip]
  1509.         call    find_enabled_breakpoint
  1510.         jnz     .nobreak
  1511. ; temporarily disable breakpoint, make step, enable breakpoint, continue
  1512.         inc     eax
  1513.         mov     [temp_break], eax
  1514.         mov     [bAfterGo], 1
  1515.         dec     eax
  1516.         call    disable_breakpoint
  1517.         call    get_context
  1518.         or      byte [_eflags+1], 1             ; set TF
  1519.         call    set_context
  1520.         and     byte [_eflags+1], not 1
  1521.         call    DoResume
  1522.         ret
  1523. .nobreak:
  1524.         call    DoResume
  1525.         call    redraw_title
  1526.         call    redraw_registers
  1527.         call    redraw_dump
  1528.         ret
  1529. OnDetach:
  1530.         mov     ecx, [debuggee_pid]
  1531.         push    3
  1532.         pop     ebx
  1533.         push    69
  1534.         pop     eax
  1535.         mcall
  1536.         and     [debuggee_pid], 0
  1537.         call    redraw_title
  1538.         call    redraw_registers
  1539.         call    redraw_dump
  1540.         call    free_symbols
  1541.         mov     esi, aContinued
  1542.         jmp     put_message
  1543.  
  1544. after_go_exception:
  1545.         push    eax
  1546.         mov     eax, [temp_break]
  1547.         dec     eax
  1548.         push    esi
  1549.         call    enable_breakpoint
  1550. ; in any case, clear TF and RF
  1551.         call    get_new_context
  1552.         and     [_eflags], not 10100h           ; clear TF,RF
  1553.         call    set_context
  1554.         xor     edx, edx
  1555.         mov     [temp_break], edx
  1556.         xchg    dl, [bAfterGo]
  1557.         pop     esi
  1558.         pop     eax
  1559.         cmp     dl, 2
  1560.         jnz     @f
  1561.         lodsd
  1562.         push    esi
  1563.         call    get_dump
  1564.         jmp     exception.done
  1565. @@:     test    eax, eax
  1566.         jz      .notint1
  1567. ; if exception is result of single step, simply ignore it and continue
  1568.         test    dword [esi], 0xF
  1569.         jnz     dbgmsgstart.5
  1570.         lodsd
  1571.         push    esi
  1572.         mov     esi, oldcontext
  1573.         mov     edi, context
  1574.         mov     ecx, 28h/4
  1575.         rep     movsd
  1576.         call    DoResume
  1577.         jmp     dbgmsgend
  1578. .notint1:
  1579. ; in other case, work as without temp_break
  1580.         lodsd
  1581.         push    esi
  1582.         push    eax
  1583.         jmp     exception.4
  1584. .notour:
  1585.  
  1586. debugmsg:
  1587.         neg     [dbgbufsize]
  1588.         mov     esi, dbgbuf
  1589. dbgmsgstart:
  1590.         lodsd
  1591. ;       push    eax esi
  1592. ;       push    dword [esi]
  1593. ;       mov     esi, dbgmsg_str
  1594. ;       call    put_message_nodraw
  1595. ;       pop     esi eax
  1596.         add     esi, 4
  1597.         dec     eax
  1598.         jz      exception
  1599.         dec     eax
  1600.         jz      terminated
  1601.         mov     [bSuspended], 1
  1602.         cmp     [bAfterGo], 0
  1603.         jnz     after_go_exception
  1604.         push    esi
  1605.         call    get_new_context
  1606.         and     [_eflags], not 10100h           ; clear TF,RF
  1607.         call    set_context
  1608.         pop     esi
  1609. .5:
  1610.         push    esi
  1611.         call    get_dump
  1612.         pop     esi
  1613.         lodsd
  1614.         xor     ecx, ecx
  1615. .6:
  1616.         bt      eax, ecx
  1617.         jnc     .7
  1618.         mov     ebx, [drx_break+ecx*4]
  1619.         test    ebx, ebx
  1620.         jz      .7
  1621.         pushad
  1622.         dec     ebx
  1623.         push    ebx
  1624.         mov     esi, aBreakStop
  1625.         call    put_message_nodraw
  1626.         popad
  1627. .7:
  1628.         inc     ecx
  1629.         cmp     cl, 4
  1630.         jb      .6
  1631.         push    esi
  1632.         jmp     exception.done_draw
  1633. terminated:
  1634.         push    esi
  1635.         mov     esi, terminated_msg
  1636.         call    put_message
  1637.         and     [debuggee_pid], 0
  1638.         and     [temp_break], 0
  1639.         mov     [bAfterGo], 0
  1640.         xor     eax, eax
  1641.         mov     ecx, breakpoints_n*6/4+4
  1642.         mov     edi, breakpoints
  1643.         rep     stosd
  1644.         cmp     [bReload], 1
  1645.         sbb     [bReload], -1
  1646.         jnz     exception.done
  1647.         call    free_symbols
  1648.         jmp     exception.done
  1649. exception:
  1650.         mov     [bSuspended], 1
  1651.         cmp     [bAfterGo], 0
  1652.         jnz     after_go_exception
  1653.         lodsd
  1654.         push    esi
  1655.         push    eax
  1656.         call    get_new_context
  1657.         and     [_eflags], not 10100h           ; clear TF,RF
  1658.         call    set_context
  1659. .4:
  1660.         call    get_dump
  1661.         pop     eax
  1662. ; int3 command generates exception 0D, #GP
  1663.         push    eax
  1664.         cmp     al, 0Dh
  1665.         jnz     .notdbg
  1666. ; check for 0xCC byte at eip
  1667.         push    0
  1668.         push    69
  1669.         pop     eax
  1670.         push    6
  1671.         pop     ebx
  1672.         mov     ecx, [debuggee_pid]
  1673.         mov     edi, esp
  1674.         mov     esi, [_eip]
  1675.         push    1
  1676.         pop     edx
  1677.         mcall
  1678.         pop     eax
  1679.         cmp     al, 0xCC
  1680.         jnz     .notdbg
  1681. ; this is either dbg breakpoint or int3 cmd in debuggee
  1682.         mov     eax, [_eip]
  1683.         call    find_enabled_breakpoint
  1684.         jnz     .user_int3
  1685. ; dbg breakpoint; clear if one-shot
  1686.         pop     ecx
  1687.         push    eax
  1688.         mov     esi, aBreakStop
  1689.         test    byte [edi+4], 4
  1690.         jz      .put_msg_eax
  1691.         pop     ecx
  1692.         call    clear_breakpoint
  1693.         jmp     .done
  1694. .user_int3:
  1695.         mov     eax, [_eip]
  1696.         inc     [_eip]
  1697.         pop     ecx
  1698.         push    eax
  1699.         call    set_context
  1700.         mov     esi, aUserBreak
  1701.         jmp     .put_msg_eax
  1702. .notdbg:
  1703.         mov     esi, aException
  1704. .put_msg_eax:
  1705.         call    put_message_nodraw
  1706. .done_draw:
  1707.         call    draw_messages
  1708. .done:
  1709.         push    18
  1710.         pop     eax
  1711.         push    3
  1712.         pop     ebx
  1713.         mov     ecx, [dbgwnd]
  1714.         mcall   ; activate dbg window
  1715.         call    redraw_title
  1716.         call    redraw_registers
  1717.         call    redraw_dump
  1718.         call    update_disasm_eip
  1719. dbgmsgend:
  1720.         pop     esi
  1721.         mov     ecx, [dbgbuflen]
  1722.         add     ecx, dbgbuf
  1723.         cmp     esi, ecx
  1724.         jnz     dbgmsgstart
  1725.         and     [dbgbuflen], 0
  1726.         neg     [dbgbufsize]
  1727.         cmp     [bReload], 2
  1728.         jnz     @f
  1729.         mov     [bReload], 0
  1730.         call    do_reload
  1731. @@:
  1732.         jmp     waitevent
  1733.  
  1734. CtrlF7:
  1735.         cmp     [debuggee_pid], 0
  1736.         jz      .no
  1737.         call    OnStep
  1738. .no:
  1739.         jmp     waitevent
  1740. CtrlF8:
  1741.         cmp     [debuggee_pid], 0
  1742.         jz      CtrlF7.no
  1743.         call    OnProceed
  1744.         jmp     CtrlF7.no
  1745.  
  1746. OnStep:
  1747.         cmp     [bSuspended], 0
  1748.         jz      .running
  1749.         call    get_context
  1750.         or      byte [_eflags+1], 1             ; set TF
  1751.         call    set_context
  1752.         and     byte [_eflags+1], not 1
  1753. ; if instruction at eip is "int xx", set one-shot breakpoint immediately after
  1754.         mov     eax, [_eip]
  1755.         call    find_enabled_breakpoint
  1756.         jnz     @f
  1757.         cmp     byte [edi+5], 0xCD
  1758.         jz      .int
  1759. @@:
  1760.         push    0
  1761.         push    69
  1762.         pop     eax
  1763.         push    6
  1764.         pop     ebx
  1765.         mov     ecx, [debuggee_pid]
  1766.         push    3
  1767.         pop     edx
  1768.         mov     edi, esp
  1769.         mov     esi, [_eip]
  1770.         mcall
  1771.         cmp     eax, edx
  1772.         pop     eax
  1773.         jnz     .doit
  1774.         cmp     al, 0xCD
  1775.         jz      .int
  1776.         cmp     ax, 0x050F
  1777.         jz      .syscall
  1778.         cmp     ax, 0x340F
  1779.         jz      .sysenter
  1780. ; resume process
  1781. .doit:
  1782.         call    GoOn
  1783.         cmp     [bAfterGo], 0
  1784.         jz      @f
  1785.         mov     [bAfterGo], 2
  1786. @@:
  1787.         ret
  1788. .sysenter:      ; return address is [ebp-4]
  1789.         push    0
  1790.         push    69
  1791.         pop     eax
  1792.         inc     edx     ; read 4 bytes
  1793.         mov     esi, [_ebp]
  1794.         sub     esi, 4
  1795.         mcall
  1796.         cmp     eax, edx
  1797.         pop     eax
  1798.         jnz     .syscall
  1799.         push    eax
  1800.         and     byte [_eflags+1], not 1
  1801.         call    set_context
  1802.         pop     eax
  1803.         jmp     @f
  1804. .syscall:
  1805.         and     byte [_eflags+1], not 1 ; clear TF - avoid system halt (!)
  1806.         call    set_context
  1807. .int:
  1808.         mov     eax, [_eip]
  1809.         inc     eax
  1810.         inc     eax
  1811. @@:
  1812.         push    eax
  1813.         call    find_enabled_breakpoint
  1814.         pop     eax
  1815.         jz      .doit
  1816. ; there is no enabled breakpoint yet; set temporary breakpoint
  1817.         mov     bl, 5
  1818.         call    add_breakpoint
  1819.         jmp     .doit
  1820. .running:
  1821.         mov     esi, aRunningErr
  1822.         jmp     put_message
  1823.  
  1824. OnProceed:
  1825.         cmp     [bSuspended], 0
  1826.         jz      OnStep.running
  1827.         mov     esi, [_eip]
  1828. @@:
  1829.         call    get_byte_nobreak
  1830.         jc      OnStep
  1831.         inc     esi
  1832. ; skip prefixes
  1833.         call    is_prefix
  1834.         jz      @b
  1835.         cmp     al, 0xE8        ; call
  1836.         jnz     @f
  1837.         add     esi, 4
  1838.         jmp     .doit
  1839. @@:     ; A4,A5 = movs, A6,A7=cmps
  1840.         cmp     al, 0xA4
  1841.         jb      @f
  1842.         cmp     al, 0xA8
  1843.         jb      .doit
  1844. @@:     ; AA,AB=stos, AC,AD=lods, AE,AF=scas
  1845.         cmp     al, 0xAA
  1846.         jb      @f
  1847.         cmp     al, 0xB0
  1848.         jb      .doit
  1849. @@:     ; E0=loopnz,E1=loopz,E2=loop
  1850.         cmp     al, 0xE0
  1851.         jb      .noloop
  1852.         cmp     al, 0xE2
  1853.         ja      .noloop
  1854.         inc     esi
  1855.         jmp     .doit
  1856. .noloop:        ; FF /2 = call
  1857.         cmp     al, 0xFF
  1858.         jnz     OnStep
  1859.         call    get_byte_nobreak
  1860.         jc      OnStep
  1861.         inc     esi
  1862.         mov     cl, al
  1863.         and     al, 00111000b
  1864.         cmp     al, 00010000b
  1865.         jnz     OnStep
  1866. ; skip instruction
  1867.         mov     al, cl
  1868.         and     eax, 7
  1869.         shr     cl, 6
  1870.         jz      .mod0
  1871.         jp      .doit
  1872.         cmp     al, 4
  1873.         jnz     @f
  1874.         inc     esi
  1875. @@:
  1876.         inc     esi
  1877.         dec     cl
  1878.         jz      @f
  1879.         add     esi, 3
  1880. @@:
  1881.         jmp     .doit
  1882. .mod0:
  1883.         cmp     al, 4
  1884.         jnz     @f
  1885.         call    get_byte_nobreak
  1886.         jc      OnStep
  1887.         inc     esi
  1888.         and     al, 7
  1889. @@:
  1890.         cmp     al, 5
  1891.         jnz     .doit
  1892.         add     esi, 4
  1893. .doit:
  1894. ; insert one-shot breakpoint at esi and resume
  1895.         call    get_byte_nobreak
  1896.         jc      OnStep
  1897.         mov     eax, esi
  1898.         call    find_enabled_breakpoint
  1899.         jz      .ret
  1900.         mov     eax, esi
  1901.         mov     bl, 5
  1902.         call    add_breakpoint
  1903.         jmp     OnStep.doit
  1904. .ret:
  1905.         ret
  1906.  
  1907. get_byte_nobreak:
  1908.         mov     eax, esi
  1909.         call    find_enabled_breakpoint
  1910.         jnz     .nobreak
  1911.         mov     al, [edi+5]
  1912.         clc
  1913.         ret
  1914. .nobreak:
  1915.         push    69
  1916.         pop     eax
  1917.         push    6
  1918.         pop     ebx
  1919.         mov     ecx, [debuggee_pid]
  1920.         xor     edx, edx
  1921.         push    edx
  1922.         inc     edx
  1923.         mov     edi, esp
  1924.         mcall
  1925.         dec     eax
  1926.         clc
  1927.         jz      @f
  1928.         stc
  1929. @@:     pop     eax
  1930.         ret
  1931.  
  1932. is_prefix:
  1933.         cmp     al, 0x64        ; fs:
  1934.         jz      .ret
  1935.         cmp     al, 0x65        ; gs:
  1936.         jz      .ret
  1937.         cmp     al, 0x66        ; use16/32
  1938.         jz      .ret
  1939.         cmp     al, 0x67        ; addr16/32
  1940.         jz      .ret
  1941.         cmp     al, 0xF0        ; lock
  1942.         jz      .ret
  1943.         cmp     al, 0xF2        ; repnz
  1944.         jz      .ret
  1945.         cmp     al, 0xF3        ; rep(z)
  1946.         jz      .ret
  1947.         cmp     al, 0x2E        ; cs:
  1948.         jz      .ret
  1949.         cmp     al, 0x36        ; ss:
  1950.         jz      .ret
  1951.         cmp     al, 0x3E        ; ds:
  1952.         jz      .ret
  1953.         cmp     al, 0x26        ; es:
  1954. .ret:   ret
  1955.  
  1956. token_end       equ     1
  1957. token_reg       equ     2
  1958. token_hex       equ     3
  1959. token_add       equ     4
  1960. token_sub       equ     5
  1961. token_mul       equ     6
  1962. token_div       equ     7
  1963. token_lp        equ     8
  1964. token_rp        equ     9
  1965. token_err       equ     -1
  1966.  
  1967. is_hex_digit:
  1968.         cmp     al, '0'
  1969.         jb      .no
  1970.         cmp     al, '9'
  1971.         jbe     .09
  1972.         cmp     al, 'A'
  1973.         jb      .no
  1974.         cmp     al, 'F'
  1975.         jbe     .AF
  1976.         cmp     al, 'a'
  1977.         jb      .no
  1978.         cmp     al, 'f'
  1979.         jbe     .af
  1980. .no:
  1981.         stc
  1982.         ret
  1983. .09:
  1984.         sub     al, '0'
  1985. ;       clc
  1986.         ret
  1987. .AF:
  1988.         sub     al, 'A'-10
  1989. ;       clc
  1990.         ret
  1991. .af:
  1992.         sub     al, 'a'-10
  1993. ;       clc
  1994.         ret
  1995.  
  1996. find_reg:
  1997.         mov     edi, reg_table
  1998. .findreg:
  1999.         movzx   ecx, byte [edi]
  2000.         stc
  2001.         jecxz   .regnotfound
  2002.         inc     edi
  2003.         push    esi edi ecx
  2004. @@:
  2005.         lodsb
  2006.         or      al, 20h
  2007.         scasb
  2008.         loopz   @b
  2009.         pop     ecx edi esi
  2010.         lea     edi, [edi+ecx+1]
  2011.         jnz     .findreg
  2012.         movzx   edi, byte [edi-1]
  2013.         add     esi, ecx
  2014. .regnotfound:
  2015.         ret
  2016.  
  2017. expr_get_token:
  2018.         lodsb
  2019.         cmp     al, 0
  2020.         jz      .end_token
  2021.         cmp     al, ' '
  2022.         jbe     expr_get_token
  2023.         cmp     al, '+'
  2024.         jz      .add
  2025.         cmp     al, '-'
  2026.         jz      .sub
  2027.         cmp     al, '*'
  2028.         jz      .mul
  2029.         cmp     al, '/'
  2030.         jz      .div
  2031.         cmp     al, '('
  2032.         jz      .lp
  2033.         cmp     al, ')'
  2034.         jnz     .notsign
  2035. .rp:
  2036.         mov     al, token_rp
  2037.         ret
  2038. .div:
  2039.         mov     al, token_div
  2040.         ret
  2041. .end_token:
  2042.         mov     al, token_end
  2043.         ret
  2044. .add:
  2045.         mov     al, token_add
  2046.         ret
  2047. .sub:
  2048.         mov     al, token_sub
  2049.         ret
  2050. .mul:
  2051.         mov     al, token_mul
  2052.         ret
  2053. .lp:
  2054.         mov     al, token_lp
  2055.         ret
  2056. .notsign:
  2057.         dec     esi
  2058.         call    find_reg
  2059.         jc      .regnotfound
  2060.         mov     al, token_reg
  2061.         ret
  2062. .regnotfound:
  2063. ; test for symbol
  2064.         push    esi
  2065. @@:
  2066.         lodsb
  2067.         cmp     al, ' '
  2068.         ja      @b
  2069.         push    eax
  2070.         mov     byte [esi], 0
  2071.         xchg    esi, [esp+4]
  2072.         call    find_symbol_name
  2073.         mov     edi, eax
  2074.         pop     eax
  2075.         xchg    esi, [esp]
  2076.         mov     byte [esi], al
  2077.         jc      @f
  2078.         add     esp, 4
  2079.         mov     al, token_hex
  2080.         ret
  2081. @@:
  2082.         pop     esi
  2083. ; test for hex number
  2084.         xor     ecx, ecx
  2085.         xor     edi, edi
  2086.         xor     eax, eax
  2087. @@:
  2088.         lodsb
  2089.         call    is_hex_digit
  2090.         jc      @f
  2091.         shl     edi, 4
  2092.         or      edi, eax
  2093.         inc     ecx
  2094.         jmp     @b
  2095. @@:
  2096.         dec     esi
  2097.         jecxz   .err
  2098.         cmp     ecx, 8
  2099.         ja      .err
  2100.         mov     al, token_hex
  2101.         ret
  2102. .err:
  2103.         mov     al, token_err
  2104.         mov     esi, aParseError
  2105.         ret
  2106.  
  2107. expr_read2:
  2108.         cmp     al, token_hex
  2109.         jz      .hex
  2110.         cmp     al, token_reg
  2111.         jz      .reg
  2112.         cmp     al, token_lp
  2113.         jz      .lp
  2114.         mov     al, token_err
  2115.         mov     esi, aParseError
  2116.         ret
  2117. .hex:
  2118.         mov     ebp, edi
  2119. .ret:
  2120.         jmp     expr_get_token
  2121. .reg:
  2122.         cmp     edi, 24
  2123.         jz      .eip
  2124.         sub     edi, 4
  2125.         jb      .8lo
  2126.         sub     edi, 4
  2127.         jb      .8hi
  2128.         sub     edi, 8
  2129.         jb      .16
  2130.         mov     ebp, [_eax+edi*4]
  2131.         jmp     .ret
  2132. .16:
  2133.         movzx   ebp, word [_eax+(edi+8)*4]
  2134.         jmp     .ret
  2135. .8lo:
  2136.         movzx   ebp, byte [_eax+(edi+4)*4]
  2137.         jmp     .ret
  2138. .8hi:
  2139.         movzx   ebp, byte [_eax+(edi+4)*4+1]
  2140.         jmp     .ret
  2141. .eip:
  2142.         mov     ebp, [_eip]
  2143.         jmp     .ret
  2144. .lp:
  2145.         call    expr_get_token
  2146.         call    expr_read0
  2147.         cmp     al, token_err
  2148.         jz      @f
  2149.         cmp     al, token_rp
  2150.         jz      expr_get_token
  2151.         mov     al, token_err
  2152.         mov     esi, aParseError
  2153. @@:     ret
  2154.  
  2155. expr_read1:
  2156.         call    expr_read2
  2157. .1:
  2158.         cmp     al, token_mul
  2159.         jz      .mul
  2160.         cmp     al, token_div
  2161.         jz      .div
  2162.         ret
  2163. .mul:
  2164.         push    ebp
  2165.         call    expr_get_token
  2166.         call    expr_read2
  2167.         pop     edx
  2168. ; ebp := edx*ebp
  2169.         imul    ebp, edx
  2170.         jmp     .1
  2171. .div:
  2172.         push    ebp
  2173.         call    expr_get_token
  2174.         call    expr_read2
  2175.         pop     edx
  2176. ; ebp := edx/ebp
  2177.         test    ebp, ebp
  2178.         jz      .div0
  2179.         push    eax
  2180.         xor     eax, eax
  2181.         xchg    eax, edx
  2182.         div     ebp
  2183.         xchg    eax, ebp
  2184.         pop     eax
  2185.         jmp     .1
  2186. .div0:
  2187.         mov     al, token_err
  2188.         mov     esi, aDivByZero
  2189.         ret
  2190.  
  2191. expr_read0:
  2192.         xor     ebp, ebp
  2193.         cmp     al, token_add
  2194.         jz      .add
  2195.         cmp     al, token_sub
  2196.         jz      .sub
  2197.         call    expr_read1
  2198. .1:
  2199.         cmp     al, token_add
  2200.         jz      .add
  2201.         cmp     al, token_sub
  2202.         jz      .sub
  2203.         ret
  2204. .add:
  2205.         push    ebp
  2206.         call    expr_get_token
  2207.         call    expr_read1
  2208.         pop     edx
  2209. ; ebp := edx+ebp
  2210.         add     ebp, edx
  2211.         jmp     .1
  2212. .sub:
  2213.         push    ebp
  2214.         call    expr_get_token
  2215.         call    expr_read1
  2216.         pop     edx
  2217. ; ebp := edx-ebp
  2218.         xchg    edx, ebp
  2219.         sub     ebp, edx
  2220.         jmp     .1
  2221.  
  2222. calc_expression:
  2223. ; in: esi->expression
  2224. ; out: CF=1 if error
  2225. ;      CF=0 and ebp=value if ok
  2226.         call    expr_get_token
  2227.         call    expr_read0
  2228.         cmp     al, token_end
  2229.         jz      .end
  2230.         cmp     al, token_err
  2231.         jz      @f
  2232.         mov     esi, aParseError
  2233. @@:
  2234.         call    put_message
  2235.         stc
  2236.         ret
  2237. .end:
  2238.         clc
  2239.         ret
  2240.  
  2241. OnCalc:
  2242.         mov     esi, [curarg]
  2243.         call    calc_expression
  2244.         jc      .ret
  2245.         push    ebp
  2246.         mov     esi, calc_string
  2247.         call    put_message_nodraw
  2248.         jmp     draw_messages
  2249. .ret:
  2250.         ret
  2251.  
  2252. OnDump:
  2253.         mov     esi, [curarg]
  2254.         cmp     byte [esi], 0
  2255.         jnz     .param
  2256.         add     [dumppos], dump_height*10h
  2257.         jmp     .doit
  2258. .param:
  2259.         call    calc_expression
  2260.         jc      .ret
  2261.         mov     [dumppos], ebp
  2262. .doit:
  2263.         call    get_dump
  2264.         call    redraw_dump
  2265. .ret:
  2266.         ret
  2267.  
  2268. OnUnassemble:
  2269.         mov     esi, [curarg]
  2270.         cmp     byte [esi], 0
  2271.         jnz     .param
  2272.         mov     eax, [disasm_start_pos]
  2273.         mov     ecx, disasm_height
  2274.         mov     [disasm_cur_pos], eax
  2275. .l:
  2276.         mov     eax, [disasm_cur_pos]
  2277.         call    find_symbol
  2278.         jc      @f
  2279.         dec     ecx
  2280.         jz      .m
  2281. @@:
  2282.         push    ecx
  2283.         call    disasm_instr
  2284.         pop     ecx
  2285.         jc      .err
  2286.         loop    .l
  2287. .m:
  2288.         mov     eax, [disasm_cur_pos]
  2289.         jmp     .doit
  2290. .param:
  2291.         call    calc_expression
  2292.         jc      .ret
  2293.         mov     eax, ebp
  2294. .doit:
  2295.         push    eax
  2296.         push    [disasm_start_pos]
  2297.         mov     [disasm_start_pos], eax
  2298.         call    update_disasm
  2299.         pop     [disasm_start_pos]
  2300.         pop     eax
  2301.         cmp     [disasm_cur_str], 0
  2302.         jz      @f
  2303.         mov     [disasm_start_pos], eax
  2304. .ret:
  2305.         ret
  2306. @@:
  2307.         call    update_disasm
  2308. .err:
  2309.         mov     esi, aInvAddr
  2310.         jmp     put_message
  2311.  
  2312. OnReg:
  2313.         mov     esi, [curarg]
  2314.         call    skip_spaces
  2315.         call    find_reg
  2316.         jnc     @f
  2317. .err:
  2318.         mov     esi, RSyntax
  2319.         jmp     put_message
  2320. @@:
  2321.         call    skip_spaces
  2322.         test    al, al
  2323.         jz      .err
  2324.         cmp     al, '='
  2325.         jnz     @f
  2326.         inc     esi
  2327.         call    skip_spaces
  2328.         test    al, al
  2329.         jz      .err
  2330. @@:
  2331.         push    edi
  2332.         call    calc_expression
  2333.         pop     edi
  2334.         jc      .ret
  2335. ; now edi=register id, ebp=value
  2336.         cmp     [bSuspended], 0
  2337.         mov     esi, aRunningErr
  2338.         jz      put_message
  2339.         xchg    eax, ebp
  2340.         cmp     edi, 24
  2341.         jz      .eip
  2342.         sub     edi, 4
  2343.         jb      .8lo
  2344.         sub     edi, 4
  2345.         jb      .8hi
  2346.         sub     edi, 8
  2347.         jb      .16
  2348.         mov     [_eax+edi*4], eax
  2349.         jmp     .ret
  2350. .16:
  2351.         mov     word [_eax+(edi+8)*4], ax
  2352.         jmp     .ret
  2353. .8lo:
  2354.         mov     byte [_eax+(edi+4)*4], al
  2355.         jmp     .ret
  2356. .8hi:
  2357.         mov     byte [_eax+(edi+4)*4+1], al
  2358.         jmp     .ret
  2359. .eip:
  2360.         mov     [_eip], eax
  2361.         call    update_disasm_eip
  2362. .ret:
  2363.         call    set_context
  2364.         jmp     redraw_registers
  2365.  
  2366. ; Breakpoints manipulation
  2367. OnBp:
  2368.         mov     esi, [curarg]
  2369.         call    calc_expression
  2370.         jc      .ret
  2371.         xchg    eax, ebp
  2372.         push    eax
  2373.         call    find_breakpoint
  2374.         inc     eax
  2375.         pop     eax
  2376.         jz      .notfound
  2377.         mov     esi, aDuplicateBreakpoint
  2378.         jmp     .sayerr
  2379. .notfound:
  2380.         mov     bl, 1
  2381.         call    add_breakpoint
  2382.         jnc     .ret
  2383.         mov     esi, aBreakpointLimitExceeded
  2384. .sayerr:
  2385.         call    put_message
  2386. .ret:
  2387.         jmp     redraw_disasm
  2388.  
  2389. OnBpmb:
  2390.         mov     dh, 0011b
  2391.         jmp     DoBpm
  2392. OnBpmw:
  2393.         mov     dh, 0111b
  2394.         jmp     DoBpm
  2395. OnBpmd:
  2396.         mov     dh, 1111b
  2397. DoBpm:
  2398.         mov     esi, [curarg]
  2399.         cmp     byte [esi], 'w'
  2400.         jnz     @f
  2401.         and     dh, not 2
  2402.         inc     esi
  2403. @@:
  2404.         push    edx
  2405.         call    calc_expression
  2406.         pop     edx
  2407.         jnc     @f
  2408.         ret
  2409. @@:
  2410. ; ebp=expression, dh=flags
  2411.         movzx   eax, dh
  2412.         shr     eax, 2
  2413.         test    ebp, eax
  2414.         jz      @f
  2415.         mov     esi, aUnaligned
  2416.         jmp     put_message
  2417. @@:
  2418.         mov     eax, ebp
  2419.         mov     bl, 0Bh
  2420.         call    add_breakpoint
  2421.         jnc     @f
  2422.         mov     esi, aBreakpointLimitExceeded
  2423.         jmp     put_message
  2424. @@:
  2425. ; now find index
  2426.         push    eax
  2427.         xor     ecx, ecx
  2428. .l1:
  2429.         cmp     [drx_break+ecx*4], 0
  2430.         jnz     .l2
  2431.         push    69
  2432.         pop     eax
  2433.         push    ecx
  2434.         mov     dl, cl
  2435.         mov     ecx, [debuggee_pid]
  2436.         mov     esi, ebp
  2437.         push    9
  2438.         pop     ebx
  2439.         mcall
  2440.         test    eax, eax
  2441.         jz      .ok
  2442.         pop     ecx
  2443. .l2:
  2444.         inc     ecx
  2445.         cmp     ecx, 4
  2446.         jb      .l1
  2447.         pop     eax
  2448.         call    clear_breakpoint
  2449.         mov     esi, aBreakpointLimitExceeded
  2450.         jmp     put_message
  2451. .ok:
  2452.         pop     ecx
  2453.         pop     eax
  2454.         and     byte [edi], not 2       ; breakpoint is enabled
  2455.         shl     dl, 6
  2456.         or      dl, dh
  2457.         mov     byte [edi+1], dl
  2458.         inc     eax
  2459.         mov     [drx_break+ecx*4], eax
  2460.         ret
  2461.  
  2462. OnBc:
  2463.         mov     esi, [curarg]
  2464. @@:     call    get_hex_number
  2465.         jc      OnBp.ret
  2466.         call    clear_breakpoint
  2467.         jmp     @b
  2468.  
  2469. OnBd:
  2470.         mov     esi, [curarg]
  2471. @@:     call    get_hex_number
  2472.         jc      OnBp.ret
  2473.         call    disable_breakpoint
  2474.         jmp     @b
  2475.  
  2476. OnBe:
  2477.         mov     esi, [curarg]
  2478. @@:     call    get_hex_number
  2479.         jc      OnBp.ret
  2480.         push    eax
  2481.         call    find_enabled_breakpoint
  2482.         pop     eax
  2483.         jz      .err
  2484.         call    enable_breakpoint
  2485.         jmp     @b
  2486. .err:
  2487.         mov     esi, OnBeErrMsg
  2488.         jmp     put_message
  2489.  
  2490. get_hex_number:
  2491.         call    skip_spaces
  2492.         xor     ecx, ecx
  2493.         xor     edx, edx
  2494. @@:
  2495.         lodsb
  2496.         call    is_hex_digit
  2497.         jc      .ret
  2498.         shl     edx, 4
  2499.         or      dl, al
  2500.         inc     ecx
  2501.         jmp     @b
  2502. .ret:
  2503.         dec     esi
  2504.         cmp     ecx, 1
  2505.         xchg    eax, edx
  2506.         ret
  2507.  
  2508. OnBl:
  2509.         mov     esi, [curarg]
  2510.         cmp     byte [esi], 0
  2511.         jz      .listall
  2512.         call    get_hex_number
  2513.         jc      .ret
  2514.         cmp     eax, breakpoints_n
  2515.         jae     .err
  2516.         push    eax
  2517.         add     eax, eax
  2518.         lea     edi, [breakpoints + eax + eax*2]
  2519.         pop     eax
  2520.         test    byte [edi+4], 1
  2521.         jz      .err
  2522.         call    show_break_info
  2523. .ret:
  2524.         ret
  2525. .err:
  2526.         mov     esi, aInvalidBreak
  2527.         jmp     put_message
  2528. .listall:
  2529.         mov     edi, breakpoints
  2530.         xor     eax, eax
  2531. @@:
  2532.         test    byte [edi+4], 1
  2533.         jz      .cont
  2534.         push    edi eax
  2535.         call    show_break_info
  2536.         pop     eax edi
  2537. .cont:
  2538.         add     edi, 6
  2539.         inc     eax
  2540.         cmp     eax, breakpoints_n
  2541.         jb      @b
  2542.         ret
  2543.  
  2544. show_break_info:
  2545.         push    edi
  2546.         test    byte [edi+4], 8
  2547.         jnz     .dr
  2548.         push    dword [edi]
  2549.         push    eax
  2550.         mov     esi, aBreakNum
  2551.         call    put_message_nodraw
  2552.         jmp     .cmn
  2553. .dr:
  2554.         push    eax
  2555.         mov     esi, aMemBreak1
  2556.         call    put_message_nodraw
  2557.         pop     edi
  2558.         push    edi
  2559.         mov     esi, aMemBreak2
  2560.         test    byte [edi+5], 2
  2561.         jz      @f
  2562.         mov     esi, aMemBreak3
  2563. @@:
  2564.         call    put_message_nodraw
  2565.         pop     edi
  2566.         push    edi
  2567.         mov     esi, aMemBreak6
  2568.         test    byte [edi+5], 8
  2569.         jnz     @f
  2570.         mov     esi, aMemBreak5
  2571.         test    byte [edi+5], 4
  2572.         jnz     @f
  2573.         mov     esi, aMemBreak4
  2574. @@:
  2575.         call    put_message_nodraw
  2576.         pop     edi
  2577.         push    edi
  2578.         push    dword [edi]
  2579.         mov     esi, aMemBreak7
  2580.         call    put_message_nodraw
  2581. .cmn:
  2582.         pop     edi
  2583.         test    byte [edi+4], 2
  2584.         jz      @f
  2585.         push    edi
  2586.         mov     esi, aDisabled
  2587.         call    put_message_nodraw
  2588.         pop     edi
  2589. @@:
  2590.         test    byte [edi+4], 4
  2591.         jz      @f
  2592.         mov     esi, aOneShot
  2593.         call    put_message_nodraw
  2594. @@:
  2595.         mov     esi, newline
  2596.         jmp     put_message
  2597.  
  2598. add_breakpoint:
  2599. ; in: eax=address, bl=flags
  2600. ; out: CF=1 => error, CF=0 => eax=breakpoint number
  2601.         xor     ecx, ecx
  2602.         mov     edi, breakpoints
  2603. @@:
  2604.         test    byte [edi+4], 1
  2605.         jz      .found
  2606.         add     edi, 6
  2607.         inc     ecx
  2608.         cmp     ecx, breakpoints_n
  2609.         jb      @b
  2610.         stc
  2611.         ret
  2612. .found:
  2613.         stosd
  2614.         xchg    eax, ecx
  2615.         mov     [edi], bl
  2616.         test    bl, 2
  2617.         jnz     @f
  2618.         or      byte [edi], 2
  2619.         push    eax
  2620.         call    enable_breakpoint
  2621.         pop     eax
  2622. @@:
  2623.         clc
  2624.         ret
  2625.  
  2626. clear_breakpoint:
  2627.         cmp     eax, breakpoints_n
  2628.         jae     .ret
  2629.         mov     ecx, 4
  2630.         inc     eax
  2631. .1:
  2632.         cmp     [drx_break-4+ecx*4], eax
  2633.         jnz     @f
  2634.         and     [drx_break-4+ecx*4], 0
  2635. @@:     loop    .1
  2636.         dec     eax
  2637.         push    eax
  2638.         add     eax, eax
  2639.         lea     edi, [breakpoints + eax + eax*2 + 4]
  2640.         test    byte [edi], 1
  2641.         pop     eax
  2642.         jz      .ret
  2643.         push    edi
  2644.         call    disable_breakpoint
  2645.         pop     edi
  2646.         mov     byte [edi], 0
  2647. .ret:
  2648.         ret
  2649.  
  2650. disable_breakpoint:
  2651.         cmp     eax, breakpoints_n
  2652.         jae     .ret
  2653.         add     eax, eax
  2654.         lea     edi, [breakpoints + eax + eax*2 + 5]
  2655.         test    byte [edi-1], 1
  2656.         jz      .ret
  2657.         test    byte [edi-1], 2
  2658.         jnz     .ret
  2659.         or      byte [edi-1], 2
  2660.         test    byte [edi-1], 8
  2661.         jnz     .dr
  2662.         push    esi
  2663.         push    7
  2664.         pop     ebx
  2665.         push    69
  2666.         pop     eax
  2667.         mov     ecx, [debuggee_pid]
  2668.         xor     edx, edx
  2669.         inc     edx
  2670.         mov     esi, [edi-5]
  2671.         mcall
  2672.         pop     esi
  2673. .ret:
  2674.         ret
  2675. .dr:
  2676.         mov     dl, [edi]
  2677.         shr     dl, 6
  2678.         mov     dh, 80h
  2679.         push    69
  2680.         pop     eax
  2681.         push    9
  2682.         pop     ebx
  2683.         mov     ecx, [debuggee_pid]
  2684.         mcall
  2685.         ret
  2686.  
  2687. enable_breakpoint:
  2688.         push    esi
  2689.         cmp     eax, breakpoints_n
  2690.         jae     .ret
  2691.         add     eax, eax
  2692.         lea     edi, [breakpoints + eax + eax*2 + 5]
  2693.         test    byte [edi-1], 1
  2694.         jz      .ret
  2695.         test    byte [edi-1], 2
  2696.         jz      .ret
  2697.         and     byte [edi-1], not 2
  2698.         test    byte [edi-1], 8
  2699.         jnz     .dr
  2700.         push    6
  2701.         pop     ebx
  2702.         push    69
  2703.         pop     eax
  2704.         mov     esi, [edi-5]
  2705.         mov     ecx, [debuggee_pid]
  2706.         xor     edx, edx
  2707.         inc     edx
  2708.         mcall
  2709.         dec     eax
  2710.         jnz     .err
  2711.         mov     al, 69
  2712.         push    0xCC
  2713.         mov     edi, esp
  2714.         inc     ebx
  2715.         mcall
  2716.         pop     eax
  2717. .ret:
  2718.         pop     esi
  2719.         ret
  2720. .err:
  2721.         or      byte [edi-1], 2
  2722.         mov     esi, aBreakErr
  2723.         call    put_message
  2724.         pop     esi
  2725.         ret
  2726. .dr:
  2727.         push    9
  2728.         pop     ebx
  2729.         push    69
  2730.         pop     eax
  2731.         mov     esi, [edi-5]
  2732.         mov     ecx, [debuggee_pid]
  2733.         mov     dl, [edi]
  2734.         shr     dl, 6
  2735.         mov     dh, [edi]
  2736.         and     dh, 0xF
  2737.         mcall
  2738.         test    eax, eax
  2739.         jnz     .err
  2740.         pop     esi
  2741.         ret
  2742.  
  2743. find_breakpoint:
  2744.         xor     ecx, ecx
  2745.         xchg    eax, ecx
  2746.         mov     edi, breakpoints
  2747. @@:
  2748.         test    byte [edi+4], 1
  2749.         jz      .cont
  2750.         test    byte [edi+4], 8
  2751.         jnz     .cont
  2752.         cmp     [edi], ecx
  2753.         jz      .found
  2754. .cont:
  2755.         add     edi, 6
  2756.         inc     eax
  2757.         cmp     eax, breakpoints_n
  2758.         jb      @b
  2759.         or      eax, -1
  2760. .found:
  2761.         ret
  2762.  
  2763. find_enabled_breakpoint:
  2764.         xor     ecx, ecx
  2765.         xchg    eax, ecx
  2766.         mov     edi, breakpoints
  2767. @@:
  2768.         test    byte [edi+4], 1
  2769.         jz      .cont
  2770.         test    byte [edi+4], 2 or 8
  2771.         jnz     .cont
  2772.         cmp     [edi], ecx
  2773.         jz      .found
  2774. .cont:
  2775.         add     edi, 6
  2776.         inc     eax
  2777.         cmp     eax, breakpoints_n
  2778.         jb      @b
  2779.         or      eax, -1
  2780. .found:
  2781.         ret
  2782.  
  2783. OnUnpack:
  2784. ; program must be loaded - checked when command was parsed
  2785. ; program must be stopped
  2786.         mov     esi, aRunningErr
  2787.         cmp     [bSuspended], 0
  2788.         jz      put_message
  2789. ; all breakpoints must be disabled
  2790.         mov     edi, breakpoints
  2791. @@:
  2792.         test    byte [edi+4], 1
  2793.         jz      .cont
  2794.         test    byte [edi+4], 2
  2795.         jnz     .cont
  2796.         mov     esi, aEnabledBreakErr
  2797.         jmp     put_message
  2798. .cont:
  2799.         add     edi, 6
  2800.         cmp     edi, breakpoints+breakpoints_n*6
  2801.         jb      @b
  2802. ; ok, now do it
  2803. ; set breakpoint on 0xC dword access
  2804.         push    9
  2805.         pop     ebx
  2806.         mov     ecx, [debuggee_pid]
  2807.         mov     dx, 1111b*256
  2808.         push    0xC
  2809.         pop     esi
  2810. @@:
  2811.         push    69
  2812.         pop     eax
  2813.         mcall
  2814.         test    eax, eax
  2815.         jz      .breakok
  2816.         inc     edx
  2817.         cmp     dl, 4
  2818.         jb      @b
  2819. .breakok:
  2820.         call    GoOn
  2821. ; now wait for event
  2822. .wait: