WebSVN – Kolibri OS – Diff – /programs/develop/mtdbg/gui.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; GUI ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
macro DrawRectangle x, y, w, h, color
{
        mcall 13, x shl 16 + w,     y shl 16 + 1,     color   ; top
        mcall   , x shl 16 + 1,     y shl 16 + h,     color   ; left
        mcall   , (x+w) shl 16 +1,  y shl 16 + (h+1), color   ; right
        mcall   , x shl 16 + w,   (y+h) shl 16 + 1,   color   ; bottom
}
 
;-----------------------------------------------------------------------------
;                             Color scheme
 
BLACK_ON_WHITE  equ 0
MOVIEOS         equ 1
WHITE_ON_BLACK  equ 2
 
;                         format - 0xRRGGBB
if COLOR_THEME eq MOVIEOS
 
        COLOR_BG_NORMAL           = 0x1d272f
        COLOR_BG_BREAKPOINT       = 0x0000aa
        COLOR_BG_SELECTED         = 0xec9300
        COLOR_LINE                = 0x00b9a0
        COLOR_TXT_NORMAL          = 0xffffff
        COLOR_TXT_INACTIVE        = 0x8f7948
        COLOR_TXT_CHANGED         = 0xec9300
        COLOR_TXT_LABEL           = 0x22b14c
        COLOR_TXT_SELECTED        = 0x1d272f
        COLOR_TXT_HEX             = 0xec9300
        COLOR_TXT_BREAKPOINT      = 0xec9300
 
else if COLOR_THEME eq WHITE_ON_BLACK
 
        COLOR_BG_NORMAL           = 0x101010 ; dark grey
        COLOR_BG_BREAKPOINT       = 0xFF0000 ; red
        COLOR_BG_SELECTED         = 0x0000FF ; blue
        COLOR_LINE                = 0xFFFFFF ; white
        COLOR_TXT_NORMAL          = 0xFFFFFF ; white
        COLOR_TXT_INACTIVE        = 0x808080 ; grey
        COLOR_TXT_CHANGED         = 0x00AA00 ; green
        COLOR_TXT_LABEL           = COLOR_TXT_NORMAL
        COLOR_TXT_SELECTED        = 0xFFFFFF ; white
        COLOR_TXT_HEX             = COLOR_TXT_NORMAL
        COLOR_TXT_BREAKPOINT      = COLOR_TXT_NORMAL
 
else  ; BLACK ON WHITE
 
        COLOR_BG_NORMAL           = 0xffffff ; white
        COLOR_BG_BREAKPOINT       = 0xFF0000 ; red
        COLOR_BG_SELECTED         = 0x0000FF ; blue
        COLOR_LINE                = 0x000000 ; black
        COLOR_TXT_NORMAL          = 0x000000 ; black
        COLOR_TXT_INACTIVE        = 0x808080 ; grey
        COLOR_TXT_CHANGED         = 0x00AA00 ; green
        COLOR_TXT_LABEL           = COLOR_TXT_NORMAL
        COLOR_TXT_SELECTED        = 0xFFFFFF ; white
        COLOR_TXT_HEX             = COLOR_TXT_NORMAL
        COLOR_TXT_BREAKPOINT      = COLOR_TXT_NORMAL
 
end if
 
;-----------------------------------------------------------------------------
 
data_width      equ 80
data_x_pos      equ 12
data_x_size     equ data_width*6
 
title_x_pos     equ 30
title_y_pos     equ 32
title_y_size    equ 10
 
;dump_y_pos      equ (registers_y_pos + registers_y_size + 5)
dump_y_pos      equ (title_y_pos + title_y_size)
dump_height     equ 6
dump_y_size     equ (dump_height*10)
 
disasm_y_pos    equ (dump_y_pos + dump_y_size + 4)
disasm_height   equ 18
disasm_y_size   equ (disasm_height*10)
 
messages_width  equ data_width
messages_height equ 8
messages_x_pos  equ data_x_pos
messages_y_pos  equ (disasm_y_pos + disasm_y_size + 4)
messages_x_size equ messages_width*6
messages_y_size equ messages_height*10
 
cmdline_width   equ data_width
cmdline_x_pos   equ data_x_pos
cmdline_y_pos   equ (messages_y_pos + messages_y_size + 4)
cmdline_x_size  equ messages_x_size
cmdline_y_size  equ 10
 
registers_x_pos equ (data_x_pos + messages_x_size + 4)
registers_y_pos equ (title_y_pos + title_y_size - 3)
registers_x_size equ 134
registers_y_size equ (cmdline_y_pos + cmdline_y_size - registers_y_pos+1)
 
wnd_x_size      equ (data_x_pos + messages_x_size + data_x_pos + registers_x_size+3)
wnd_y_size      equ (cmdline_y_pos + cmdline_y_size + data_x_pos)
 
;-----------------------------------------------------------------------------
;                          Entry point
 
; TODO: split all gui part in independent function, move entry point into mtdbg.asm
 
start:
        ; initialize process heap
        mcall   68, 11
        mov     edi, messages
        mov     ecx, messages_width*messages_height
        mov     al, ' '
        rep stosb
        xor     eax, eax
        mov     [messages_pos], eax
        mov     [cmdline_len], eax
        mov     [cmdline_pos], eax
        mov     edi, needzerostart
        mov     ecx, (needzeroend-needzerostart+3)/4
        rep stosd
        mov     esi, begin_str
        call    put_message_nodraw
        ; set event mask - default events and debugging events
        mcall   40, 0x107
        ; set debug messages buffer
        mov     ecx, dbgbufsize
        mov     dword [ecx], 256
        xor     ebx, ebx
        mov     [ecx+4], ebx
        mov     al, 69
        mcall
        mov     esi, i_param
        call    get_arg.skip_spaces
        test    al, al
        jz      dodraw
        push    esi
        call    draw_window
        pop     esi
        call    OnLoadInit
        jmp     waitevent
 
dodraw:
        call    draw_window
 
waitevent:
        mcall   10
        cmp     al, 9
        jz      debugmsg
        dec     eax
        jz      dodraw
        dec     eax
        jz      keypressed
        dec     eax
        jnz     waitevent
        ; button pressed - we have only one button (close)
        mcall   -1
 
; TODO: split in more independent function
keypressed:
        mov     al, 2
        mcall
        shr     eax, 8
        cmp     al, 8
        jz      .backspace
        cmp     al, 0xB0
        jz      .left
        cmp     al, 0xB3
        jz      .right
        cmp     al, 0x0D
        jz      .enter
        cmp     al, 0xB6
        jz      .del
        cmp     al, 0xB4
        jz      .home
        cmp     al, 0xB5
        jz      .end
        cmp     al, 0xB1
        jz      .down
        cmp     al, 0xB2
        jz      .up
        cmp     ah, 0x41
        jz      F7
        cmp     ah, 0x42
        jz      F8
        cmp     [cmdline_len], cmdline_width
        jae     waitevent
        push    eax
        call    clear_cmdline_end
        pop     eax
        mov     edi, cmdline
        mov     ecx, [cmdline_len]
        add     edi, ecx
        lea     esi, [edi-1]
        sub     ecx, [cmdline_pos]
        std
        rep movsb
        cld
        stosb
        inc     [cmdline_len]
        call    draw_cmdline_end
        inc     [cmdline_pos]
        call    draw_cursor
        jmp     waitevent
 
    .backspace:
        cmp     [cmdline_pos], 0
        jz      waitevent
        dec     [cmdline_pos]
 
    .delchar:
        call    clear_cmdline_end
        mov     edi, [cmdline_pos]
        dec     [cmdline_len]
        mov     ecx, [cmdline_len]
        sub     ecx, edi
        add     edi, cmdline
        lea     esi, [edi+1]
        rep movsb
        call    draw_cmdline_end
        call    draw_cursor
        jmp     waitevent
 
    .del:
        mov     eax, [cmdline_pos]
        cmp     eax, [cmdline_len]
        jae     waitevent
        jmp     .delchar
 
    .left:
        cmp     [cmdline_pos], 0
        jz      waitevent
        call    hide_cursor
        dec     [cmdline_pos]
        call    draw_cursor
        jmp     waitevent
 
    .right:
        mov     eax, [cmdline_pos]
        cmp     eax, [cmdline_len]
        jae     waitevent
        call    hide_cursor
        inc     [cmdline_pos]
        call    draw_cursor
        jmp     waitevent
 
    .home:
        call    hide_cursor
        and     [cmdline_pos], 0
        call    draw_cursor
        jmp     waitevent
 
    .end:
        call    hide_cursor
        mov     eax, [cmdline_len]
        mov     [cmdline_pos], eax
        call    draw_cursor
 
    .up:
    .down:
        jmp     waitevent
 
        ; We also trying to execute previous command, if empty command_line
    .enter:
        mov     ecx, [cmdline_len]
        test    ecx, ecx
        jnz     .exec_cur
        mov     cl, byte [cmdline_prev]
        cmp     cl, 0
        jz      waitevent
 
    .exec_prev:
        mov     esi, cmdline_prev
        jmp     .exec
 
    .exec_cur:
        mov     esi, cmdline
 
    .exec:
        mov     byte [esi+ecx], 0
        and     [cmdline_pos], 0
        push    esi
        call    clear_cmdline_end
        call    draw_cursor
        pop     esi
        and     [cmdline_len], 0
        ; skip leading spaces
        call    get_arg.skip_spaces
        cmp     al, 0
        jz      waitevent
        ; now esi points to command
        push    esi
        mov     esi, prompt
        call    put_message_nodraw
        pop     esi
        push    esi
        call    put_message_nodraw
 
; TODO: add meaningful name
z1:
        mov     esi, newline
        call    put_message
        pop     esi
        push    esi
        call    get_arg
        mov     [curarg], esi
        pop     edi
        mov     esi, commands
        call    find_cmd
        mov     eax, aUnknownCommand
        jc      .x11
 
        ; check command requirements
        ; flags field:
        ; &1: command may be called without parameters
        ; &2: command may be called with parameters
        ; &4: command may be called without loaded program
        ; &8: command may be called with loaded program
        mov     eax, [esi+8]
        mov     ecx, [curarg]
        cmp     byte [ecx], 0
        jz      .noargs
        test    byte [esi+16], 2
        jz      .x11
        jmp     @f
 
    .noargs:
        test    byte [esi+16], 1
        jz      .x11
 
    @@:
        cmp     [debuggee_pid], 0
        jz      .nodebuggee
        mov     eax, aAlreadyLoaded
        test    byte [esi+16], 8
        jz      .x11
        jmp     .x9
 
    .nodebuggee:
        mov     eax, need_debuggee
        test    byte [esi+16], 4
        jnz     .x9
 
    .x11:
        xchg    esi, eax
        call    put_message
 
        ; store cmdline for repeating
    .x10:
        mov     esi, cmdline
        mov     ecx, [cmdline_len]
 
    @@:
        cmp     ecx, 0
        jle     .we
        mov     al, [esi + ecx]
        mov     [cmdline_prev + ecx], al
        dec     ecx
        jmp     @b
 
    .we:
        mov     [cmdline_len], 0
        jmp     waitevent
 
    .x9:
        call    dword [esi+4]
        jmp     .x10
 
;-----------------------------------------------------------------------------
;                            Cmdline handling
 
clear_cmdline_end:
        mov     ebx, [cmdline_pos]
        mov     ecx, [cmdline_len]
        sub     ecx, ebx
        imul    ebx, 6
        imul    ecx, 6
        inc     ecx
        add     ebx, cmdline_x_pos
        shl     ebx, 16
        or      ebx, ecx
        mov     ecx, cmdline_y_pos*10000h + cmdline_y_size
        mov     edx, COLOR_BG_NORMAL
        ; draw container rectangle/box for cmdline
        mcall   13
        ret
 
draw_cmdline:
        xor     ebx, ebx
        jmp     @f
 
; TODO: make it local
draw_cmdline_end:
        mov     ebx, [cmdline_pos]
 
    @@:
        mov     esi, [cmdline_len]
        sub     esi, ebx
 
        mov     ecx, COLOR_TXT_NORMAL
        lea     edx, [cmdline+ebx]
        imul    ebx, 6
        add     ebx, cmdline_x_pos
        shl     ebx, 16
        or      ebx, cmdline_y_pos+1
        ; draw a text string in the window
        mcall   4
        ret
 
;-----------------------------------------------------------------------------
;                        Working with messages
; in: esi->ASCIIZ message
put_message_nodraw:
        mov     edx, [messages_pos]
 
    .m:
        lea     edi, [messages+edx]
 
    .l:
        lodsb
        cmp     al, 0
        jz      .done
        call    test_scroll
        cmp     al, 10
        jz      .newline
        cmp     al, '%'
        jnz     @f
        cmp     dword [esp], z1
        jnz     .format
 
    @@:
        stosb
        inc     edx
        jmp     .l
 
    .newline:
        push    edx
        mov     ecx, messages_width
        xor     eax, eax
        xchg    eax, edx
        div     ecx
        xchg    eax, edx
        pop     edx
        test    eax, eax
        jz      .m
        sub     edx, eax
        add     edx, ecx
        jmp     .m
 
    .done:
        mov     [messages_pos], edx
        ret
 
        ; at this moment all format specs must be %X
    .format:
        lodsb   ; get 
        sub     al, '0'
        movzx   ecx, al
        lodsb
        pop     eax
        pop     ebp
        push    eax
        ; write number in ebp with ecx digits
        dec     ecx
        shl     ecx, 2
 
    .writenibble:
        push    ecx
        call    test_scroll
        pop     ecx
        mov     eax, ebp
        shr     eax, cl
        and     al, 0xF
        cmp     al, 10
        sbb     al, 69h
        das
        stosb
        inc     edx
        sub     ecx, 4
        jns     .writenibble
        jmp     .l
 
test_scroll:
        cmp     edx, messages_width*messages_height
        jnz     .ret
        push    esi
        mov     edi, messages
        lea     esi, [edi+messages_width]
        mov     ecx, (messages_height-1)*messages_width/4
        rep movsd
        push    eax
        mov     al, ' '
        push    edi
        push    messages_width
        pop     ecx
        sub     edx, ecx
        rep stosb
        pop     edi
        pop     eax
        pop     esi
 
    .ret:
        ret
 
;-----------------------------------------------------------------------------
 
put_message:
        call    put_message_nodraw
 
draw_messages:
        ; draw container rectangle/box
        mcall   13, messages_x_pos*10000h+messages_x_size, messages_y_pos*10000h+messages_y_size, COLOR_BG_NORMAL
        mov     edx, messages
        push    messages_width
        pop     esi
        mov     ecx, COLOR_TXT_NORMAL
        mov     ebx, messages_x_pos*10000h+messages_y_pos
 
    @@:
        ; display text string in the window
        mcall   4
        add     edx, esi
        add     ebx, 10
        cmp     edx, messages+messages_width*messages_height
        jb      @b
        ret
 
;-----------------------------------------------------------------------------
;                     Show/hide cursor in command line
 
; TODO: make it cursor.draw and cursor.hide ???
draw_cursor:
        mov     ecx, cmdline_y_pos*10001h+cmdline_y_size-1
        mov     ebx, [cmdline_pos]
        imul    ebx, 6
        add     ebx, cmdline_x_pos
        mov     edx, ebx
        shl     ebx, 16
        or      ebx, edx
        mov     edx, COLOR_TXT_NORMAL
        ; draw line
        mcall   38
        ret
 
hide_cursor:
        mov     ebx, [cmdline_pos]
        imul    ebx, 6
        add     ebx, cmdline_x_pos
        shl     ebx, 16
        inc     ebx
        mov     ecx, cmdline_y_pos*10000h + cmdline_y_size
        mov     edx, COLOR_BG_NORMAL
        ; draw container rectangle/box
        mcall   13
        mov     ebx, [cmdline_pos]
        cmp     ebx, [cmdline_len]
        jae     .ret
        ; setting up text color scheme and attributes
        mov     ecx, COLOR_TXT_NORMAL
        lea     edx, [cmdline+ebx]
        imul    ebx, 6
        add     ebx, cmdline_x_pos
        shl     ebx, 16
        or      ebx, cmdline_y_pos+1
        push    1
        pop     esi
        ; draw text string in the window
        mcall   4
 
    .ret:
        ret
 
;-----------------------------------------------------------------------------
;                       Draw program window title
 
; FIXME: something wrong here
redraw_title:
        ; draw container rectangle/box
        mcall   13, title_x_pos*10000h+data_x_pos+data_x_size-title_x_pos, title_y_pos*10000h+title_y_size, COLOR_BG_NORMAL
 
draw_title:
        mcall   38, (data_x_pos-2)*10000h+title_x_pos-5, (title_y_pos+5)*10001h, COLOR_LINE
        push    NoPrgLoaded_len
        pop     esi
        cmp     [debuggee_pid], 0
        jz      @f
        mov     esi, [prgname_len]
 
    @@:
        imul    ebx, esi, 6
        add     ebx, title_x_pos+4
        shl     ebx, 16
        mov     bx, data_x_pos+data_x_size-10-5-6*7
        cmp     [bSuspended], 0
        jz      @f
        add     ebx, 6
 
    @@:
        ; draw line with COLOR_LINE (in edx)
        mcall
        mov     ebx, (data_x_pos+data_x_size-10+4)*0x10000 + data_x_pos+data_x_size+2
        ; draw line with COLOR_LINE (in edx)
        mcall
        mov     al, 4
        mov     ebx, title_x_pos*10000h+title_y_pos
        ; setting up text color scheme and attributes
        mov     ecx, COLOR_TXT_NORMAL
        mov     edx, NoPrgLoaded_str
        cmp     [debuggee_pid], 0
        jz      @f
        mov     edx, [prgname_ptr]
 
    @@:
        ; draw text string in the window
        mcall
        cmp     [debuggee_pid], 0
        jz      .nodebuggee
        mov     ebx, (data_x_pos+data_x_size-10-6*7)*10000h + title_y_pos
        mov     edx, aRunning
        push    7
        pop     esi
        cmp     [bSuspended], 0
        jz      @f
        add     ebx, 6*10000h
        mov     edx, aPaused
        dec     esi
 
    @@:
        ; draw line with COLOR_LINE (in edx) in one case
        ; and draw text string with color COLOR_TXT_NORMAL (in ecx) in another
        mcall
        ret
 
    .nodebuggee:
        mov     al, 38
        mov     ebx, (data_x_pos+data_x_size-10-6*7-5)*0x10000 + data_x_pos+data_x_size+2
        mov     ecx, (title_y_pos+5)*10001h
        mov     edx, COLOR_LINE
        jmp     @b
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;; REGISTERS PANEL ;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
;-----------------------------------------------------------------------------
;                      Display common register content
 
; TODO: add format support (e.g. numerical value, or address offset/pointer)
 
; in: esi->value, edx->string, ecx = string length, ebx = coord
draw_register:
        push    edx
        push    ecx
        push    esi
        mov     eax, esi
        mov     esi, ecx
 
        mov     ecx, (COLOR_TXT_INACTIVE or 0x40000000)
        cmp     [debuggee_pid], 0
        jz      .cd
        cmp     [bSuspended], 0
        jz      .cd
 
        mov     ecx, (COLOR_TXT_NORMAL or 0x40000000)
        push    edi
        mov     edi, [eax]
        cmp     dword [eax+oldcontext-context], edi
        pop     edi
        jz      .cd
        mov     ecx, (COLOR_TXT_CHANGED or 0x40000000)
 
    .cd:
        ; draw a text string in the window
        mcall   4
        imul    esi, 60000h
        lea     edx, [ebx+esi]
        mov     esi, ecx
        pop     ecx
 
        ; draw a number in the window
        mcall   47, 80101h
        lea     ebx, [edx+60000h*18]
        mov     esi, ecx
        pop     ecx
        pop     edx
        add     edx, ecx
        ret
 
;-----------------------------------------------------------------------------
;                  Display FPU register (ST0 - ST7) content
;
; in: esi->value, edx->string, ecx = string length, ebx = coord
draw_fpu_register:
        push    ebx
        push    edx
        push    ecx
        push    esi
 
        sub     esp, 8
 
        fld     tword [esi]
        fistp   qword [esp]
 
        mov     eax, esi
        mov     esi, ecx
 
        mov     ecx, (COLOR_TXT_INACTIVE or 0x40000000)
        cmp     [debuggee_pid], 0
        jz      .cd
        cmp     [bSuspended], 0
        jz      .cd
 
        mov     ecx, (COLOR_TXT_NORMAL or 0x40000000)
        push    edi
        mov     edi, [eax]
        cmp     dword [eax+oldcontext-context], edi
        pop     edi
        jnz     .scol
        push    edi
        mov     edi, [eax+4]
        cmp     dword [eax+oldcontext-context+4], edi
        pop     edi
        jz      .cd
 
    .scol:
        mov     ecx, (COLOR_TXT_CHANGED or 0x40000000)
 
    .cd:
        ; draw a text string in the window
        mcall   4
        imul    esi, 60000h
        lea     edx, [ebx+esi]
        mov     esi, ecx
 
        mov     ecx, esp
 
        ; draw a number in the window
        ; color is the same as for previous text draw function
        ; ebx : [20] show 16 chars set [30] bit - qword
        mcall   47, 40100101h
        add     esp, 8
        pop     ecx
        lea     ebx, [edx+60000h*18]
        mov     esi, ecx
        pop     ecx
        pop     edx
        pop     ebx
        add     edx, ecx
        ret
 
;-----------------------------------------------------------------------------
;                  Display FPU register (ST0 - ST7) content
;
; in: esi->value, ebx = coord
draw_fpu_register_2:
 
.str_buf  equ esp
.bcd_man  equ esp+32
.bcd_exp  equ esp+32+12
 
        sub     esp, 32+12+12
 
        mov     edx, ebp
        shl     edx, 4
 
        fld     tword [_st0+edx]
        fldlg2
        fld     tword [_st0+edx]
        bt      dword [_st0+edx+8], 15
        jnc @f
        fabs
@@:
        fyl2x
        frndint
        fld     st0
        fbstp   tword [.bcd_exp]
        fldl2t
        fmulp
        fld     st0
        frndint
        fxch
        fsub    st,st1
 
        f2xm1
        fld1
        faddp
        fscale
        fstp    st1
        fdivp
        fimul   dword [_10000000]
        fbstp   tword [.bcd_man]
 
        mov     eax, 0x20202020
        mov     edi, .str_buf
        stosd
        stosd
        stosd
        stosd
 
        lea     esi, [.bcd_man-1]
        mov     edi, .str_buf
 
        mov     ecx, 9
        mov     eax, 0x10000
 
        mov     al, [esi+ecx+1]
        cmp     al, 0x80            ; check for sign
        jne     .mantis_2_str
        mov     al, '-'
        stosb
 
.mantis_2_str:
 
        mov     al, [esi+ecx]
        test    al, al
        jnz     @f
 
        bt      eax, 16
        jc      .skip_lb
@@:
        mov     ah, al
        shr     al, 4
        jnz     .write_h
 
        bt      eax, 16
        jc      .skip_hb
 
.write_h:
        add     al, 0x30
        stosb
        btr     eax, 16
        jnc     .skip_hb
        mov     al, '.'
        stosb
.skip_hb:
        mov     al, ah
        and     al, 0x0F
        jnz     .write_lb
 
        bt      eax, 16
        jc      .skip_lb
.write_lb:
        add     al,0x30
        stosb
        btr     eax, 16
        jnc     .skip_lb
        mov     al, '.'
        stosb
.skip_lb:
        dec     ecx
        jnz     .mantis_2_str
 
        mov     ax, ' e'
        stosw
 
        lea     esi, [.bcd_exp-1]
        mov     ecx, 9
        mov     eax,0x10000
        mov     al, [esi+ecx+1]
        cmp     al, 0x80
        jne     .exp_2_str
        mov     al, '-'
        stosb
.exp_2_str:
        mov     al, [esi+ecx]
        test    al, al
        jnz     @f
 
        bt      eax, 16
        jc      .skip_lb2
@@:
        mov     ah, al
        shr     al, 4
        jnz     .write_h2
 
        bt      eax, 16
        jc      .skip_hb2
.write_h2:
        add     al, 0x30
        stosb
        btr     eax, 16
        stosb
.skip_hb2:
        mov     al, ah
        and     al, 0x0F
        jnz     .write_lb2
 
        bt      eax, 16
        jc      .skip_lb2
.write_lb2:
        add     al, 0x30
        stosb
        btr     eax, 16
.skip_lb2:
        dec ecx
        jnz .exp_2_str
 
        mov     ecx, (COLOR_TXT_INACTIVE or 0x40000000)
        cmp     [debuggee_pid], 0
        jz      .do_label
        cmp     [bSuspended], 0
        jz      .do_label
 
        mov     ecx, (COLOR_TXT_NORMAL or 0x40000000)
 
        mov     eax, dword [_st0+edx]
        cmp     eax, dword [_st0+(oldcontext-context)+edx]
        jne     .scol
 
        mov     eax, dword [_st0+edx+4]
        cmp     eax, dword [_st0+(oldcontext-context)+4]
        jne     .scol
 
        mov     ax, word [_st0+edx+8]
        cmp     ax, word [_st0+(oldcontext-context)+8]
        je      .do_label
 
.scol:
        mov     ecx, (COLOR_TXT_CHANGED or 0x40000000)
 
.do_label:
        ; draw a text string in the window
 
        mov     eax, 4
        mov     esi, eax
        lea     edx, [fpu_strs+ebp*4]
        mov     edi, COLOR_BG_NORMAL
        int     0x40
 
        mov     esi, 16
        mov     edx, .str_buf
        add     ebx, 0x180000
        int     0x40
 
        sub     ebx, 0x180000
        add     esp, 32+12+12
 
        ret
 
 
;-----------------------------------------------------------------------------
;                      Show FPU MMX register content
;
; in: esi->value, edx->string, ecx = string length, ebx = coord
draw_mmx_register:
        push    ebx
        push    edx
        push    ecx
        push    esi
        mov     eax, esi
        mov     esi, ecx
 
        mov     ecx, (COLOR_TXT_INACTIVE or 0x40000000)
        cmp     [debuggee_pid], 0
        jz      .cd
        cmp     [bSuspended], 0
        jz      .cd
 
        mov     ecx, (COLOR_TXT_NORMAL or 0x40000000)
        push    edi
        mov     edi, [eax]
        cmp     dword [eax+oldcontext-context], edi
        pop     edi
        jnz     .scol
        push    edi
        mov     edi, [eax+4]
        cmp     dword [eax+oldcontext-context+4], edi
        pop     edi
        jz      .cd
 
    .scol:
        mov     ecx, (COLOR_TXT_CHANGED or 0x40000000)
 
    .cd:
        ; draw a text string in the window
        mcall   4
 
        imul    esi, 60000h
        lea     edx, [ebx+esi]
        mov     esi, ecx
        pop     ecx
        ; draw a number in the window
        ; color is the same as for previous draw text function
        ; ebx : [20] show 16 chars set [30] bit - qword
        mcall   47, 40100101h
        lea     ebx, [edx+60000h*18]
        mov     esi, ecx
        pop     ecx
        pop     edx
        pop     ebx
        add     edx, ecx
        ret
 
; TODO add SSE registers
; TODO add AVX registers
 
;-----------------------------------------------------------------------------
;                   Display contents of EFLAGS register
draw_flag:
        movzx   edi, byte [edx+7]
        bt      [_eflags], edi
        jc      .on
        or      byte [edx], 20h
        jmp     .onoff
 
    .on:
        and     byte [edx], not 20h
 
    .onoff:
        mov     ecx, (COLOR_TXT_INACTIVE or 0x40000000)
        cmp     [debuggee_pid], 0
        jz      .doit
        cmp     [bSuspended], 0
        jz      .doit
 
        mov     ecx, (COLOR_TXT_NORMAL or 0x40000000)
        bt      [_eflags], edi
        lahf
        bt      dword [_eflags + oldcontext - context], edi
        rcl     ah, 1
        test    ah, 3
        jp      .doit
        mov     ecx, (COLOR_TXT_CHANGED or 0x40000000)
 
    .doit:
        mov     ah, 0
        mov     edi, COLOR_BG_NORMAL
        ; draw a text string in the window in one case
        ; and a number in another
        ; color scheme same as for previously called function (was in ecx)
        mcall
        ret
 
;-----------------------------------------------------------------------------
;                      Draw registers frame title
 
; Also show current register set (common + MMX, SSE or AVX)
draw_reg_title:
        mov     edi, COLOR_BG_NORMAL
        mov     ecx, (COLOR_TXT_NORMAL or 0x40000000)
        mov     esi, 7
        cmp     [reg_mode], REG_MODE_CPU
        jz      @f
        mov     ecx, (COLOR_TXT_INACTIVE or 0x40000000)
    @@:
        mov     edx, aMain
        ; draw a text string in the window
        mcall   4, (registers_x_pos+4)*10000h+registers_y_pos+2
 
        cmp     [reg_mode], REG_MODE_SSE
        jz      @f
        mov     ecx, (COLOR_TXT_INACTIVE or 0x40000000)
    @@:
        mov     edx, aSSE
        ; draw a text string in the window
        mcall   4, (registers_x_pos+46)*10000h+registers_y_pos+2
 
        cmp     [reg_mode], REG_MODE_AVX
        jz      @f
        mov     ecx, (COLOR_TXT_INACTIVE or 0x40000000)
    @@:
        mov     edx, aAVX
        ; draw a text string in the window
        mcall   4, (registers_x_pos+88)*10000h+registers_y_pos+2
        ret
 
;-----------------------------------------------------------------------------
;                Display common registers set + MMX + FPU
 
draw_main_registers:
; TODO: add support for FPU ST0-ST7 registers
        mov     edi, COLOR_BG_NORMAL
        mov     esi, _eax
        push    4
        pop     ecx
        mov     edx, regs_strs
        mov     ebx, (registers_x_pos+2)*10000h+registers_y_pos+22
        call    draw_register
        mov     ebx, (registers_x_pos+2)*10000h+registers_y_pos+32
        add     esi, _ebx-_eax
        call    draw_register
        mov     ebx, (registers_x_pos+2)*10000h+registers_y_pos+42
        add     esi, _ecx-_ebx
        call    draw_register
        mov     ebx, (registers_x_pos+2)*10000h+registers_y_pos+52
        add     esi, _edx-_ecx
        call    draw_register
        mov     ebx, (registers_x_pos+2)*10000h+registers_y_pos+62
        add     esi, _esi-_edx
        call    draw_register
        mov     ebx, (registers_x_pos+2)*10000h+registers_y_pos+72
        add     esi, _edi-_esi
        call    draw_register
        mov     ebx, (registers_x_pos+2)*10000h+registers_y_pos+82
        add     esi, _ebp-_edi
        call    draw_register
        mov     ebx, (registers_x_pos+2)*10000h+registers_y_pos+92
        add     esi, _esp-_ebp
        call    draw_register
        mov     ebx, (registers_x_pos+2)*10000h+registers_y_pos+102
        add     esi, _eip-_esp
        call    draw_register
        mov     ebx, (registers_x_pos+2)*10000h+registers_y_pos+112
 
        mov     cl, 7
        add     esi, _eflags-_eip
        call    draw_register
        mov     cl, 4
 
    ; MMX registers
 
        push    ebp
 
        push    8
        mov     edx, mmx_strs
        mov     ebx, (registers_x_pos+2)*10000h+registers_y_pos+142
        mov     esi, _mm0
 
align 4
.draw_mmx_regs:
 
        call    draw_mmx_register
        add     ebx, 10
        add     esi, 16
        dec     dword [esp]
        jnz     .draw_mmx_regs
 
;FPU registers
 
        ;int3
        nop
 
        mov     [esp], byte 8
        xor     ebp, ebp
 
        mov     ebx, (registers_x_pos+2)*10000h+registers_y_pos+232
 
align 4
.draw_fpu_regs:
 
        call    draw_fpu_register_2
        add     ebx, 10
        inc     ebp
        dec     dword [esp]
        jnz     .draw_fpu_regs
        pop     eax                         ;restore stack
        pop     ebp
 
        mov     ecx, COLOR_TXT_INACTIVE
        cmp     [debuggee_pid], 0
        jz      @f
        cmp     [bSuspended], 0
        jz      @f
        mov     ecx, COLOR_TXT_NORMAL
    @@:
        mov     edx, aColon
        xor     esi, esi
        inc     esi
        mcall   4, (registers_x_pos+10)*10000h+registers_y_pos+122
        mov     edx, flags
 
    @@:
        add     ebx, 2*6*10000h
        call    draw_flag
        inc     edx
        cmp     dl, flags_bits and 0xFF
        jnz     @b
        ret
 
;-----------------------------------------------------------------------------
;                  Draw SSE registers set
 
draw_sse_registers:
 
        ret
 
;-----------------------------------------------------------------------------
;                  Draw AVX registers set
 
draw_avx_registers:
 
        ret
 
;-----------------------------------------------------------------------------
;                 Draw all registers sets
draw_registers:
 
        ; draw container rectangle/box with COLOR_BG_NORMAL
        mcall   13, (registers_x_pos-1)*10000h+(registers_x_size+2), (registers_y_pos-1)*10000h+(registers_y_size+2), COLOR_BG_NORMAL
        call    draw_reg_title
 
    .redraw:
        cmp     [reg_mode], REG_MODE_CPU
        jnz     @f
        call    draw_main_registers
        ret
 
    @@:
        cmp     [reg_mode], REG_MODE_SSE
        jnz     @f
        call    draw_sse_registers
        ret
 
    @@:
        call    draw_avx_registers
        ret
 
;-----------------------------------------------------------------------------
;                     Display memory dump
 
draw_dump:
        ; draw container rectangle/box in the window
        mcall   13, data_x_pos*10000h+data_x_size, dump_y_pos*10000h+dump_y_size, COLOR_BG_NORMAL
 
    .redraw:
        ; addresses
        mov     ebx, 80100h
        mov     edx, data_x_pos*10000h + dump_y_pos
        mov     ecx, [dumppos]
        mov     edi, COLOR_BG_NORMAL
        mov     esi, (COLOR_TXT_INACTIVE or 0x40000000)
        cmp     [debuggee_pid], 0
        jz      @f
        cmp     [bSuspended], 0
        jz      @f
        mov     esi, (COLOR_TXT_NORMAL or 0x40000000)
    @@:
        ; draw a number in the window
        mcall   47
        add     ecx, 10h
        add     edx, 10
        cmp     dl, dump_y_pos + dump_y_size
        jb      @b
        ; hex dump of data
        mov     ecx, dumpdata
        push    ecx
        xor     ebx, ebx
        mov     edx, (data_x_pos+12*6)*10000h + dump_y_pos
        cmp     [dumpread], ebx
        jz      .hexdumpdone1
 
    .hexdumploop1:
        push    ebx
        mov     ebx, 20101h
        ; draw a number in the window
        mcall
        pop     ebx
        add     edx, 3*6*10000h
        inc     ecx
        inc     ebx
        test    bl, 15
        jz      .16
        test    bl, 7
        jnz     @f
        add     edx, 2*6*10000h - 10 + 6*(3*10h+2)*10000h
 
    .16:
        add     edx, 10 - 6*(3*10h+2)*10000h
 
    @@:
        cmp     ebx, [dumpread]
        jb      .hexdumploop1
 
    .hexdumpdone1:
        mov     al, 4
        ; copy color value from esi to ecx
        ; to draw text string with 'mcall 4'
        mov     ecx, esi
        xchg    ebx, edx
        push    2
        pop     esi
 
    .hexdumploop2:
        cmp     edx, dump_height*10h
        jae     .hexdumpdone2
        push    edx
        mov     edx, aQuests
        ; draw text string with color in ecx, copied from esi
        mcall
        pop     edx
        add     ebx, 3*6*10000h
        inc     edx
        test    dl, 15
        jz      .16x
        test    dl, 7
        jnz     .hexdumploop2
        add     ebx, 2*6*10000h - 10 + 6*(3*10h+2)*10000h
 
    .16x:
        add     ebx, 10 - 6*(3*10h+2)*10000h
        jmp     .hexdumploop2
 
    .hexdumpdone2:
        dec     esi
        ; colon, minus signs
        mov     ebx, (data_x_pos+8*6)*10000h + dump_y_pos
        mov     edx, aColon
 
    @@:
        mcall
        add     ebx, 10
        cmp     bl, dump_y_pos+dump_height*10
        jb      @b
        mov     ebx, (data_x_pos+(12+3*8)*6)*10000h + dump_y_pos
        mov     edx, aMinus
 
    @@:
        mcall
        add     ebx, 10
        cmp     bl, dump_y_pos+dump_height*10
        jb      @b
        ; ASCII data
        mov     ebx, (data_x_pos+(12+3*10h+2+2)*6)*10000h + dump_y_pos
        pop     edx
        push    dump_height*10h
 
    .asciiloop:
        push    edx
        cmp     byte [edx], 20h
        jae     @f
        mov     edx, aPoint
 
    @@:
        ; draw a text string in the window, color in ecx
        mcall
        pop     edx
        inc     edx
        add     ebx, 6*10000h
        dec     dword [esp]
        jz      .asciidone
        test    byte [esp], 15
        jnz     .asciiloop
        add     ebx, 10 - 6*10h*10000h
        jmp     .asciiloop
 
    .asciidone:
        pop     ecx
        ret
 
;-----------------------------------------------------------------------------
;                   Display disassembled code
 
draw_disasm:
 
        mov     eax, [disasm_start_pos]
        mov     [disasm_cur_pos], eax
        and     [disasm_cur_str], 0
 
    .loop:
        mov     eax, [disasm_cur_pos]
        call    find_symbol
        jc      .nosymb
        mov     ebx, [disasm_cur_str]
        imul    ebx, 10
        push    ebx
        lea     ecx, [ebx+disasm_y_pos-1]
        shl     ecx, 16
        mov     cl, 11
        ; setting up background color for disassembled text
        mov     edx, COLOR_BG_NORMAL
        ; draw container rectangle/box with color COLOR_BG_NORMAL (was 0xFFFFFF - white)
        mcall   13, data_x_pos*10000h+data_x_size
        pop     ebx
        ; copy color value from edx (COLOR_BG_NORMAL)
        mov     edi, edx
        add     ebx, (data_x_pos+6*2)*10000h+disasm_y_pos
        mov     edx, esi
 
    @@:
        lodsb
        test    al, al
        jnz     @b
        mov     byte [esi-1], ':'
        sub     esi, edx
        ; normal color
        ; was 0x40000000
        mov     ecx, (COLOR_TXT_LABEL or 0x40000000)
        mov     al, 4
        ; draw a text string in the window with color COLOR_TXT_NORMAL in ecx
        mcall
        mov     byte [esi+edx-1], 0
        lea     esi, [esi*3]
        movzx   ecx, bx
        shr     ebx, 16
        lea     ebx, [ebx+esi*2]
        shl     ecx, 16
        mov     cl, 10
        imul    ebx, 10001h
        sub     bx, data_x_pos+data_x_size
        neg     bx
        mov     al, 13
        ; copy color value from edi
        mov     edx, edi
        ; draw container rectangle/box for disassembled text, color in edx
        mcall
        inc     [disasm_cur_str]
        cmp     [disasm_cur_str], disasm_height
        jae     .loopend
 
    .nosymb:
        push    [disasm_cur_pos]
        call    disasm_instr
        pop     ebp
        jc      .loopend
        mov     edx, COLOR_BG_NORMAL
        mov     esi, COLOR_TXT_NORMAL
        mov     ebx, data_x_pos*10000h + data_x_size
        mov     ecx, [disasm_cur_str]
        imul    ecx, 10*10000h
        add     ecx, (disasm_y_pos-1)*10000h + 10
        mov     eax, ebp
        pushad
        call    find_enabled_breakpoint
        popad
        jnz     .nobp
        mov     edx, COLOR_BG_BREAKPOINT
        mov     esi, COLOR_TXT_BREAKPOINT
    .nobp:
 
        mov     eax, [_eip]
        cmp     eax, ebp
        jnz     .notcurrent
        mov     edx, COLOR_BG_SELECTED
        mov     esi, COLOR_TXT_SELECTED
    .notcurrent:
        push    esi     ; Save color value for disassembled text
 
        ; draw container rectangle/box for disassembled text
        ; color in edx
        mcall   13
 
        mov     edx, [disasm_cur_str]
        imul    edx, 10
        add     edx, data_x_pos*10000h + disasm_y_pos
        ; draw a number in the window, color in esi
        mcall   47, 80100h, ebp
 
        lea     ebx, [edx+8*6*10000h]
        mov     ecx, esi    ; text color
        push    2
        pop     esi
        mov     edx, aColon
        ; draw the colon
        mcall   4
        push    9
        pop     edi
        lea     edx, [ebx+2*6*10000h]
        mov     ecx, ebp
        sub     ecx, [disasm_start_pos]
        add     ecx, disasm_buffer
 
        mov     esi, COLOR_TXT_HEX
        mov     eax, [_eip]
        cmp     eax, ebp
        jnz     @f
        mov     esi, COLOR_TXT_SELECTED
  @@:
    .drawhex:
        ; draw a number in the window, color in esi
        mcall   47, 20101h
        add     edx, 6*3*10000h
        inc     ecx
        inc     ebp
        cmp     ebp, [disasm_cur_pos]
        jae     .hexdone
        dec     edi
        jnz     .drawhex
        push    esi
        mov     esi, [disasm_cur_pos]
        dec     esi
        cmp     esi, ebp
        pop     esi
        jbe     .drawhex
 
        lea     ebx, [edx-6*10000h]
        ; copy color value from esi
        mov     ecx, esi
        push    3
        pop     esi
        mov     edx, aDots
        ; draw a text string in the window, color in ecx
        mcall   4
 
    .hexdone:
        pop     esi
        xor     eax, eax
        mov     edi, disasm_string
        mov     edx, edi
        or      ecx, -1
        repnz scasb
        not     ecx
        dec     ecx
        xchg    ecx, esi
        mov     ebx, [disasm_cur_str]
        imul    ebx, 10
        add     ebx, (data_x_pos+6*40)*10000h+disasm_y_pos
 
        ; draw a text string in the window, color in ecx
        mcall   4
        inc     [disasm_cur_str]
        cmp     [disasm_cur_str], disasm_height
        jb      .loop
 
    .loopend:
        mov     ecx, disasm_height
        sub     ecx, [disasm_cur_str]
        jz      @f
        imul    ecx, 10
        inc     ecx
        mov     eax, disasm_y_pos + disasm_y_size
        sub     eax, ecx
        shl     eax, 16
        add     ecx, eax
        ; Draw filled rectangle
        mcall   13, data_x_pos*10000h+data_x_size, , COLOR_BG_NORMAL
 
    @@:
        ret
 
;-----------------------------------------------------------------------------
 
; TODO: cleanup of this function, make some global labels local
update_disasm_eip:
; test if instruction at eip is showed
        mov     ecx, disasm_height
        mov     eax, [disasm_start_pos]
        mov     [disasm_cur_pos], eax
 
    .l:
        mov     eax, [disasm_cur_pos]
        call    find_symbol
        jc      @f
        dec     ecx
        jz      .m
 
    @@:
        cmp     [_eip], eax
        jz      draw_disasm
        push    ecx
        call    disasm_instr
        pop     ecx
        jc      .m
        loop    .l
 
    .m:
 
update_disasm_eip_force:
        mov     eax, [_eip]
        mov     [disasm_start_pos], eax
 
update_disasm:
        cmp     [debuggee_pid], 0
        jz      .no
 
        mcall   69, 6, [debuggee_pid], 256, [disasm_start_pos], disasm_buffer
        cmp     eax, -1
        jnz     @f
        mov     esi, read_mem_err
        call    put_message
 
    .no:
        xor     eax, eax
 
    @@:
        mov     [disasm_buf_size], eax
        call    restore_from_breaks
        jmp     draw_disasm
 
 
;-----------------------------------------------------------------------------
;                               Draw main window
 
draw_window:
        ; start window redraw
        mcall   12, 1
 
        ; define window
        mcall   0, wnd_x_size, wnd_y_size, (COLOR_BG_NORMAL or 0x54000000), , caption_str
 
        ; clear unused areas
        ; get window skin height
        mcall   48, 4
        cmp     eax, title_y_pos
        jb      @f
        push    registers_y_pos
        pop     eax
 
    @@:
        push    registers_y_pos
        pop     ecx
        push    eax
        sub     ecx, eax
        shl     eax, 16
        add     ecx, eax
        mov     ebx, 5*10000h + (wnd_x_size-9)
        mov     edx, COLOR_BG_NORMAL
        ; draw container rectangle/box for registers information region
        mcall   13
        mov     ecx, (dump_y_pos+dump_y_size)*10000h + (disasm_y_pos-dump_y_pos-dump_y_size)
        ; draw container rectangle/box for dump memory region
        mcall
        mov     ecx, (disasm_y_pos-1+disasm_y_size)*10000h + (messages_y_pos-disasm_y_pos+1-disasm_y_size)
        ; draw container rectangle/box for disassembled code region
        mcall
        mov     ecx, (messages_y_pos+messages_y_size)*10000h + (wnd_y_size-messages_y_pos-messages_y_size-4)
        ; draw container rectangle/box for messages window region
        mcall
        mov     ebx, 5*10000h + (data_x_pos-5)
        pop     ecx
        imul    ecx, 10001h
        sub     cx, wnd_y_size-4
        neg     cx
        ; draw container rectangle/box
        mcall
        mov     ebx, (data_x_pos+data_x_size)*10000h + (wnd_x_size-data_x_pos-data_x_size-4)
        ; draw container rectangle/box
        mcall
        mov     ebx, 5*10000h + title_x_pos - 5
        mov     ecx, (title_y_pos)*10000h + (title_y_size)
        ; draw container rectangle/box for dump memory region title
        mcall
 
        ; messages frame
        mov     ebx, (messages_x_pos-2)*10000h + (messages_x_pos+messages_x_size+2)
        push    ebx
        mov     ecx, (messages_y_pos-2)*10001h
        mov     edx, COLOR_LINE
        mcall   38
        mov     ecx, (messages_y_pos+messages_y_size+2)*10001h
        mcall
        mov     ebx, (messages_x_pos-2)*10001h
        push    ebx
        mov     ecx, (messages_y_pos-2)*10000h + (messages_y_pos+messages_y_size+2)
        mcall
        mov     ebx, (messages_x_pos+messages_x_size+2)*10001h
        push    ebx
        mcall
 
        ; command line frame
        mov     ecx, (cmdline_y_pos-2)*10000h + (cmdline_y_pos+cmdline_y_size+2)
        pop     ebx
        mcall
        pop     ebx
        mcall
        pop     ebx
        mov     ecx, (cmdline_y_pos+cmdline_y_size+2)*10001h
        mcall
        mov     ecx, (cmdline_y_pos-2)*10001h
        mcall
 
        ; registers frame
        DrawRectangle (registers_x_pos-2), (registers_y_pos-2), (registers_x_size+3), (registers_y_size+3), COLOR_LINE
        ; draw container rectangle/box for registers information window region
 
        ; messages
        call    draw_messages
 
        ; command line & cursor
        call    draw_cmdline
        call    draw_cursor
 
        ; title & registers & dump & disasm
        mov     ebx, (data_x_pos-2)*10001h
        mov     ecx, (title_y_pos+5)*10000h + (messages_y_pos-2)
        mov     edx, COLOR_LINE
        mcall   38
        mov     ebx, (data_x_pos+data_x_size+2)*10001h
        mcall
        mov     ebx, (data_x_pos-2)*10000h + (data_x_pos+data_x_size+2)
        mov     ecx, (disasm_y_pos-4)*10001h
        mcall
 
        ; redraw whole window again
        call    redraw_title
        call    draw_registers
        call    draw_dump
        call    draw_disasm
 
        ; end of window redraw
        mcall   12, 2
        ret
 
; vim: ft=fasm tabstop=4

Rev 4895	Rev 4900
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; GUI ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	2	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; GUI ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	3	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4		4
5	macro DrawRectangle x, y, w, h, color	5	macro DrawRectangle x, y, w, h, color
6	{	6	{
7	mcall 13, x shl 16 + w, y shl 16 + 1, color ; top	7	mcall 13, x shl 16 + w, y shl 16 + 1, color ; top
8	mcall , x shl 16 + 1, y shl 16 + h, color ; left	8	mcall , x shl 16 + 1, y shl 16 + h, color ; left
9	mcall , (x+w) shl 16 +1, y shl 16 + (h+1), color ; right	9	mcall , (x+w) shl 16 +1, y shl 16 + (h+1), color ; right
10	mcall , x shl 16 + w, (y+h) shl 16 + 1, color ; bottom	10	mcall , x shl 16 + w, (y+h) shl 16 + 1, color ; bottom
11	}	11	}
12		12
13	;-----------------------------------------------------------------------------	13	;-----------------------------------------------------------------------------
14	; Color scheme	14	; Color scheme
15		15
16	BLACK_ON_WHITE equ 0	16	BLACK_ON_WHITE equ 0
17	MOVIEOS equ 1	17	MOVIEOS equ 1
18	WHITE_ON_BLACK equ 2	18	WHITE_ON_BLACK equ 2
19		19
20	; format - 0xRRGGBB	20	; format - 0xRRGGBB
21	if COLOR_THEME eq MOVIEOS	21	if COLOR_THEME eq MOVIEOS
22		22
23	COLOR_BG_NORMAL = 0x1d272f	23	COLOR_BG_NORMAL = 0x1d272f
24	COLOR_BG_BREAKPOINT = 0x0000aa	24	COLOR_BG_BREAKPOINT = 0x0000aa
25	COLOR_BG_SELECTED = 0xec9300	25	COLOR_BG_SELECTED = 0xec9300
26	COLOR_LINE = 0x00b9a0	26	COLOR_LINE = 0x00b9a0
27	COLOR_TXT_NORMAL = 0xffffff	27	COLOR_TXT_NORMAL = 0xffffff
28	COLOR_TXT_INACTIVE = 0x8f7948	28	COLOR_TXT_INACTIVE = 0x8f7948
29	COLOR_TXT_CHANGED = 0xec9300	29	COLOR_TXT_CHANGED = 0xec9300
30	COLOR_TXT_LABEL = 0x22b14c	30	COLOR_TXT_LABEL = 0x22b14c
31	COLOR_TXT_SELECTED = 0x1d272f	31	COLOR_TXT_SELECTED = 0x1d272f
32	COLOR_TXT_HEX = 0xec9300	32	COLOR_TXT_HEX = 0xec9300
33	COLOR_TXT_BREAKPOINT = 0xec9300	33	COLOR_TXT_BREAKPOINT = 0xec9300
34		34
35	else if COLOR_THEME eq WHITE_ON_BLACK	35	else if COLOR_THEME eq WHITE_ON_BLACK
36		36
37	COLOR_BG_NORMAL = 0x101010 ; dark grey	37	COLOR_BG_NORMAL = 0x101010 ; dark grey
38	COLOR_BG_BREAKPOINT = 0xFF0000 ; red	38	COLOR_BG_BREAKPOINT = 0xFF0000 ; red
39	COLOR_BG_SELECTED = 0x0000FF ; blue	39	COLOR_BG_SELECTED = 0x0000FF ; blue
40	COLOR_LINE = 0xFFFFFF ; white	40	COLOR_LINE = 0xFFFFFF ; white
41	COLOR_TXT_NORMAL = 0xFFFFFF ; white	41	COLOR_TXT_NORMAL = 0xFFFFFF ; white
42	COLOR_TXT_INACTIVE = 0x808080 ; grey	42	COLOR_TXT_INACTIVE = 0x808080 ; grey
43	COLOR_TXT_CHANGED = 0x00AA00 ; green	43	COLOR_TXT_CHANGED = 0x00AA00 ; green
44	COLOR_TXT_LABEL = COLOR_TXT_NORMAL	44	COLOR_TXT_LABEL = COLOR_TXT_NORMAL
45	COLOR_TXT_SELECTED = 0xFFFFFF ; white	45	COLOR_TXT_SELECTED = 0xFFFFFF ; white
46	COLOR_TXT_HEX = COLOR_TXT_NORMAL	46	COLOR_TXT_HEX = COLOR_TXT_NORMAL
47	COLOR_TXT_BREAKPOINT = COLOR_TXT_NORMAL	47	COLOR_TXT_BREAKPOINT = COLOR_TXT_NORMAL
48		48
49	else ; BLACK ON WHITE	49	else ; BLACK ON WHITE
50		50
51	COLOR_BG_NORMAL = 0xffffff ; white	51	COLOR_BG_NORMAL = 0xffffff ; white
52	COLOR_BG_BREAKPOINT = 0xFF0000 ; red	52	COLOR_BG_BREAKPOINT = 0xFF0000 ; red
53	COLOR_BG_SELECTED = 0x0000FF ; blue	53	COLOR_BG_SELECTED = 0x0000FF ; blue
54	COLOR_LINE = 0x000000 ; black	54	COLOR_LINE = 0x000000 ; black
55	COLOR_TXT_NORMAL = 0x000000 ; black	55	COLOR_TXT_NORMAL = 0x000000 ; black
56	COLOR_TXT_INACTIVE = 0x808080 ; grey	56	COLOR_TXT_INACTIVE = 0x808080 ; grey
57	COLOR_TXT_CHANGED = 0x00AA00 ; green	57	COLOR_TXT_CHANGED = 0x00AA00 ; green
58	COLOR_TXT_LABEL = COLOR_TXT_NORMAL	58	COLOR_TXT_LABEL = COLOR_TXT_NORMAL
59	COLOR_TXT_SELECTED = 0xFFFFFF ; white	59	COLOR_TXT_SELECTED = 0xFFFFFF ; white
60	COLOR_TXT_HEX = COLOR_TXT_NORMAL	60	COLOR_TXT_HEX = COLOR_TXT_NORMAL
61	COLOR_TXT_BREAKPOINT = COLOR_TXT_NORMAL	61	COLOR_TXT_BREAKPOINT = COLOR_TXT_NORMAL
62		62
63	end if	63	end if
64		64
65	;-----------------------------------------------------------------------------	65	;-----------------------------------------------------------------------------
66		66
67	data_width equ 80	67	data_width equ 80
68	data_x_pos equ 12	68	data_x_pos equ 12
69	data_x_size equ data_width*6	69	data_x_size equ data_width*6
70		70
71	title_x_pos equ 30	71	title_x_pos equ 30
72	title_y_pos equ 32	72	title_y_pos equ 32
73	title_y_size equ 10	73	title_y_size equ 10
74		74
75	;dump_y_pos equ (registers_y_pos + registers_y_size + 5)	75	;dump_y_pos equ (registers_y_pos + registers_y_size + 5)
76	dump_y_pos equ (title_y_pos + title_y_size)	76	dump_y_pos equ (title_y_pos + title_y_size)
77	dump_height equ 6	77	dump_height equ 6
78	dump_y_size equ (dump_height*10)	78	dump_y_size equ (dump_height*10)
79		79
80	disasm_y_pos equ (dump_y_pos + dump_y_size + 4)	80	disasm_y_pos equ (dump_y_pos + dump_y_size + 4)
81	disasm_height equ 18	81	disasm_height equ 18
82	disasm_y_size equ (disasm_height*10)	82	disasm_y_size equ (disasm_height*10)
83		83
84	messages_width equ data_width	84	messages_width equ data_width
85	messages_height equ 8	85	messages_height equ 8
86	messages_x_pos equ data_x_pos	86	messages_x_pos equ data_x_pos
87	messages_y_pos equ (disasm_y_pos + disasm_y_size + 4)	87	messages_y_pos equ (disasm_y_pos + disasm_y_size + 4)
88	messages_x_size equ messages_width*6	88	messages_x_size equ messages_width*6
89	messages_y_size equ messages_height*10	89	messages_y_size equ messages_height*10
90		90
91	cmdline_width equ data_width	91	cmdline_width equ data_width
92	cmdline_x_pos equ data_x_pos	92	cmdline_x_pos equ data_x_pos
93	cmdline_y_pos equ (messages_y_pos + messages_y_size + 4)	93	cmdline_y_pos equ (messages_y_pos + messages_y_size + 4)
94	cmdline_x_size equ messages_x_size	94	cmdline_x_size equ messages_x_size
95	cmdline_y_size equ 10	95	cmdline_y_size equ 10
96		96
97	registers_x_pos equ (data_x_pos + messages_x_size + 4)	97	registers_x_pos equ (data_x_pos + messages_x_size + 4)
98	registers_y_pos equ (title_y_pos + title_y_size - 3)	98	registers_y_pos equ (title_y_pos + title_y_size - 3)
99	registers_x_size equ 134	99	registers_x_size equ 134
100	registers_y_size equ (cmdline_y_pos + cmdline_y_size - registers_y_pos+1)	100	registers_y_size equ (cmdline_y_pos + cmdline_y_size - registers_y_pos+1)
101		101
102	wnd_x_size equ (data_x_pos + messages_x_size + data_x_pos + registers_x_size+3)	102	wnd_x_size equ (data_x_pos + messages_x_size + data_x_pos + registers_x_size+3)
103	wnd_y_size equ (cmdline_y_pos + cmdline_y_size + data_x_pos)	103	wnd_y_size equ (cmdline_y_pos + cmdline_y_size + data_x_pos)
104		104
105	;-----------------------------------------------------------------------------	105	;-----------------------------------------------------------------------------
106	; Entry point	106	; Entry point
107		107
108	; TODO: split all gui part in independent function, move entry point into mtdbg.asm	108	; TODO: split all gui part in independent function, move entry point into mtdbg.asm
109		109
110	start:	110	start:
111	; initialize process heap	111	; initialize process heap
112	mcall 68, 11	112	mcall 68, 11
113	mov edi, messages	113	mov edi, messages
114	mov ecx, messages_width*messages_height	114	mov ecx, messages_width*messages_height
115	mov al, ' '	115	mov al, ' '
116	rep stosb	116	rep stosb
117	xor eax, eax	117	xor eax, eax
118	mov [messages_pos], eax	118	mov [messages_pos], eax
119	mov [cmdline_len], eax	119	mov [cmdline_len], eax
120	mov [cmdline_pos], eax	120	mov [cmdline_pos], eax
121	mov edi, needzerostart	121	mov edi, needzerostart
122	mov ecx, (needzeroend-needzerostart+3)/4	122	mov ecx, (needzeroend-needzerostart+3)/4
123	rep stosd	123	rep stosd
124	mov esi, begin_str	124	mov esi, begin_str
125	call put_message_nodraw	125	call put_message_nodraw
126	; set event mask - default events and debugging events	126	; set event mask - default events and debugging events
127	mcall 40, 0x107	127	mcall 40, 0x107
128	; set debug messages buffer	128	; set debug messages buffer
129	mov ecx, dbgbufsize	129	mov ecx, dbgbufsize
130	mov dword [ecx], 256	130	mov dword [ecx], 256
131	xor ebx, ebx	131	xor ebx, ebx
132	mov [ecx+4], ebx	132	mov [ecx+4], ebx
133	mov al, 69	133	mov al, 69
134	mcall	134	mcall
135	mov esi, i_param	135	mov esi, i_param
136	call get_arg.skip_spaces	136	call get_arg.skip_spaces
137	test al, al	137	test al, al
138	jz dodraw	138	jz dodraw
139	push esi	139	push esi
140	call draw_window	140	call draw_window
141	pop esi	141	pop esi
142	call OnLoadInit	142	call OnLoadInit
143	jmp waitevent	143	jmp waitevent
144		144
145	dodraw:	145	dodraw:
146	call draw_window	146	call draw_window
147		147
148	waitevent:	148	waitevent:
149	mcall 10	149	mcall 10
150	cmp al, 9	150	cmp al, 9
151	jz debugmsg	151	jz debugmsg
152	dec eax	152	dec eax
153	jz dodraw	153	jz dodraw
154	dec eax	154	dec eax
155	jz keypressed	155	jz keypressed
156	dec eax	156	dec eax
157	jnz waitevent	157	jnz waitevent
158	; button pressed - we have only one button (close)	158	; button pressed - we have only one button (close)
159	mcall -1	159	mcall -1
160		160
161	; TODO: split in more independent function	161	; TODO: split in more independent function
162	keypressed:	162	keypressed:
163	mov al, 2	163	mov al, 2
164	mcall	164	mcall
165	shr eax, 8	165	shr eax, 8
166	cmp al, 8	166	cmp al, 8
167	jz .backspace	167	jz .backspace
168	cmp al, 0xB0	168	cmp al, 0xB0
169	jz .left	169	jz .left
170	cmp al, 0xB3	170	cmp al, 0xB3
171	jz .right	171	jz .right
172	cmp al, 0x0D	172	cmp al, 0x0D
173	jz .enter	173	jz .enter
174	cmp al, 0xB6	174	cmp al, 0xB6
175	jz .del	175	jz .del
176	cmp al, 0xB4	176	cmp al, 0xB4
177	jz .home	177	jz .home
178	cmp al, 0xB5	178	cmp al, 0xB5
179	jz .end	179	jz .end
180	cmp al, 0xB1	180	cmp al, 0xB1
181	jz .down	181	jz .down
182	cmp al, 0xB2	182	cmp al, 0xB2
183	jz .up	183	jz .up
184	cmp ah, 0x41	184	cmp ah, 0x41
185	jz F7	185	jz F7
186	cmp ah, 0x42	186	cmp ah, 0x42
187	jz F8	187	jz F8
188	cmp [cmdline_len], cmdline_width	188	cmp [cmdline_len], cmdline_width
189	jae waitevent	189	jae waitevent
190	push eax	190	push eax
191	call clear_cmdline_end	191	call clear_cmdline_end
192	pop eax	192	pop eax
193	mov edi, cmdline	193	mov edi, cmdline
194	mov ecx, [cmdline_len]	194	mov ecx, [cmdline_len]
195	add edi, ecx	195	add edi, ecx
196	lea esi, [edi-1]	196	lea esi, [edi-1]
197	sub ecx, [cmdline_pos]	197	sub ecx, [cmdline_pos]
198	std	198	std
199	rep movsb	199	rep movsb
200	cld	200	cld
201	stosb	201	stosb
202	inc [cmdline_len]	202	inc [cmdline_len]
203	call draw_cmdline_end	203	call draw_cmdline_end
204	inc [cmdline_pos]	204	inc [cmdline_pos]
205	call draw_cursor	205	call draw_cursor
206	jmp waitevent	206	jmp waitevent
207		207
208	.backspace:	208	.backspace:
209	cmp [cmdline_pos], 0	209	cmp [cmdline_pos], 0
210	jz waitevent	210	jz waitevent
211	dec [cmdline_pos]	211	dec [cmdline_pos]
212		212
213	.delchar:	213	.delchar:
214	call clear_cmdline_end	214	call clear_cmdline_end
215	mov edi, [cmdline_pos]	215	mov edi, [cmdline_pos]
216	dec [cmdline_len]	216	dec [cmdline_len]
217	mov ecx, [cmdline_len]	217	mov ecx, [cmdline_len]
218	sub ecx, edi	218	sub ecx, edi
219	add edi, cmdline	219	add edi, cmdline
220	lea esi, [edi+1]	220	lea esi, [edi+1]
221	rep movsb	221	rep movsb
222	call draw_cmdline_end	222	call draw_cmdline_end
223	call draw_cursor	223	call draw_cursor
224	jmp waitevent	224	jmp waitevent
225		225
226	.del:	226	.del:
227	mov eax, [cmdline_pos]	227	mov eax, [cmdline_pos]
228	cmp eax, [cmdline_len]	228	cmp eax, [cmdline_len]
229	jae waitevent	229	jae waitevent
230	jmp .delchar	230	jmp .delchar
231		231
232	.left:	232	.left:
233	cmp [cmdline_pos], 0	233	cmp [cmdline_pos], 0
234	jz waitevent	234	jz waitevent
235	call hide_cursor	235	call hide_cursor
236	dec [cmdline_pos]	236	dec [cmdline_pos]
237	call draw_cursor	237	call draw_cursor
238	jmp waitevent	238	jmp waitevent
239		239
240	.right:	240	.right:
241	mov eax, [cmdline_pos]	241	mov eax, [cmdline_pos]
242	cmp eax, [cmdline_len]	242	cmp eax, [cmdline_len]
243	jae waitevent	243	jae waitevent
244	call hide_cursor	244	call hide_cursor
245	inc [cmdline_pos]	245	inc [cmdline_pos]
246	call draw_cursor	246	call draw_cursor
247	jmp waitevent	247	jmp waitevent
248		248
249	.home:	249	.home:
250	call hide_cursor	250	call hide_cursor
251	and [cmdline_pos], 0	251	and [cmdline_pos], 0
252	call draw_cursor	252	call draw_cursor
253	jmp waitevent	253	jmp waitevent
254		254
255	.end:	255	.end:
256	call hide_cursor	256	call hide_cursor
257	mov eax, [cmdline_len]	257	mov eax, [cmdline_len]
258	mov [cmdline_pos], eax	258	mov [cmdline_pos], eax
259	call draw_cursor	259	call draw_cursor
260		260
261	.up:	261	.up:
262	.down:	262	.down:
263	jmp waitevent	263	jmp waitevent
264		264
265	; We also trying to execute previous command, if empty command_line	265	; We also trying to execute previous command, if empty command_line
266	.enter:	266	.enter:
267	mov ecx, [cmdline_len]	267	mov ecx, [cmdline_len]
268	test ecx, ecx	268	test ecx, ecx
269	jnz .exec_cur	269	jnz .exec_cur
270	mov cl, byte [cmdline_prev]	270	mov cl, byte [cmdline_prev]
271	cmp cl, 0	271	cmp cl, 0
272	jz waitevent	272	jz waitevent
273		273
274	.exec_prev:	274	.exec_prev:
275	mov esi, cmdline_prev	275	mov esi, cmdline_prev
276	jmp .exec	276	jmp .exec
277		277
278	.exec_cur:	278	.exec_cur:
279	mov esi, cmdline	279	mov esi, cmdline
280		280
281	.exec:	281	.exec:
282	mov byte [esi+ecx], 0	282	mov byte [esi+ecx], 0
283	and [cmdline_pos], 0	283	and [cmdline_pos], 0
284	push esi	284	push esi
285	call clear_cmdline_end	285	call clear_cmdline_end
286	call draw_cursor	286	call draw_cursor
287	pop esi	287	pop esi
288	and [cmdline_len], 0	288	and [cmdline_len], 0
289	; skip leading spaces	289	; skip leading spaces
290	call get_arg.skip_spaces	290	call get_arg.skip_spaces
291	cmp al, 0	291	cmp al, 0
292	jz waitevent	292	jz waitevent
293	; now esi points to command	293	; now esi points to command
294	push esi	294	push esi
295	mov esi, prompt	295	mov esi, prompt
296	call put_message_nodraw	296	call put_message_nodraw
297	pop esi	297	pop esi
298	push esi	298	push esi
299	call put_message_nodraw	299	call put_message_nodraw
300		300
301	; TODO: add meaningful name	301	; TODO: add meaningful name
302	z1:	302	z1:
303	mov esi, newline	303	mov esi, newline
304	call put_message	304	call put_message
305	pop esi	305	pop esi
306	push esi	306	push esi
307	call get_arg	307	call get_arg
308	mov [curarg], esi	308	mov [curarg], esi
309	pop edi	309	pop edi
310	mov esi, commands	310	mov esi, commands
311	call find_cmd	311	call find_cmd
312	mov eax, aUnknownCommand	312	mov eax, aUnknownCommand
313	jc .x11	313	jc .x11
314		314
315	; check command requirements	315	; check command requirements
316	; flags field:	316	; flags field:
317	; &1: command may be called without parameters	317	; &1: command may be called without parameters
318	; &2: command may be called with parameters	318	; &2: command may be called with parameters
319	; &4: command may be called without loaded program	319	; &4: command may be called without loaded program
320	; &8: command may be called with loaded program	320	; &8: command may be called with loaded program
321	mov eax, [esi+8]	321	mov eax, [esi+8]
322	mov ecx, [curarg]	322	mov ecx, [curarg]
323	cmp byte [ecx], 0	323	cmp byte [ecx], 0
324	jz .noargs	324	jz .noargs
325	test byte [esi+16], 2	325	test byte [esi+16], 2
326	jz .x11	326	jz .x11
327	jmp @f	327	jmp @f
328		328
329	.noargs:	329	.noargs:
330	test byte [esi+16], 1	330	test byte [esi+16], 1
331	jz .x11	331	jz .x11
332		332
333	@@:	333	@@:
334	cmp [debuggee_pid], 0	334	cmp [debuggee_pid], 0
335	jz .nodebuggee	335	jz .nodebuggee
336	mov eax, aAlreadyLoaded	336	mov eax, aAlreadyLoaded
337	test byte [esi+16], 8	337	test byte [esi+16], 8
338	jz .x11	338	jz .x11
339	jmp .x9	339	jmp .x9
340		340
341	.nodebuggee:	341	.nodebuggee:
342	mov eax, need_debuggee	342	mov eax, need_debuggee
343	test byte [esi+16], 4	343	test byte [esi+16], 4
344	jnz .x9	344	jnz .x9
345		345
346	.x11:	346	.x11:
347	xchg esi, eax	347	xchg esi, eax
348	call put_message	348	call put_message
349		349
350	; store cmdline for repeating	350	; store cmdline for repeating
351	.x10:	351	.x10:
352	mov esi, cmdline	352	mov esi, cmdline
353	mov ecx, [cmdline_len]	353	mov ecx, [cmdline_len]
354		354
355	@@:	355	@@:
356	cmp ecx, 0	356	cmp ecx, 0
357	jle .we	357	jle .we
358	mov al, [esi + ecx]	358	mov al, [esi + ecx]
359	mov [cmdline_prev + ecx], al	359	mov [cmdline_prev + ecx], al
360	dec ecx	360	dec ecx
361	jmp @b	361	jmp @b
362		362
363	.we:	363	.we:
364	mov [cmdline_len], 0	364	mov [cmdline_len], 0
365	jmp waitevent	365	jmp waitevent
366		366
367	.x9:	367	.x9:
368	call dword [esi+4]	368	call dword [esi+4]
369	jmp .x10	369	jmp .x10
370		370
371	;-----------------------------------------------------------------------------	371	;-----------------------------------------------------------------------------
372	; Cmdline handling	372	; Cmdline handling
373		373
374	clear_cmdline_end:	374	clear_cmdline_end:
375	mov ebx, [cmdline_pos]	375	mov ebx, [cmdline_pos]
376	mov ecx, [cmdline_len]	376	mov ecx, [cmdline_len]
377	sub ecx, ebx	377	sub ecx, ebx
378	imul ebx, 6	378	imul ebx, 6
379	imul ecx, 6	379	imul ecx, 6
380	inc ecx	380	inc ecx
381	add ebx, cmdline_x_pos	381	add ebx, cmdline_x_pos
382	shl ebx, 16	382	shl ebx, 16
383	or ebx, ecx	383	or ebx, ecx
384	mov ecx, cmdline_y_pos*10000h + cmdline_y_size	384	mov ecx, cmdline_y_pos*10000h + cmdline_y_size
385	mov edx, COLOR_BG_NORMAL	385	mov edx, COLOR_BG_NORMAL
386	; draw container rectangle/box for cmdline	386	; draw container rectangle/box for cmdline
387	mcall 13	387	mcall 13
388	ret	388	ret
389		389
390	draw_cmdline:	390	draw_cmdline:
391	xor ebx, ebx	391	xor ebx, ebx
392	jmp @f	392	jmp @f
393		393
394	; TODO: make it local	394	; TODO: make it local
395	draw_cmdline_end:	395	draw_cmdline_end:
396	mov ebx, [cmdline_pos]	396	mov ebx, [cmdline_pos]
397		397
398	@@:	398	@@:
399	mov esi, [cmdline_len]	399	mov esi, [cmdline_len]
400	sub esi, ebx	400	sub esi, ebx
401		401
402	mov ecx, COLOR_TXT_NORMAL	402	mov ecx, COLOR_TXT_NORMAL
403	lea edx, [cmdline+ebx]	403	lea edx, [cmdline+ebx]
404	imul ebx, 6	404	imul ebx, 6
405	add ebx, cmdline_x_pos	405	add ebx, cmdline_x_pos
406	shl ebx, 16	406	shl ebx, 16
407	or ebx, cmdline_y_pos+1	407	or ebx, cmdline_y_pos+1
408	; draw a text string in the window	408	; draw a text string in the window
409	mcall 4	409	mcall 4
410	ret	410	ret
411		411
412	;-----------------------------------------------------------------------------	412	;-----------------------------------------------------------------------------
413	; Working with messages	413	; Working with messages
414	; in: esi->ASCIIZ message	414	; in: esi->ASCIIZ message
415	put_message_nodraw:	415	put_message_nodraw:
416	mov edx, [messages_pos]	416	mov edx, [messages_pos]
417		417
418	.m:	418	.m:
419	lea edi, [messages+edx]	419	lea edi, [messages+edx]
420		420
421	.l:	421	.l:
422	lodsb	422	lodsb
423	cmp al, 0	423	cmp al, 0
424	jz .done	424	jz .done
425	call test_scroll	425	call test_scroll
426	cmp al, 10	426	cmp al, 10
427	jz .newline	427	jz .newline
428	cmp al, '%'	428	cmp al, '%'
429	jnz @f	429	jnz @f
430	cmp dword [esp], z1	430	cmp dword [esp], z1
431	jnz .format	431	jnz .format
432		432
433	@@:	433	@@:
434	stosb	434	stosb
435	inc edx	435	inc edx
436	jmp .l	436	jmp .l
437		437
438	.newline:	438	.newline:
439	push edx	439	push edx
440	mov ecx, messages_width	440	mov ecx, messages_width
441	xor eax, eax	441	xor eax, eax
442	xchg eax, edx	442	xchg eax, edx
443	div ecx	443	div ecx
444	xchg eax, edx	444	xchg eax, edx
445	pop edx	445	pop edx
446	test eax, eax	446	test eax, eax
447	jz .m	447	jz .m
448	sub edx, eax	448	sub edx, eax
449	add edx, ecx	449	add edx, ecx
450	jmp .m	450	jmp .m
451		451
452	.done:	452	.done:
453	mov [messages_pos], edx	453	mov [messages_pos], edx
454	ret	454	ret
455		455
456	; at this moment all format specs must be %X	456	; at this moment all format specs must be %X
457	.format:	457	.format:
458	lodsb ; get	458	lodsb ; get
459	sub al, '0'	459	sub al, '0'
460	movzx ecx, al	460	movzx ecx, al
461	lodsb	461	lodsb
462	pop eax	462	pop eax
463	pop ebp	463	pop ebp
464	push eax	464	push eax
465	; write number in ebp with ecx digits	465	; write number in ebp with ecx digits
466	dec ecx	466	dec ecx
467	shl ecx, 2	467	shl ecx, 2
468		468
469	.writenibble:	469	.writenibble:
470	push ecx	470	push ecx
471	call test_scroll	471	call test_scroll
472	pop ecx	472	pop ecx
473	mov eax, ebp	473	mov eax, ebp
474	shr eax, cl	474	shr eax, cl
475	and al, 0xF	475	and al, 0xF
476	cmp al, 10	476	cmp al, 10
477	sbb al, 69h	477	sbb al, 69h
478	das	478	das
479	stosb	479	stosb
480	inc edx	480	inc edx
481	sub ecx, 4	481	sub ecx, 4
482	jns .writenibble	482	jns .writenibble
483	jmp .l	483	jmp .l
484		484
485	test_scroll:	485	test_scroll:
486	cmp edx, messages_width*messages_height	486	cmp edx, messages_width*messages_height
487	jnz .ret	487	jnz .ret
488	push esi	488	push esi
489	mov edi, messages	489	mov edi, messages
490	lea esi, [edi+messages_width]	490	lea esi, [edi+messages_width]
491	mov ecx, (messages_height-1)*messages_width/4	491	mov ecx, (messages_height-1)*messages_width/4
492	rep movsd	492	rep movsd
493	push eax	493	push eax
494	mov al, ' '	494	mov al, ' '
495	push edi	495	push edi
496	push messages_width	496	push messages_width
497	pop ecx	497	pop ecx
498	sub edx, ecx	498	sub edx, ecx
499	rep stosb	499	rep stosb
500	pop edi	500	pop edi

Subversion Repositories Kolibri OS

(root)/programs/develop/mtdbg/gui.inc – Rev 4895 → 4900