WebSVN – Kolibri OS – Diff – /programs/develop/mtdbg/mtdbg.asm


format binary
include '../../macros.inc'
use32
	db	'MENUET01'
	dd	1
	dd	start
	dd	i_end
	dd	used_mem
	dd	used_mem
	dd	i_param
	dd	0
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; GUI ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
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
 
registers_x_pos equ data_x_pos
registers_y_pos equ (title_y_pos + title_y_size)
registers_y_size equ 30
 
dump_y_pos equ (registers_y_pos + registers_y_size + 5)
dump_height equ 4
dump_y_size equ (dump_height*10)
 
disasm_y_pos equ (dump_y_pos + dump_y_size + 4)
disasm_height equ 16
disasm_y_size equ (disasm_height*10)
 
messages_width equ data_width
messages_height equ 12
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 + 10)
cmdline_x_size equ messages_x_size
cmdline_y_size equ 10
 
wnd_x_size equ (data_x_pos + messages_x_size + data_x_pos)
wnd_y_size equ (cmdline_y_pos + cmdline_y_size + data_x_pos)
 
start:
	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
	push	40
	pop	eax
	mov	ebx, 0x107
	mcall
; 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	skip_spaces
	test	al, al
	jz	dodraw
	push	esi
	call	draw_window
	pop	esi
	call	OnLoadInit
	jmp	waitevent
dodraw:
	call	draw_window
waitevent:
	push	10
	pop	eax
	mcall
	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)
	push	-1
	pop	eax
	mcall
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	al, 0xD8
	jz	CtrlF7
	cmp	al, 0xD9
	jz	CtrlF8
	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
.enter:
	mov	ecx, [cmdline_len]
	test	ecx, ecx
	jz	waitevent
	mov	esi, cmdline
	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	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
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
.x10:
	jmp	waitevent
.x9:
	call	dword [esi+4]
	jmp	.x10
 
find_cmd:
; all commands are case-insensitive
	push	edi
.x4:
	mov	al, [edi]
	cmp	al, 0
	jz	.x5
	cmp	al, 'A'
	jb	@f
	cmp	al, 'Z'
	ja	@f
	or	al, 20h
@@:
	stosb
	jmp	.x4
.x5:
; find command
	pop	edi
.x6:
	cmp	dword [esi], 0
	jz	.x7
	push	esi
	mov	esi, [esi]
	lodsb
	movzx	ecx, al
	push	edi
	repz	cmpsb
	pop	edi
	pop	esi
	jz	.x8
	add	esi, 17
	jmp	.x6
.x7:
	stc
.x8:
	ret
 
get_arg:
	lodsb
	cmp	al, ' '
	ja	get_arg
	mov	byte [esi-1], 0
	cmp	al, 0
	jnz	skip_spaces
	dec	esi
skip_spaces:
	lodsb
	cmp	al, 0
	jz	@f
	cmp	al, ' '
	jbe	skip_spaces
@@:	dec	esi
	ret
 
clear_cmdline_end:
	mov	ebx, [cmdline_pos]
	mov	ecx, [cmdline_len]
	sub	ecx, ebx
	push	13
	pop	eax
	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, 0xFFFFFF
	mcall
	ret
 
draw_cmdline:
	xor	ebx, ebx
	jmp	@f
draw_cmdline_end:
	mov	ebx, [cmdline_pos]
@@:
	mov	esi, [cmdline_len]
	sub	esi, ebx
	push	4
	pop	eax
	xor	ecx, ecx
	lea	edx, [cmdline+ebx]
	imul	ebx, 6
	add	ebx, cmdline_x_pos
	shl	ebx, 16
	or	ebx, cmdline_y_pos+1
	mcall
	ret
 
put_message_nodraw:
; in: esi->ASCIZ message
	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
.format:
; at moment all format specs must be %X
	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:
	push	13
	pop	eax
	mov	edx, 0xFFFFFF
	mov	ebx, messages_x_pos*10000h+messages_x_size
	mov	ecx, messages_y_pos*10000h+messages_y_size
	mcall
	mov	edx, messages
	push	messages_width
	pop	esi
	xor	ecx, ecx
	mov	al, 4
	mov	ebx, messages_x_pos*10000h+messages_y_pos
@@:
	mcall
	add	edx, esi
	add	ebx, 10
	cmp	edx, messages+messages_width*messages_height
	jb	@b
	ret
 
draw_cursor:
	push	38
	pop	eax
	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
	xor	edx, edx
	mcall
	ret
hide_cursor:
	mov	ebx, [cmdline_pos]
	push	13
	pop	eax
	imul	ebx, 6
	add	ebx, cmdline_x_pos
	shl	ebx, 16
	inc	ebx
	mov	ecx, cmdline_y_pos*10000h + cmdline_y_size
	mov	edx, 0xFFFFFF
	mcall
	mov	ebx, [cmdline_pos]
	cmp	ebx, [cmdline_len]
	jae	.ret
	mov	al, 4
	xor	ecx, ecx
	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
	mcall
.ret:
	ret
 
redraw_title:
	push	13
	pop	eax
	mov	edx, 0xFFFFFF
	mov	ebx, title_x_pos*10000h + data_x_pos+data_x_size-title_x_pos
	mov	ecx, title_y_pos*10000h + title_y_size
	mcall
draw_title:
	mov	al, 38
	mov	ebx, (data_x_pos-2)*10000h + title_x_pos-5
	mov	ecx, (title_y_pos+5)*10001h
	xor	edx, edx
	mcall
	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
@@:
	mcall
	mov	ebx, (data_x_pos+data_x_size-10+4)*0x10000 + data_x_pos+data_x_size+2
	mcall
	mov	al, 4
	mov	ebx, title_x_pos*10000h+title_y_pos
	xor	ecx, ecx
	mov	edx, NoPrgLoaded_str
	cmp	[debuggee_pid], 0
	jz	@f
	mov	edx, [prgname_ptr]
@@:
	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
@@:
	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
	xor	edx, edx
	jmp	@b
 
draw_register:
; in: esi->value, edx->string, ecx=string len, ebx=coord
	push	edx
	push	ecx
	push	esi
	mov	eax, esi
	mov	esi, ecx
; color
	mov	ecx, 40808080h
	cmp	[debuggee_pid], 0
	jz	.cd
	cmp	[bSuspended], 0
	jz	.cd
	mov	ecx, 40000000h
	push	edi
	mov	edi, [eax]
	cmp	dword [eax+oldcontext-context], edi
	pop	edi
	jz	.cd
	mov	ecx, 0x4000AA00
.cd:
	push	4
	pop	eax
	mcall
	imul	esi, 60000h
	lea	edx, [ebx+esi]
	mov	al, 47
	mov	ebx, 80101h
	mov	esi, ecx
	pop	ecx
	mcall
	lea	ebx, [edx+60000h*18]
	mov	esi, ecx
	pop	ecx
	pop	edx
	add	edx, ecx
	ret
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, 40808080h
	cmp	[debuggee_pid], 0
	jz	.doit
	cmp	[bSuspended], 0
	jz	.doit
	mov	ecx, 40000000h
	bt	[_eflags], edi
	lahf
	bt	dword [_eflags + oldcontext - context], edi
	rcl	ah, 1
	test	ah, 3
	jp	.doit
	mov	ecx, 0x4000AA00
.doit:
	mov	ah, 0
	mov	edi, 0xFFFFFF
	mcall
	ret
 
draw_registers:
	push	13
	pop	eax
	mov	edx, 0xFFFFFF
	mov	ebx, data_x_pos*10000h + data_x_size
	mov	ecx, registers_y_pos*10000h + registers_y_size
	mcall
redraw_registers:
	mov	edi, 0xFFFFFF
	mov	esi, _eax
	push	4
	pop	ecx
	mov	edx, regs_strs
	mov	ebx, registers_x_pos*10000h+registers_y_pos
	call	draw_register
	add	esi, _ebx-_eax
	call	draw_register
	add	esi, _ecx-_ebx
	call	draw_register
	add	esi, _edx-_ecx
	call	draw_register
	mov	ebx, registers_x_pos*10000h+registers_y_pos+10
	add	esi, _esi-_edx
	call	draw_register
	add	esi, _edi-_esi
	call	draw_register
	add	esi, _ebp-_edi
	call	draw_register
	add	esi, _esp-_ebp
	call	draw_register
	mov	ebx, registers_x_pos*10000h+registers_y_pos+20
	add	esi, _eip-_esp
	call	draw_register
	mov	cl, 7
	add	esi, _eflags-_eip
	call	draw_register
	mov	al, 4
	mov	ecx, 808080h
	cmp	[debuggee_pid], 0
	jz	@f
	cmp	[bSuspended], 0
	jz	@f
	xor	ecx, ecx
@@:
	mov	edx, aColon
	xor	esi, esi
	inc	esi
	mov	ebx, (registers_x_pos+37*6)*10000h + registers_y_pos+20
	mcall
	mov	edx, flags
@@:
	add	ebx, 2*6*10000h
	call	draw_flag
	inc	edx
	cmp	dl, flags_bits and 0xFF
	jnz	@b
	ret
 
draw_dump:
	push	13
	pop	eax
	mov	edx, 0xFFFFFF
	mov	ebx, data_x_pos*10000h + data_x_size
	mov	ecx, dump_y_pos*10000h + dump_y_size
	mcall
redraw_dump:
; addresses
	mov	al, 47
	mov	ebx, 80100h
	mov	edx, data_x_pos*10000h + dump_y_pos
	mov	ecx, [dumppos]
	mov	edi, 0xFFFFFF
	mov	esi, 40808080h
	cmp	[debuggee_pid], 0
	jz	@f
	cmp	[bSuspended], 0
	jz	@f
	mov	esi, 40000000h
@@:
	mcall
	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
	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
	mov	ecx, esi
	xchg	ebx, edx
	push	2
	pop	esi
.hexdumploop2:
	cmp	edx, dump_height*10h
	jae	.hexdumpdone2
	push	edx
	mov	edx, aQuests
	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
@@:
	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
 
redraw_disasm:
;	push	13
;	pop	eax
;	mov	edx, 0xFFFFFF
;	mov	ebx, data_x_pos*10000h + data_x_size
;	mov	ecx, (disasm_y_pos-1)*10000h + (disasm_y_size+1)
;	mcall
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
	mov	edx, 0xFFFFFF
	mov	ebx, data_x_pos*10000h + data_x_size
	push	13
	pop	eax
	mcall
	pop	ebx
	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
	mov	ecx, 40000000h
 
 
	mov	al, 4
	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
	mov	edx, edi
	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
	xor	esi, esi	; default color: black
	mov	edx, 0xFFFFFF	; default background: white
	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	.nored
	mov	edx, 0xFF0000	; use background: red
.nored:
	mov	eax, [_eip]
	cmp	eax, ebp
	jnz	.noblue
	mov	edx, 0x0000FF	; use background: blue
	mov	esi, 0xFFFFFF	; on blue bgr, use white color
.noblue:
	push	13
	pop	eax
	mcall
	mov	al, 47
	mov	ebx, 80100h
	mov	edx, [disasm_cur_str]
	imul	edx, 10
	add	edx, data_x_pos*10000h + disasm_y_pos
	mov	ecx, ebp
	mcall
	mov	al, 4
	lea	ebx, [edx+8*6*10000h]
	mov	ecx, esi
	push	2
	pop	esi
	mov	edx, aColon
	mcall
	push	9
	pop	edi
	lea	edx, [ebx+2*6*10000h]
	mov	esi, ecx
	mov	ecx, ebp
	sub	ecx, [disasm_start_pos]
	add	ecx, disasm_buffer
.drawhex:
	mov	al, 47
	mov	ebx, 20101h
	mcall
	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
	mov	al, 4
	lea	ebx, [edx-6*10000h]
	mov	ecx, esi
	push	3
	pop	esi
	mov	edx, aDots
	mcall
	mov	esi, ecx
.hexdone:
	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
	mov	al, 4
	mcall
	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
	push	13
	pop	eax
	mov	ebx, data_x_pos*65536 + data_x_size
	mov	edx, 0xFFFFFF
	mcall
@@:
	ret
 
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	redraw_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
	push	69
	pop	eax
	push	6
	pop	ebx
	mov	ecx, [debuggee_pid]
	mov	edi, disasm_buffer
	mov	edx, 256
	mov	esi, [disasm_start_pos]
	mcall
	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	redraw_disasm
 
draw_window:
; start redraw
	push	12
	pop	eax
	push	1
	pop	ebx
	mcall
; define window
	xor	eax, eax
	mov	ebx, wnd_x_size
	mov	ecx, wnd_y_size
	mov	edx, 54FFFFFFh
	mov	edi, caption_str
	mcall
; clear unused areas
	mov	al, 48
	push	4
	pop	ebx
	mcall
	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)
	push	13
	pop	eax
	mcall
	mov	ecx, (registers_y_pos+registers_y_size)*10000h + (dump_y_pos-registers_y_pos-registers_y_size)
	mcall
	mov	ecx, (dump_y_pos+dump_y_size)*10000h + (disasm_y_pos-dump_y_pos-dump_y_size)
	mcall
	mov	ecx, (disasm_y_pos-1+disasm_y_size)*10000h + (messages_y_pos-disasm_y_pos+1-disasm_y_size)
	mcall
	mov	ecx, (messages_y_pos+messages_y_size)*10000h + (wnd_y_size-messages_y_pos-messages_y_size-4)
	mcall
	mov	ebx, 5*10000h + (data_x_pos-5)
	pop	ecx
	imul	ecx, 10001h
	sub	cx, wnd_y_size-4
	neg	cx
	mcall
	mov	ebx, (data_x_pos+data_x_size)*10000h + (wnd_x_size-data_x_pos-data_x_size-4)
	mcall
; messages frame
	mov	al, 38
	mov	ebx, (messages_x_pos-2)*10000h + (messages_x_pos+messages_x_size+2)
	push	ebx
	mov	ecx, (messages_y_pos-2)*10001h
	xor	edx, edx
	mcall
	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
; messages
	call	draw_messages
; command line & cursor
	call	draw_cmdline
	call	draw_cursor
; title & registers & dump & disasm
	mov	al, 38
	mov	ebx, (data_x_pos-2)*10001h
	mov	ecx, (title_y_pos+5)*10000h + (messages_y_pos-2)
	mcall
	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, (dump_y_pos-3)*10001h
	mcall
	mov	ecx, (disasm_y_pos-4)*10001h
	mcall
	call	redraw_title
	call	draw_registers
	call	draw_dump
	call	redraw_disasm
; end redraw
	push	12
	pop	eax
	push	2
	pop	ebx
	mcall
	ret
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; DEBUGGING ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
OnHelp:
	mov	esi, help_msg
	mov	edi, [curarg]
	cmp	byte [edi], 0
	jz	.x
	mov	esi, help_groups
	call	find_cmd
	jc	.nocmd
	mov	esi, [esi+12]
.x:
	jmp	put_message
.nocmd:
	mov	esi, aUnknownCommand
	jmp	.x
 
OnQuit:
	push	-1
	pop	eax
	mcall
 
get_new_context:
	mov	esi, context
	mov	edi, oldcontext
	mov	ecx, 10
	rep	movsd
get_context:
	push	1
	pop	ebx
	push	69
	pop	eax
	mov	ecx, [debuggee_pid]
	mov	esi, context
	push	28h
	pop	edx
	mcall
	ret
set_context:
	push	2
	pop	ebx
	push	69
	pop	eax
	mov	ecx, [debuggee_pid]
	mov	esi, context
	push	28h
	pop	edx
	mcall
	ret
 
get_dump:
	mov	edi, dumpdata
	mov	esi, [edi-4]
	mov	edx, dump_height*10h
	mov	ecx, edx
	xor	eax, eax
	push	edi
	rep	stosb
	pop	edi
	mov	ecx, [debuggee_pid]
	mov	al, 69
	push	6
	pop	ebx
	mcall
	cmp	eax, -1
	jnz	@f
	mov	esi, read_mem_err
	call	put_message
	xor	eax, eax
@@:
	mov	[edi-8], eax
;	call	restore_from_breaks
;	ret
restore_from_breaks:
; in: edi=buffer,eax=size,esi=address
	mov	ebx, breakpoints
@@:
	test	byte [ebx+4], 1
	jz	.cont		; ignore invalid
	test	byte [ebx+4], 2 or 8
	jnz	.cont		; ignore disabled and memory breaks
	mov	ecx, [ebx]
	sub	ecx, esi
	cmp	ecx, eax
	jae	.cont
	mov	dl, [ebx+5]
	mov	[edi+ecx], dl
.cont:
	add	ebx, 6
	cmp	ebx, breakpoints+breakpoints_n*6
	jb	@b
	ret
 
OnLoad:
	mov	esi, [curarg]
OnLoadInit:
	mov	edi, loadname
	or	[prgname_len], -1
	mov	[prgname_ptr], edi
.copyname:
	lodsb
	stosb
	inc	[prgname_len]
	cmp	al, '/'
	jnz	@f
	or	[prgname_len], -1
	mov	[prgname_ptr], edi
@@:
	cmp	al, ' '
	ja	.copyname
	mov	byte [edi-1], 0
	and	[load_params], 0
	dec	esi
	call	skip_spaces
	cmp	al, 0
	jz	@f
	mov	[load_params], esi
@@:
	and	[dumppos], 0
	mov	ecx, [symbols]
	jecxz	do_reload
	mcall	68, 13
	and	[symbols], 0
	and	[num_symbols], 0
do_reload:
	push	18
	pop	eax
	push	7
	pop	ebx
	mcall
	mov	[dbgwnd], eax
	xchg	ecx, eax
	push	70
	pop	eax
	mov	ebx, fn70_load_block
	mcall
	test	eax, eax
	jns	.load_ok
.load_err:
	push	eax
	mov	esi, load_err_msg
	call	put_message
	pop	eax
	not	eax
	cmp	eax, 0x20
	jae	.unk_err
	mov	esi, [load_err_msgs+eax*4]
	test	esi, esi
	jnz	put_message
.unk_err:
	mov	esi, unk_err_msg
	inc	eax
	push	eax
	call	put_message_nodraw
	jmp	draw_messages
.load_ok:
	mov	[debuggee_pid], eax
	mov	[bSuspended], 1
	push	ecx
	call	get_context
	mov	edi, oldcontext
	mov	ecx, 10
	rep	movsd
; activate debugger window
	pop	ecx
	mov	bl, 3
	push	18
	pop	eax
	mcall
	call	redraw_title
	call	redraw_registers
	call	get_dump
	call	redraw_dump
	call	update_disasm_eip_force
	mov	esi, load_succ_msg
	push	[debuggee_pid]
	call	put_message_nodraw
	call	draw_messages
; try to load symbols
	mov	esi, loadname
	mov	edi, symbolsfile
	push	edi
@@:
	lodsb
	stosb
	test	al, al
	jnz	@b
	lea	ecx, [edi-1]
@@:
	dec	edi
	cmp	edi, symbolsfile
	jb	@f
	cmp	byte [edi], '/'
	jz	@f
	cmp	byte [edi], '.'
	jnz	@b
	mov	ecx, edi
@@:
	mov	dword [ecx], '.dbg'
	mov	byte [ecx+4], 0
	pop	esi
	mov	ebp, esi
	call	OnLoadSymbols.silent
; now test for packed progs
	cmp	[disasm_buf_size], 100h
	jz	@f
	ret
@@:
	mov	esi, mxp_nrv_sig
	mov	ebp, disasm_buffer
	mov	edi, ebp
	push	3
	pop	ecx
	repz	cmpsb
	jnz	.not_mxp_nrv
	cmpsb
	mov	cl, mxp_nrv_sig_size-4
	repz	cmpsb
	mov	esi, mxp_nrv_name
	jz	.packed
.not_mxp_nrv:
	mov	esi, mxp_sig
	mov	edi, ebp
	mov	cl, mxp_sig_size
	repz	cmpsb
	mov	esi, mxp_name
	jz	.packed
.not_mxp:
	mov	esi, mxp_lzo_sig1
	mov	edi, ebp
	mov	cl, mxp_lzo_sig1_size
	repz	cmpsb
	mov	esi, mxp_lzo_name
	jz	.packed
	mov	esi, mxp_lzo_sig2
	mov	edi, ebp
	mov	cl, 8
	repz	cmpsb
	jnz	.not_mxp_lzo
	cmpsb
	mov	cl, mxp_lzo_sig2_size - 9
	repz	cmpsb
	mov	esi, mxp_lzo_name
	jz	.packed
.not_mxp_lzo:
	mov	esi, mtappack_name
	cmp	dword [ebp], 0xBF5E246A
	jnz	.not_mtappack
	cmp	dword [ebp+8], 0xEC4E8B57
	jnz	.not_mtappack1
	cmp	dword [ebp+12], 0x8D5EA4F3
	jnz	.not_mtappack1
	cmp	byte [ebp+12h], 0xE9
	jz	.packed
.not_mtappack1:
	cmp	word [ebp+8], 0xB957
	jnz	.not_mtappack
	cmp	dword [ebp+14], 0x575EA4F3
	jnz	.not_mtappack2
	cmp	byte [ebp+17h], 0xE9
	jz	.packed
.not_mtappack2:
	cmp	dword [ebp+14], 0x5F8DA4F3
	jnz	.not_mtappack3
	cmp	word [ebp+18], 0xE9FC
	jz	.packed
.not_mtappack3:
	cmp	word [ebp+14], 0xA4F3
	jnz	.not_mtappack
	cmp	byte [ebp+15h], 0xE9
	jz	.packed
.not_mtappack:
	ret
.packed:
	push	esi
	mov	esi, aPacked1
	call	put_message_nodraw
	pop	esi
	call	put_message_nodraw
	mov	esi, aPacked2
	call	put_message
	call	hide_cursor
	push	40
	pop	eax
	push	7
	pop	ebx
	mcall
.wait:
	push	10
	pop	eax
	mcall
	dec	eax
	jz	.redraw
	dec	eax
	jz	.key
	or	eax, -1
	mcall
.redraw:
	call	draw_window
	call	hide_cursor
	jmp	.wait
.key:
	mov	al, 2
	mcall
	cmp	ah, 'y'
	jz	.yes
	cmp	ah, 'Y'
	jz	.yes
	cmp	ah, 0xD
	jz	.yes
	cmp	ah, 'n'
	jz	.no
	cmp	ah, 'N'
	jnz	.wait
.no:
	push	40
	pop	eax
	mov	ebx, 0x107
	mcall
	call	draw_cursor
	mov	esi, aN_str
	jmp	put_message
.yes:
	push	40
	pop	eax
	mov	ebx, 0x107
	mcall
	call	draw_cursor
	mov	esi, aY_str
	call	put_message
	call	OnUnpack
	ret
 
mxp_nrv_sig:
	xor	eax, eax
	mov	ecx, 0x95	; 0xA1 for programs with parameters
	mov	[eax], ecx
	add	ecx, [eax+24h]
	push	40h
	pop	esi
	mov	edi, [eax+20h]
	push	edi
	rep	movsb
	jmp	dword [esp]
	pop	esi
	add	esi, [eax]
	xor	edi, edi
mxp_nrv_sig_size = $ - mxp_nrv_sig
 
mxp_sig:
	mov	ecx, 1CBh
	push	46h
	pop	esi
	mov	edi, [20h]
	rep	movsb
	mov	ecx, [24h]
	rep	movsb
	jmp	dword [20h]
	mov	eax, [20h]
	add	eax, 1CBh
	push	eax
	push	dword [24h]
	push	0
	push	8
	call	$+0x25
mxp_sig_size = $ - mxp_sig
 
mxp_lzo_sig1:
	xor	eax, eax
	mov	ebp, 0FFh
	mov	ecx, 175h
	mov	[eax], ecx
	add	ecx, [eax+24h]
	push	45h
	pop	esi
	mov	edi, [eax+20h]
	push	edi
	rep	movsb
	jmp	dword [esp]
	pop	ebx
	add	ebx, [eax]
	xor	edi, edi
	cmp	byte [ebx], 11h
	jbe	$+0x1A
mxp_lzo_sig1_size = $ - mxp_lzo_sig1
mxp_lzo_sig2:
	xor	eax, eax
	mov	ebp, 0FFh
	mov	ecx, 188h	; or 177h
	mov	[eax], ecx
	add	ecx, [eax+24h]
	push	44h
	pop	esi
	mov	edi, [eax+20h]
	rep	movsb
	jmp	dword [eax+20h]
	mov	ebx, [eax+20h]
	add	ebx, [eax]
mxp_lzo_sig2_size = $ - mxp_lzo_sig2
 
OnReload:
	cmp	[debuggee_pid], 0
	jnz	terminate_reload
	mov	esi, need_debuggee
	cmp	byte [loadname], 0
	jnz	do_reload
	jz	put_message
terminate_reload:
	mov	[bReload], 1
OnTerminate:
	mov	ecx, [debuggee_pid]
	push	8
	pop	ebx
	push	69
	pop	eax
	mcall
	ret
 
AfterSuspend:
	mov	[bSuspended], 1
	call	get_new_context
	call	get_dump
	call	redraw_title
	call	redraw_registers
	call	redraw_dump
	call	update_disasm_eip
	ret
 
OnSuspend:
	mov	ecx, [debuggee_pid]
	push	4
	pop	ebx
	push	69
	pop	eax
	mcall
	call	AfterSuspend
	mov	esi, aSuspended
	jmp	put_message
DoResume:
	mov	ecx, [debuggee_pid]
	push	5
	pop	ebx
	push	69
	pop	eax
	mcall
	mov	[bSuspended], 0
	ret
OnResume:
	mov	esi, [curarg]
	cmp	byte [esi], 0
	jz	GoOn
	call	calc_expression
	jc	.ret
	mov	eax, ebp
	push	eax
	call	find_enabled_breakpoint
	pop	eax
	jz	GoOn
	mov	bl, 5	; valid enabled one-shot
	call	add_breakpoint
	jnc	GoOn
	mov	esi, aBreakpointLimitExceeded
	call	put_message
.ret:
	ret
GoOn:
; test for enabled breakpoint at eip
	mov	eax, [_eip]
	call	find_enabled_breakpoint
	jnz	.nobreak
; temporarily disable breakpoint, make step, enable breakpoint, continue
	inc	eax
	mov	[temp_break], eax
	mov	[bAfterGo], 1
	dec	eax
	call	disable_breakpoint
	call	get_context
	or	byte [_eflags+1], 1		; set TF
	call	set_context
	and	byte [_eflags+1], not 1
	call	DoResume
	ret
.nobreak:
	call	DoResume
	call	redraw_title
	call	redraw_registers
	call	redraw_dump
	ret
OnDetach:
	mov	ecx, [debuggee_pid]
	push	3
	pop	ebx
	push	69
	pop	eax
	mcall
	and	[debuggee_pid], 0
	call	redraw_title
	call	redraw_registers
	call	redraw_dump
	call	free_symbols
	mov	esi, aContinued
	jmp	put_message
 
after_go_exception:
	push	eax
	mov	eax, [temp_break]
	dec	eax
	push	esi
	call	enable_breakpoint
; in any case, clear TF and RF
	call	get_new_context
	and	[_eflags], not 10100h		; clear TF,RF
	call	set_context
	xor	edx, edx
	mov	[temp_break], edx
	xchg	dl, [bAfterGo]
	pop	esi
	pop	eax
	cmp	dl, 2
	jnz	@f
	lodsd
	push	esi
	call	get_dump
	jmp	exception.done
@@:	test	eax, eax
	jz	.notint1
; if exception is result of single step, simply ignore it and continue
	test	dword [esi], 0xF
	jnz	dbgmsgstart.5
	lodsd
	push	esi
	mov	esi, oldcontext
	mov	edi, context
	mov	ecx, 28h/4
	rep	movsd
	call	DoResume
	jmp	dbgmsgend
.notint1:
; in other case, work as without temp_break
	lodsd
	push	esi
	push	eax
	jmp	exception.4
.notour:
 
debugmsg:
	neg	[dbgbufsize]
	mov	esi, dbgbuf
dbgmsgstart:
	lodsd
;	push	eax esi
;	push	dword [esi]
;	mov	esi, dbgmsg_str
;	call	put_message_nodraw
;	pop	esi eax
	add	esi, 4
	dec	eax
	jz	exception
	dec	eax
	jz	terminated
	mov	[bSuspended], 1
	cmp	[bAfterGo], 0
	jnz	after_go_exception
	push	esi
	call	get_new_context
	and	[_eflags], not 10100h		; clear TF,RF
	call	set_context
	pop	esi
.5:
	push	esi
	call	get_dump
	pop	esi
	lodsd
	xor	ecx, ecx
.6:
	bt	eax, ecx
	jnc	.7
	mov	ebx, [drx_break+ecx*4]
	test	ebx, ebx
	jz	.7
	pushad
	dec	ebx
	push	ebx
	mov	esi, aBreakStop
	call	put_message_nodraw
	popad
.7:
	inc	ecx
	cmp	cl, 4
	jb	.6
	push	esi
	jmp	exception.done_draw
terminated:
	push	esi
	mov	esi, terminated_msg
	call	put_message
	and	[debuggee_pid], 0
	and	[temp_break], 0
	mov	[bAfterGo], 0
	xor	eax, eax
	mov	ecx, breakpoints_n*6/4+4
	mov	edi, breakpoints
	rep	stosd
	cmp	[bReload], 1
	sbb	[bReload], -1
	jnz	exception.done
	call	free_symbols
	jmp	exception.done
exception:
	mov	[bSuspended], 1
	cmp	[bAfterGo], 0
	jnz	after_go_exception
	lodsd
	push	esi
	push	eax
	call	get_new_context
	and	[_eflags], not 10100h		; clear TF,RF
	call	set_context
.4:
	call	get_dump
	pop	eax
; int3 command generates exception 0D, #GP
	push	eax
	cmp	al, 0Dh
	jnz	.notdbg
; check for 0xCC byte at eip
	push	0
	push	69
	pop	eax
	push	6
	pop	ebx
	mov	ecx, [debuggee_pid]
	mov	edi, esp
	mov	esi, [_eip]
	push	1
	pop	edx
	mcall
	pop	eax
	cmp	al, 0xCC
	jnz	.notdbg
; this is either dbg breakpoint or int3 cmd in debuggee
	mov	eax, [_eip]
	call	find_enabled_breakpoint
	jnz	.user_int3
; dbg breakpoint; clear if one-shot
	pop	ecx
	push	eax
	mov	esi, aBreakStop
	test	byte [edi+4], 4
	jz	.put_msg_eax
	pop	ecx
	call	clear_breakpoint
	jmp	.done
.user_int3:
	mov	eax, [_eip]
	inc	[_eip]
	pop	ecx
	push	eax
	call	set_context
	mov	esi, aUserBreak
	jmp	.put_msg_eax
.notdbg:
	mov	esi, aException
.put_msg_eax:
	call	put_message_nodraw
.done_draw:
	call	draw_messages
.done:
	push	18
	pop	eax
	push	3
	pop	ebx
	mov	ecx, [dbgwnd]
	mcall	; activate dbg window
	call	redraw_title
	call	redraw_registers
	call	redraw_dump
	call	update_disasm_eip
dbgmsgend:
	pop	esi
	mov	ecx, [dbgbuflen]
	add	ecx, dbgbuf
	cmp	esi, ecx
	jnz	dbgmsgstart
	and	[dbgbuflen], 0
	neg	[dbgbufsize]
	cmp	[bReload], 2
	jnz	@f
	mov	[bReload], 0
	call	do_reload
@@:
	jmp	waitevent
 
CtrlF7:
	cmp	[debuggee_pid], 0
	jz	.no
	call	OnStep
.no:
	jmp	waitevent
CtrlF8:
	cmp	[debuggee_pid], 0
	jz	CtrlF7.no
	call	OnProceed
	jmp	CtrlF7.no
 
OnStep:
	cmp	[bSuspended], 0
	jz	.running
	call	get_context
	or	byte [_eflags+1], 1		; set TF
	call	set_context
	and	byte [_eflags+1], not 1
; if instruction at eip is "int xx", set one-shot breakpoint immediately after
	mov	eax, [_eip]
	call	find_enabled_breakpoint
	jnz	@f
	cmp	byte [edi+5], 0xCD
	jz	.int
@@:
	push	0
	push	69
	pop	eax
	push	6
	pop	ebx
	mov	ecx, [debuggee_pid]
	push	3
	pop	edx
	mov	edi, esp
	mov	esi, [_eip]
	mcall
	cmp	eax, edx
	pop	eax
	jnz	.doit
	cmp	al, 0xCD
	jz	.int
	cmp	ax, 0x050F
	jz	.syscall
	cmp	ax, 0x340F
	jz	.sysenter
; resume process
.doit:
	call	GoOn
	cmp	[bAfterGo], 0
	jz	@f
	mov	[bAfterGo], 2
@@:
	ret
.sysenter:	; return address is [ebp-4]
	push	0
	push	69
	pop	eax
	inc	edx	; read 4 bytes
	mov	esi, [_ebp]
	sub	esi, 4
	mcall
	cmp	eax, edx
	pop	eax
	jnz	.syscall
	push	eax
	and	byte [_eflags+1], not 1
	call	set_context
	pop	eax
	jmp	@f
.syscall:
	and	byte [_eflags+1], not 1	; clear TF - avoid system halt (!)
	call	set_context
.int:
	mov	eax, [_eip]
	inc	eax
	inc	eax
@@:
	push	eax
	call	find_enabled_breakpoint
	pop	eax
	jz	.doit
; there is no enabled breakpoint yet; set temporary breakpoint
	mov	bl, 5
	call	add_breakpoint
	jmp	.doit
.running:
	mov	esi, aRunningErr
	jmp	put_message
 
OnProceed:
	cmp	[bSuspended], 0
	jz	OnStep.running
	mov	esi, [_eip]
@@:
	call	get_byte_nobreak
	jc	OnStep
	inc	esi
; skip prefixes
	call	is_prefix
	jz	@b
	cmp	al, 0xE8	; call
	jnz	@f
	add	esi, 4
	jmp	.doit
@@:	; A4,A5 = movs, A6,A7=cmps
	cmp	al, 0xA4
	jb	@f
	cmp	al, 0xA8
	jb	.doit
@@:	; AA,AB=stos, AC,AD=lods, AE,AF=scas
	cmp	al, 0xAA
	jb	@f
	cmp	al, 0xB0
	jb	.doit
@@:	; E0=loopnz,E1=loopz,E2=loop
	cmp	al, 0xE0
	jb	.noloop
	cmp	al, 0xE2
	ja	.noloop
	inc	esi
	jmp	.doit
.noloop:	; FF /2 = call
	cmp	al, 0xFF
	jnz	OnStep
	call	get_byte_nobreak
	jc	OnStep
	inc	esi
	mov	cl, al
	and	al, 00111000b
	cmp	al, 00010000b
	jnz	OnStep
; skip instruction
	mov	al, cl
	and	eax, 7
	shr	cl, 6
	jz	.mod0
	jp	.doit
	cmp	al, 4
	jnz	@f
	inc	esi
@@:
	inc	esi
	dec	cl
	jz	@f
	add	esi, 3
@@:
	jmp	.doit
.mod0:
	cmp	al, 4
	jnz	@f
	call	get_byte_nobreak
	jc	OnStep
	inc	esi
	and	al, 7
@@:
	cmp	al, 5
	jnz	.doit
	add	esi, 4
.doit:
; insert one-shot breakpoint at esi and resume
	call	get_byte_nobreak
	jc	OnStep
	mov	eax, esi
	call	find_enabled_breakpoint
	jz	.ret
	mov	eax, esi
	mov	bl, 5
	call	add_breakpoint
	jmp	OnStep.doit
.ret:
	ret
 
get_byte_nobreak:
	mov	eax, esi
	call	find_enabled_breakpoint
	jnz	.nobreak
	mov	al, [edi+5]
	clc
	ret
.nobreak:
	push	69
	pop	eax
	push	6
	pop	ebx
	mov	ecx, [debuggee_pid]
	xor	edx, edx
	push	edx
	inc	edx
	mov	edi, esp
	mcall
	dec	eax
	clc
	jz	@f
	stc
@@:	pop	eax
	ret
 
is_prefix:
	cmp	al, 0x64	; fs:
	jz	.ret
	cmp	al, 0x65	; gs:
	jz	.ret
	cmp	al, 0x66	; use16/32
	jz	.ret
	cmp	al, 0x67	; addr16/32
	jz	.ret
	cmp	al, 0xF0	; lock
	jz	.ret
	cmp	al, 0xF2	; repnz
	jz	.ret
	cmp	al, 0xF3	; rep(z)
	jz	.ret
	cmp	al, 0x2E	; cs:
	jz	.ret
	cmp	al, 0x36	; ss:
	jz	.ret
	cmp	al, 0x3E	; ds:
	jz	.ret
	cmp	al, 0x26	; es:
.ret:	ret
 
token_end	equ	1
token_reg	equ	2
token_hex	equ	3
token_add	equ	4
token_sub	equ	5
token_mul	equ	6
token_div	equ	7
token_lp	equ	8
token_rp	equ	9
token_err	equ	-1
 
is_hex_digit:
	cmp	al, '0'
	jb	.no
	cmp	al, '9'
	jbe	.09
	cmp	al, 'A'
	jb	.no
	cmp	al, 'F'
	jbe	.AF
	cmp	al, 'a'
	jb	.no
	cmp	al, 'f'
	jbe	.af
.no:
	stc
	ret
.09:
	sub	al, '0'
;	clc
	ret
.AF:
	sub	al, 'A'-10
;	clc
	ret
.af:
	sub	al, 'a'-10
;	clc
	ret
 
find_reg:
	mov	edi, reg_table
.findreg:
	movzx	ecx, byte [edi]
	stc
	jecxz	.regnotfound
	inc	edi
	push	esi edi ecx
@@:
	lodsb
	or	al, 20h
	scasb
	loopz	@b
	pop	ecx edi esi
	lea	edi, [edi+ecx+1]
	jnz	.findreg
	movzx	edi, byte [edi-1]
	add	esi, ecx
.regnotfound:
	ret
 
expr_get_token:
	lodsb
	cmp	al, 0
	jz	.end_token
	cmp	al, ' '
	jbe	expr_get_token
	cmp	al, '+'
	jz	.add
	cmp	al, '-'
	jz	.sub
	cmp	al, '*'
	jz	.mul
	cmp	al, '/'
	jz	.div
	cmp	al, '('
	jz	.lp
	cmp	al, ')'
	jnz	.notsign
.rp:
	mov	al, token_rp
	ret
.div:
	mov	al, token_div
	ret
.end_token:
	mov	al, token_end
	ret
.add:
	mov	al, token_add
	ret
.sub:
	mov	al, token_sub
	ret
.mul:
	mov	al, token_mul
	ret
.lp:
	mov	al, token_lp
	ret
.notsign:
	dec	esi
	call	find_reg
	jc	.regnotfound
	mov	al, token_reg
	ret
.regnotfound:
; test for symbol
	push	esi
@@:
	lodsb
	cmp	al, ' '
	ja	@b
	push	eax
	mov	byte [esi], 0
	xchg	esi, [esp+4]
	call	find_symbol_name
	mov	edi, eax
	pop	eax
	xchg	esi, [esp]
	mov	byte [esi], al
	jc	@f
	add	esp, 4
	mov	al, token_hex
	ret
@@:
	pop	esi
; test for hex number
	xor	ecx, ecx
	xor	edi, edi
	xor	eax, eax
@@:
	lodsb
	call	is_hex_digit
	jc	@f
	shl	edi, 4
	or	edi, eax
	inc	ecx
	jmp	@b
@@:
	dec	esi
	jecxz	.err
	cmp	ecx, 8
	ja	.err
	mov	al, token_hex
	ret
.err:
	mov	al, token_err
	mov	esi, aParseError
	ret
 
expr_read2:
	cmp	al, token_hex
	jz	.hex
	cmp	al, token_reg
	jz	.reg
	cmp	al, token_lp
	jz	.lp
	mov	al, token_err
	mov	esi, aParseError
	ret
.hex:
	mov	ebp, edi
.ret:
	jmp	expr_get_token
.reg:
	cmp	edi, 24
	jz	.eip
	sub	edi, 4
	jb	.8lo
	sub	edi, 4
	jb	.8hi
	sub	edi, 8
	jb	.16
	mov	ebp, [_eax+edi*4]
	jmp	.ret
.16:
	movzx	ebp, word [_eax+(edi+8)*4]
	jmp	.ret
.8lo:
	movzx	ebp, byte [_eax+(edi+4)*4]
	jmp	.ret
.8hi:
	movzx	ebp, byte [_eax+(edi+4)*4+1]
	jmp	.ret
.eip:
	mov	ebp, [_eip]
	jmp	.ret
.lp:
	call	expr_get_token
	call	expr_read0
	cmp	al, token_err
	jz	@f
	cmp	al, token_rp
	jz	expr_get_token
	mov	al, token_err
	mov	esi, aParseError
@@:	ret
 
expr_read1:
	call	expr_read2
.1:
	cmp	al, token_mul
	jz	.mul
	cmp	al, token_div
	jz	.div
	ret
.mul:
	push	ebp
	call	expr_get_token
	call	expr_read2
	pop	edx
; ebp := edx*ebp
	imul	ebp, edx
	jmp	.1
.div:
	push	ebp
	call	expr_get_token
	call	expr_read2
	pop	edx
; ebp := edx/ebp
	test	ebp, ebp
	jz	.div0
	push	eax
	xor	eax, eax
	xchg	eax, edx
	div	ebp
	xchg	eax, ebp
	pop	eax
	jmp	.1
.div0:
	mov	al, token_err
	mov	esi, aDivByZero
	ret
 
expr_read0:
	xor	ebp, ebp
	cmp	al, token_add
	jz	.add
	cmp	al, token_sub
	jz	.sub
	call	expr_read1
.1:
	cmp	al, token_add
	jz	.add
	cmp	al, token_sub
	jz	.sub
	ret
.add:
	push	ebp
	call	expr_get_token
	call	expr_read1
	pop	edx
; ebp := edx+ebp
	add	ebp, edx
	jmp	.1
.sub:
	push	ebp
	call	expr_get_token
	call	expr_read1
	pop	edx
; ebp := edx-ebp
	xchg	edx, ebp
	sub	ebp, edx
	jmp	.1
 
calc_expression:
; in: esi->expression
; out: CF=1 if error
;      CF=0 and ebp=value if ok
	call	expr_get_token
	call	expr_read0
	cmp	al, token_end
	jz	.end
	cmp	al, token_err
	jz	@f
	mov	esi, aParseError
@@:
	call	put_message
	stc
	ret
.end:
	clc
	ret
 
OnCalc:
	mov	esi, [curarg]
	call	calc_expression
	jc	.ret
	push	ebp
	mov	esi, calc_string
	call	put_message_nodraw
	jmp	draw_messages
.ret:
	ret
 
OnDump:
	mov	esi, [curarg]
	cmp	byte [esi], 0
	jnz	.param
	add	[dumppos], dump_height*10h
	jmp	.doit
.param:
	call	calc_expression
	jc	.ret
	mov	[dumppos], ebp
.doit:
	call	get_dump
	call	redraw_dump
.ret:
	ret
 
OnUnassemble:
	mov	esi, [curarg]
	cmp	byte [esi], 0
	jnz	.param
	mov	eax, [disasm_start_pos]
	mov	ecx, disasm_height
	mov	[disasm_cur_pos], eax
.l:
	mov	eax, [disasm_cur_pos]
	call	find_symbol
	jc	@f
	dec	ecx
	jz	.m
@@:
	push	ecx
	call	disasm_instr
	pop	ecx
	jc	.err
	loop	.l
.m:
	mov	eax, [disasm_cur_pos]
	jmp	.doit
.param:
	call	calc_expression
	jc	.ret
	mov	eax, ebp
.doit:
	push	eax
	push	[disasm_start_pos]
	mov	[disasm_start_pos], eax
	call	update_disasm
	pop	[disasm_start_pos]
	pop	eax
	cmp	[disasm_cur_str], 0
	jz	@f
	mov	[disasm_start_pos], eax
.ret:
	ret
@@:
	call	update_disasm
.err:
	mov	esi, aInvAddr
	jmp	put_message
 
OnReg:
	mov	esi, [curarg]
	call	skip_spaces
	call	find_reg
	jnc	@f
.err:
	mov	esi, RSyntax
	jmp	put_message
@@:
	call	skip_spaces
	test	al, al
	jz	.err
	cmp	al, '='
	jnz	@f
	inc	esi
	call	skip_spaces
	test	al, al
	jz	.err
@@:
	push	edi
	call	calc_expression
	pop	edi
	jc	.ret
; now edi=register id, ebp=value
	cmp	[bSuspended], 0
	mov	esi, aRunningErr
	jz	put_message
	xchg	eax, ebp
	cmp	edi, 24
	jz	.eip
	sub	edi, 4
	jb	.8lo
	sub	edi, 4
	jb	.8hi
	sub	edi, 8
	jb	.16
	mov	[_eax+edi*4], eax
	jmp	.ret
.16:
	mov	word [_eax+(edi+8)*4], ax
	jmp	.ret
.8lo:
	mov	byte [_eax+(edi+4)*4], al
	jmp	.ret
.8hi:
	mov	byte [_eax+(edi+4)*4+1], al
	jmp	.ret
.eip:
	mov	[_eip], eax
	call	update_disasm_eip
.ret:
	call	set_context
	jmp	redraw_registers
 
; Breakpoints manipulation
OnBp:
	mov	esi, [curarg]
	call	calc_expression
	jc	.ret
	xchg	eax, ebp
	push	eax
	call	find_breakpoint
	inc	eax
	pop	eax
	jz	.notfound
	mov	esi, aDuplicateBreakpoint
	jmp	.sayerr
.notfound:
	mov	bl, 1
	call	add_breakpoint
	jnc	.ret
	mov	esi, aBreakpointLimitExceeded
.sayerr:
	call	put_message
.ret:
	jmp	redraw_disasm
 
OnBpmb:
	mov	dh, 0011b
	jmp	DoBpm
OnBpmw:
	mov	dh, 0111b
	jmp	DoBpm
OnBpmd:
	mov	dh, 1111b
DoBpm:
	mov	esi, [curarg]
	cmp	byte [esi], 'w'
	jnz	@f
	and	dh, not 2
	inc	esi
@@:
	push	edx
	call	calc_expression
	pop	edx
	jnc	@f
	ret
@@:
; ebp=expression, dh=flags
	movzx	eax, dh
	shr	eax, 2
	test	ebp, eax
	jz	@f
	mov	esi, aUnaligned
	jmp	put_message
@@:
	mov	eax, ebp
	mov	bl, 0Bh
	call	add_breakpoint
	jnc	@f
	mov	esi, aBreakpointLimitExceeded
	jmp	put_message
@@:
; now find index
	push	eax
	xor	ecx, ecx
.l1:
	cmp	[drx_break+ecx*4], 0
	jnz	.l2
	push	69
	pop	eax
	push	ecx
	mov	dl, cl
	mov	ecx, [debuggee_pid]
	mov	esi, ebp
	push	9
	pop	ebx
	mcall
	test	eax, eax
	jz	.ok
	pop	ecx
.l2:
	inc	ecx
	cmp	ecx, 4
	jb	.l1
	pop	eax
	call	clear_breakpoint
	mov	esi, aBreakpointLimitExceeded
	jmp	put_message
.ok:
	pop	ecx
	pop	eax
	and	byte [edi], not 2	; breakpoint is enabled
	shl	dl, 6
	or	dl, dh
	mov	byte [edi+1], dl
	inc	eax
	mov	[drx_break+ecx*4], eax
	ret
 
OnBc:
	mov	esi, [curarg]
@@:	call	get_hex_number
	jc	OnBp.ret
	call	clear_breakpoint
	jmp	@b
 
OnBd:
	mov	esi, [curarg]
@@:	call	get_hex_number
	jc	OnBp.ret
	call	disable_breakpoint
	jmp	@b
 
OnBe:
	mov	esi, [curarg]
@@:	call	get_hex_number
	jc	OnBp.ret
	push	eax
	call	find_enabled_breakpoint
	pop	eax
	jz	.err
	call	enable_breakpoint
	jmp	@b
.err:
	mov	esi, OnBeErrMsg
	jmp	put_message
 
get_hex_number:
	call	skip_spaces
	xor	ecx, ecx
	xor	edx, edx
@@:
	lodsb
	call	is_hex_digit
	jc	.ret
	shl	edx, 4
	or	dl, al
	inc	ecx
	jmp	@b
.ret:
	dec	esi
	cmp	ecx, 1
	xchg	eax, edx
	ret
 
OnBl:
	mov	esi, [curarg]
	cmp	byte [esi], 0
	jz	.listall
	call	get_hex_number
	jc	.ret
	cmp	eax, breakpoints_n
	jae	.err
	push	eax
	add	eax, eax
	lea	edi, [breakpoints + eax + eax*2]
	pop	eax
	test	byte [edi+4], 1
	jz	.err
	call	show_break_info
.ret:
	ret
.err:
	mov	esi, aInvalidBreak
	jmp	put_message
.listall:
	mov	edi, breakpoints
	xor	eax, eax
@@:
	test	byte [edi+4], 1
	jz	.cont
	push	edi eax
	call	show_break_info
	pop	eax edi
.cont:
	add	edi, 6
	inc	eax
	cmp	eax, breakpoints_n
	jb	@b
	ret
 
show_break_info:
	push	edi
	test	byte [edi+4], 8
	jnz	.dr
	push	dword [edi]
	push	eax
	mov	esi, aBreakNum
	call	put_message_nodraw
	jmp	.cmn
.dr:
	push	eax
	mov	esi, aMemBreak1
	call	put_message_nodraw
	pop	edi
	push	edi
	mov	esi, aMemBreak2
	test	byte [edi+5], 2
	jz	@f
	mov	esi, aMemBreak3
@@:
	call	put_message_nodraw
	pop	edi
	push	edi
	mov	esi, aMemBreak6
	test	byte [edi+5], 8
	jnz	@f
	mov	esi, aMemBreak5
	test	byte [edi+5], 4
	jnz	@f
	mov	esi, aMemBreak4
@@:
	call	put_message_nodraw
	pop	edi
	push	edi
	push	dword [edi]
	mov	esi, aMemBreak7
	call	put_message_nodraw
.cmn:
	pop	edi
	test	byte [edi+4], 2
	jz	@f
	push	edi
	mov	esi, aDisabled
	call	put_message_nodraw
	pop	edi
@@:
	test	byte [edi+4], 4
	jz	@f
	mov	esi, aOneShot
	call	put_message_nodraw
@@:
	mov	esi, newline
	jmp	put_message
 
add_breakpoint:
; in: eax=address, bl=flags
; out: CF=1 => error, CF=0 => eax=breakpoint number
	xor	ecx, ecx
	mov	edi, breakpoints
@@:
	test	byte [edi+4], 1
	jz	.found
	add	edi, 6
	inc	ecx
	cmp	ecx, breakpoints_n
	jb	@b
	stc
	ret
.found:
	stosd
	xchg	eax, ecx
	mov	[edi], bl
	test	bl, 2
	jnz	@f
	or	byte [edi], 2
	push	eax
	call	enable_breakpoint
	pop	eax
@@:
	clc
	ret
 
clear_breakpoint:
	cmp	eax, breakpoints_n
	jae	.ret
	mov	ecx, 4
	inc	eax
.1:
	cmp	[drx_break-4+ecx*4], eax
	jnz	@f
	and	[drx_break-4+ecx*4], 0
@@:	loop	.1
	dec	eax
	push	eax
	add	eax, eax
	lea	edi, [breakpoints + eax + eax*2 + 4]
	test	byte [edi], 1
	pop	eax
	jz	.ret
	push	edi
	call	disable_breakpoint
	pop	edi
	mov	byte [edi], 0
.ret:
	ret
 
disable_breakpoint:
	cmp	eax, breakpoints_n
	jae	.ret
	add	eax, eax
	lea	edi, [breakpoints + eax + eax*2 + 5]
	test	byte [edi-1], 1
	jz	.ret
	test	byte [edi-1], 2
	jnz	.ret
	or	byte [edi-1], 2
	test	byte [edi-1], 8
	jnz	.dr
	push	esi
	push	7
	pop	ebx
	push	69
	pop	eax
	mov	ecx, [debuggee_pid]
	xor	edx, edx
	inc	edx
	mov	esi, [edi-5]
	mcall
	pop	esi
.ret:
	ret
.dr:
	mov	dl, [edi]
	shr	dl, 6
	mov	dh, 80h
	push	69
	pop	eax
	push	9
	pop	ebx
	mov	ecx, [debuggee_pid]
	mcall
	ret
 
enable_breakpoint:
	push	esi
	cmp	eax, breakpoints_n
	jae	.ret
	add	eax, eax
	lea	edi, [breakpoints + eax + eax*2 + 5]
	test	byte [edi-1], 1
	jz	.ret
	test	byte [edi-1], 2
	jz	.ret
	and	byte [edi-1], not 2
	test	byte [edi-1], 8
	jnz	.dr
	push	6
	pop	ebx
	push	69
	pop	eax
	mov	esi, [edi-5]
	mov	ecx, [debuggee_pid]
	xor	edx, edx
	inc	edx
	mcall
	dec	eax
	jnz	.err
	mov	al, 69
	push	0xCC
	mov	edi, esp
	inc	ebx
	mcall
	pop	eax
.ret:
	pop	esi
	ret
.err:
	or	byte [edi-1], 2
	mov	esi, aBreakErr
	call	put_message
	pop	esi
	ret
.dr:
	push	9
	pop	ebx
	push	69
	pop	eax
	mov	esi, [edi-5]
	mov	ecx, [debuggee_pid]
	mov	dl, [edi]
	shr	dl, 6
	mov	dh, [edi]
	and	dh, 0xF
	mcall
	test	eax, eax
	jnz	.err
	pop	esi
	ret
 
find_breakpoint:
	xor	ecx, ecx
	xchg	eax, ecx
	mov	edi, breakpoints
@@:
	test	byte [edi+4], 1
	jz	.cont
	test	byte [edi+4], 8
	jnz	.cont
	cmp	[edi], ecx
	jz	.found
.cont:
	add	edi, 6
	inc	eax
	cmp	eax, breakpoints_n
	jb	@b
	or	eax, -1
.found:
	ret
 
find_enabled_breakpoint:
	xor	ecx, ecx
	xchg	eax, ecx
	mov	edi, breakpoints
@@:
	test	byte [edi+4], 1
	jz	.cont
	test	byte [edi+4], 2 or 8
	jnz	.cont
	cmp	[edi], ecx
	jz	.found
.cont:
	add	edi, 6
	inc	eax
	cmp	eax, breakpoints_n
	jb	@b
	or	eax, -1
.found:
	ret
 
OnUnpack:
; program must be loaded - checked when command was parsed
; program must be stopped
	mov	esi, aRunningErr
	cmp	[bSuspended], 0
	jz	put_message
; all breakpoints must be disabled
	mov	edi, breakpoints
@@:
	test	byte [edi+4], 1
	jz	.cont
	test	byte [edi+4], 2
	jnz	.cont
	mov	esi, aEnabledBreakErr
	jmp	put_message
.cont:
	add	edi, 6
	cmp	edi, breakpoints+breakpoints_n*6
	jb	@b
; ok, now do it
; set breakpoint on 0xC dword access
	push	9
	pop	ebx
	mov	ecx, [debuggee_pid]
	mov	dx, 1111b*256
	push	0xC
	pop	esi
@@:
	push	69
	pop	eax
	mcall
	test	eax, eax
	jz	.breakok
	inc	edx
	cmp	dl, 4
	jb	@b
.breakok:
	call	GoOn
; now wait for event
.wait:
	push	10
	pop	eax
	mcall
	dec	eax
	jz	.redraw
	dec	eax
	jz	.key
	dec	eax
	jnz	.debug
; button; we have only one button, close
	or	eax, -1
	mcall
.redraw:
	call	draw_window
	jmp	.wait
.key:
	mov	al, 2
	mcall
	cmp	ah, 3	; Ctrl+C
	jnz	.wait
.userbreak:
	mov	esi, aInterrupted
.x1:
	push	edx esi
	call	put_message
	pop	esi edx
	or	dh, 80h
	push	69
	pop	eax
	push	9
	pop	ebx
	mov	ecx, [debuggee_pid]
	mcall
	cmp	esi, aUnpacked
	jnz	OnSuspend
	jmp	AfterSuspend
.debug:
	cmp	[dbgbuflen], 4*3
	jnz	.notour
	cmp	dword [dbgbuf], 3
	jnz	.notour
	test	byte [dbgbuf+8], 1
	jnz	.our
.notour:
	mov	esi, aInterrupted
	push	edx
	call	put_message
	pop	edx
	or	dh, 80h
	push	69
	pop	eax
	push	9
	pop	ebx
	mov	ecx, [debuggee_pid]
	mcall
	jmp	debugmsg
.our:
	and	[dbgbuflen], 0
	push	edx
	call	get_context
	push	eax
	mov	al, 69
	mov	bl, 6
	mov	ecx, [debuggee_pid]
	mov	edi, esp
	push	4
	pop	edx
	push	0xC
	pop	esi
	mcall
	pop	eax
	pop	edx
	cmp	eax, [_eip]
	jz	.done
	call	DoResume
	jmp	.wait
.done:
	mov	esi, aUnpacked
	jmp	.x1
 
include 'sort.inc'
compare:
	cmpsd
	jnz	@f
	cmp	esi, edi
@@:	ret
compare2:
	cmpsd
@@:
	cmpsb
	jnz	@f
	cmp	byte [esi-1], 0
	jnz	@b
	cmp	esi, edi
@@:
	ret
 
free_symbols:
	mov	ecx, [symbols]
	jecxz	@f
	mcall	68, 13
	and	[symbols], 0
	and	[num_symbols], 0
@@:
	ret
 
OnLoadSymbols.fileerr:
	test	ebp, ebp
	jz	@f
	mcall	68, 13, edi
	ret
@@:
	push	eax
	mcall	68, 13, edi
	mov	esi, aCannotLoadFile
	call	put_message_nodraw
	pop	eax
	cmp	eax, 0x20
	jae	.unk
	mov	esi, [load_err_msgs + eax*4]
	test	esi, esi
	jnz	put_message
.unk:
	mov	esi, unk_err_msg2
	jmp	put_message
 
OnLoadSymbols:
	xor	ebp, ebp
; load input file
	mov	esi, [curarg]
	call	free_symbols
.silent:
	xor	edi, edi
	cmp	[num_symbols], edi
	jz	@f
	ret
@@:
	mov	ebx, fn70_attr_block
	mov	[ebx+21], esi
	mcall	70
	test	eax, eax
	jnz	.fileerr
	cmp	dword [fileattr+36], edi
	jnz	.memerr
	mov	ecx, dword [fileattr+32]
	mcall	68, 12
	test	eax, eax
	jz	.memerr
	mov	edi, eax
	mov	ebx, fn70_read_block
	mov	[ebx+12], ecx
	mov	[ebx+16], edi
	mov	[ebx+21], esi
	mcall	70
	test	eax, eax
	jnz	.fileerr
; calculate memory requirements
	lea	edx, [ecx+edi-1]	; edx = EOF-1
	mov	esi, edi
	xor	ecx, ecx
.calcloop:
	cmp	esi, edx
	jae	.calcdone
	cmp	word [esi], '0x'
	jnz	.skipline
	inc	esi
	inc	esi
@@:
	cmp	esi, edx
	jae	.calcdone
	lodsb
	or	al, 20h
	sub	al, '0'
	cmp	al, 9
	jbe	@b
	sub	al, 'a'-'0'-10
	cmp	al, 15
	jbe	@b
	dec	esi
@@:
	cmp	esi, edx
	ja	.calcdone
	lodsb
	cmp	al, 20h
	jz	@b
	jb	.calcloop
	cmp	al, 9
	jz	@b
	add	ecx, 12+1
	inc	[num_symbols]
@@:
	inc	ecx
	cmp	esi, edx
	ja	.calcdone
	lodsb
	cmp	al, 0xD
	jz	.calcloop
	cmp	al, 0xA
	jz	.calcloop
	jmp	@b
.skipline:
	cmp	esi, edx
	jae	.calcdone
	lodsb
	cmp	al, 0xD
	jz	.calcloop
	cmp	al, 0xA
	jz	.calcloop
	jmp	.skipline
.calcdone:
	mcall	68, 12
	test	eax, eax
	jnz	.memok
	inc	ebx
	mov	ecx, edi
	mov	al, 68
	mcall
.memerr:
	mov	esi, aNoMemory
	jmp	put_message
.memok:
	mov	[symbols], eax
	mov	ebx, eax
	push	edi
	mov	esi, edi
	mov	edi, [num_symbols]
	lea	ebp, [eax+edi*4]
	lea	edi, [eax+edi*8]
; parse input data, esi->input, edx->EOF, ebx->ptrs, edi->names
.readloop:
	cmp	esi, edx
	jae	.readdone
	cmp	word [esi], '0x'
	jnz	.readline
	inc	esi
	inc	esi
	xor	eax, eax
	xor	ecx, ecx
@@:
	shl	ecx, 4
	add	ecx, eax
	cmp	esi, edx
	jae	.readdone
	lodsb
	or	al, 20h
	sub	al, '0'
	cmp	al, 9
	jbe	@b
	sub	al, 'a'-'0'-10
	cmp	al, 15
	jbe	@b
	dec	esi
@@:
	cmp	esi, edx
	ja	.readdone
	lodsb
	cmp	al, 20h
	jz	@b
	jb	.readloop
	cmp	al, 9
	jz	@b
	mov	dword [ebx], edi
	add	ebx, 4
	mov	dword [ebp], edi
	add	ebp, 4
	mov	dword [edi], ecx
	add	edi, 4
	stosb
@@:
	xor	eax, eax
	stosb
	cmp	esi, edx
	ja	.readdone
	lodsb
	cmp	al, 0xD
	jz	.readloop
	cmp	al, 0xA
	jz	.readloop
	mov	byte [edi-1], al
	jmp	@b
.readline:
	cmp	esi, edx
	jae	.readdone
	lodsb
	cmp	al, 0xD
	jz	.readloop
	cmp	al, 0xA
	jz	.readloop
	jmp	.readline
.readdone:
	pop	ecx
	mcall	68, 13
	mov	ecx, [num_symbols]
	mov	edx, [symbols]
	mov	ebx, compare
	call	sort
	mov	ecx, [num_symbols]
	lea	edx, [edx+ecx*4]
	mov	ebx, compare2
	call	sort
	mov	esi, aSymbolsLoaded
	call	put_message
	jmp	redraw_disasm
 
find_symbol:
; in: eax=address
; out: esi, CF
	cmp	[num_symbols], 0
	jnz	@f
.ret0:
	xor	esi, esi
	stc
	ret
@@:
	push	ebx ecx edx
	xor	edx, edx
	mov	esi, [symbols]
	mov	ecx, [num_symbols]
	mov	ebx, [esi]
	cmp	[ebx], eax
	jz	.donez
	jb	@f
	pop	edx ecx ebx
	jmp	.ret0
@@:
; invariant: symbols_addr[edx] < eax < symbols_addr[ecx]
.0:
	push	edx
.1:
	add	edx, ecx
	sar	edx, 1
	cmp	edx, [esp]
	jz	.done2
	mov	ebx, [esi+edx*4]
	cmp	[ebx], eax
	jz	.done
	ja	.2
	mov	[esp], edx
	jmp	.1
.2:
	mov	ecx, edx
	pop	edx
	jmp	.0
.donecont:
	dec	edx
.done:
	test	edx, edx
	jz	@f
	mov	ebx, [esi+edx*4-4]
	cmp	[ebx], eax
	jz	.donecont
@@:
	pop	ecx
.donez:
	mov	esi, [esi+edx*4]
	add	esi, 4
	pop	edx ecx ebx
	clc
	ret
.done2:
	lea	esi, [esi+edx*4]
	pop	ecx edx ecx ebx
	stc
	ret
 
find_symbol_name:
; in: esi->name
; out: if found: CF clear, eax=value
;      otherwise CF set
	cmp	[num_symbols], 0
	jnz	@f
.stc_ret:
	stc
	ret
@@:
	push	ebx ecx edx edi
	push	-1
	pop	edx
	mov	ebx, [symbols]
	mov	ecx, [num_symbols]
	lea	ebx, [ebx+ecx*4]
; invariant: symbols_name[edx] < name < symbols_name[ecx]
.0:
	push	edx
.1:
	add	edx, ecx
	sar	edx, 1
	cmp	edx, [esp]
	jz	.done2
	call	.cmp
	jz	.done
	jb	.2
	mov	[esp], edx
	jmp	.1
.2:
	mov	ecx, edx
	pop	edx
	jmp	.0
.done:
	pop	ecx
.donez:
	mov	eax, [ebx+edx*4]
	mov	eax, [eax]
	pop	edi edx ecx ebx
	clc
	ret
.done2:
	pop	edx edi edx ecx ebx
	stc
	ret
 
.cmp:
	mov	edi, [ebx+edx*4]
	push	esi
	add	edi, 4
@@:
	cmpsb
	jnz	@f
	cmp	byte [esi-1], 0
	jnz	@b
@@:
	pop	esi
	ret
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; DISASSEMBLER ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
disasm_get_byte:
; out: al=byte
	push	ecx
	mov	ecx, [disasm_cur_pos]
	sub	ecx, [disasm_start_pos]
	cmp	ecx, [disasm_buf_size]
	jae	disasm_err
	mov	al, [disasm_buffer+ecx]
	pop	ecx
	inc	[disasm_cur_pos]
	ret
disasm_get_word:
	push	ecx
	mov	ecx, [disasm_cur_pos]
	sub	ecx, [disasm_start_pos]
	inc	ecx
	cmp	ecx, [disasm_buf_size]
	jae	disasm_err
	mov	ax, word [disasm_buffer-1+ecx]
	pop	ecx
	add	[disasm_cur_pos], 2
	ret
disasm_get_dword:
	push	ecx
	mov	ecx, [disasm_cur_pos]
	sub	ecx, [disasm_start_pos]
	add	ecx, 3
	cmp	ecx, [disasm_buf_size]
	jae	disasm_err
	mov	eax, dword [disasm_buffer-3+ecx]
	pop	ecx
	add	[disasm_cur_pos], 4
	ret
 
disasm_err:
	mov	esp, ebp
stc_ret:
	stc
	ret
disasm_ret:
	mov	esp, ebp
	and	byte [edi], 0
	ret
 
disasm_instr:
	mov	ebp, esp
	cmp	[debuggee_pid], 0
	jz	stc_ret
	mov	edi, disasm_string
	xor	ecx, ecx
; ecx=flags
disasm_loop1:
	xor	eax, eax
	call	disasm_get_byte
	jmp	dword [disasm_table_1 + eax*4]
 
cop0:
clock:
csegcs:
csegds:
cseges:
csegss:
csegfs:
cseggs:
	mov	esi, cmd1
iglobal
cmd1:
	db	0x2E,3,'cs:'
	db	0x36,3,'ss:'
	db	0x3E,3,'ds:'
	db	0x26,3,'es:'
	db	0x64,3,'fs:'
	db	0x65,3,'gs:'
	db	0x06,10,'push    es'
	db	0x07,10,'pop     es'
	db	0x0E,10,'push    cs'
	db	0x16,10,'push    ss'
	db	0x17,10,'pop     ss'
	db	0x1E,10,'push    ds'
	db	0x1F,10,'pop     ds'
	db	0x27,3,'daa'
	db	0x2F,3,'das'
	db	0x37,3,'aaa'
	db	0x3F,3,'aas'
	db	0x60,6,0,'pusha'
	db	0x61,5,0,'popa'
	db	0x90,3,'nop'
	db	0x9B,5,'fwait'
	db	0x9C,6,0,'pushf'
	db	0x9D,5,0,'popf'
	db	0x9E,4,'sahf'
	db	0x9F,4,'lahf'
	db	0xA4,5,'movsb'
	db	0xA5,5,0,'movs'
	db	0xA6,5,'cmpsb'
	db	0xA7,5,0,'cmps'
	db	0xAA,5,'stosb'
	db	0xAB,5,0,'stos'
	db	0xAC,5,'lodsb'
	db	0xAD,5,0,'lods'
	db	0xAE,5,'scasb'
	db	0xAF,5,0,'scas'
	db	0xC3,3,'ret'
	db	0xC9,5,'leave'
	db	0xCC,4,'int3'
	db	0xF0,4,'lock'
	db	0xF5,3,'cmc'
	db	0xF8,3,'clc'
	db	0xF9,3,'stc'
	db	0xFA,3,'cli'
	db	0xFB,3,'sti'
	db	0xFC,3,'cld'
	db	0xFD,3,'std'
cmd2:
	db	0x05,7,'syscall'
	db	0x06,4,'clts'
	db	0x31,5,'rdtsc'
	db	0x34,8,'sysenter'
	db	0xA2,5,'cpuid'
	db	0x77,4,'emms'
endg
	jmp	@f
ccpuid:
crdtsc:
cemms:
cop0_F:
	mov	esi, cmd2
@@:
	cmp	al, [esi]
	jz	.found
	inc	esi
	movzx	edx, byte [esi]
	inc	esi
	add	esi, edx
	jmp	@b
.found:
	inc	esi
	lodsb
	cmp	byte [esi], 0
	jz	@f
	movzx	ecx, al
disasm_1:
	rep	movsb
	and	byte [edi], 0
	ret
@@:
	mov	dl, ch
	movzx	ecx, al
	dec	ecx
	inc	esi
	rep	movsb
	test	dl, 1
	mov	al, 'w'
	jnz	@f
	mov	al, 'd'
@@:	stosb
	and	byte [edi], 0
	ret
 
c67:
	or	ch, 2
	jmp	disasm_loop1
c66:
	or	ch, 1
	jmp	disasm_loop1
 
cxlat:
cunk:
cerr:
	mov	eax, '???'
	stosd
	clc
	ret
 
cF:
	call	disasm_get_byte
	jmp	dword [disasm_table_2 + eax*4]
 
crep:
	push	[disasm_cur_pos]
	call	disasm_get_byte
	cmp	al, 0x0F
	jz	.sse
	mov	dl, al
	mov	eax, 'rep '
	stosd
	mov	al, dl
@@:
	and	eax, not 1
	cmp	al, 0x66
	jnz	@f
	call	disasm_get_byte
	mov	dl, al
	jmp	@b
@@:
	cmp	al, 0xA6
	jz	.repz
	cmp	al, 0xAE
	jz	.repz
	cmp	al, 0xA4
	jz	.prefix
	cmp	al, 0xAA
	jz	.prefix
	cmp	al, 0xAC
	jz	.prefix
	cmp	al, 0x6C
	jz	.prefix
	cmp	al, 0x6E
	jz	.prefix
.noprefix:
	pop	[disasm_cur_pos]
	and	byte [edi-1], 0
	ret
.repz:
	mov	byte [edi-1], 'z'
	mov	al, ' '
	stosb
.prefix:
	pop	[disasm_cur_pos]
	jmp	disasm_loop1
.sse:
	pop	eax
	call	disasm_get_byte
iglobal
rep_sse_cmds:
	db	0x58,3,'add'
	db	0xC2,3,'cmp'
	db	0,0
endg
	mov	esi, rep_sse_cmds+1
@@:
	movzx	edx, byte [esi]
	cmp	al, [esi-1]
	jz	@f
	lea	esi, [esi+edx+2]
	cmp	byte [esi], 0
	jnz	@b
	sub	[disasm_cur_pos], 2
	mov	eax, 'rep'
	stosd
	ret
@@:
	push	ecx
	mov	ecx, edx
	inc	esi
	rep	movsb
	pop	ecx
	mov	al, 's'
	stosb
	jmp	rep_sse_final
 
crepnz:
	call	disasm_get_byte
	cmp	al, 0x0F
	jz	.sse
	mov	dl, al
	mov	eax, 'repn'
	stosd
	mov	al, 'z'
	stosb
	mov	al, ' '
	stosb
	movzx	eax, dl
	cmp	al, 0x6C
	jb	crep.noprefix
	cmp	al, 0x6F
	jbe	.prefix
	cmp	al, 0xA4
	jb	crep.noprefix
	cmp	al, 0xA7
	jbe	.prefix
	cmp	al, 0xAA
	jb	crep.noprefix
	cmp	al, 0xAF
	ja	crep.noprefix
.prefix:
	jmp	cop0
.sse:
	call	disasm_get_byte
	mov	esi, rep_sse_cmds+1
@@:
	movzx	edx, byte [esi]
	cmp	al, [esi-1]
	jz	.found0
	lea	esi, [esi+edx+2]
	cmp	byte [esi], 0
	jnz	@b
	mov	esi, sse_cmds2+1
@@:
	movzx	edx, byte [esi]
	cmp	al, [esi-1]
	jz	.found1
	lea	esi, [esi+edx+2]
	cmp	byte [esi], 0
	jnz	@b
	sub	[disasm_cur_pos], 2
	mov	eax, 'repn'
	stosd
	mov	al, 'z'
	stosb
	and	byte [edi], 0
	ret
.found0:
	push	ecx
	mov	ecx, edx
	inc	esi
	rep	movsb
	pop	ecx
	mov	al, 's'
	stosb
	mov	al, 'd'
	jmp	rep_sse_final
.found1:
	push	ecx
	mov	ecx, edx
	inc	esi
	rep	movsb
	pop	ecx
	mov	al, 'p'
	stosb
	mov	al, 's'
rep_sse_final:
	stosb
	push	ecx
	push	5
	pop	ecx
	sub	ecx, edx
	adc	ecx, 1
	mov	al, ' '
	rep	stosb
	pop	ecx
	or	ch, 1
	jmp	disasm_mmx1
 
macro disasm_set_modew
{
	test	al, 1
	jz	@f
	or	ch, 80h
@@:
}
 
cmov2:
	disasm_set_modew
; mov r/m,i
	call	disasm_get_byte
	dec	[disasm_cur_pos]
	test	al, 00111000b
	jnz	cunk
	mov	eax, 'mov '
	stosd
	mov	eax, '    '
	stosd
	call	disasm_readrmop
	mov	ax, ', '
	stosw
	xor	eax, eax
	test	ch, 80h
	jnz	.1
	call	disasm_get_byte
	jmp	.3
.1:
	test	ch, 1
	jnz	.2
	call	disasm_get_dword
	jmp	.3
.2:
	call	disasm_get_word
.3:
	call	disasm_write_num
	and	byte [edi], 0
	ret
 
cret2:
	mov	eax, 'ret '
	stosd
	mov	eax, '    '
	stosd
	xor	eax, eax
	jmp	cmov2.2
 
disasm_write_num:
	push	esi
	cmp	eax, 0x80
	jl	.nosymb
	lea	esi, [eax-1]
	test	eax, esi
	jz	.nosymb
	call	find_symbol
	jc	.nosymb
@@:
	lodsb
	test	al, al
	jz	@f
	stosb
	jmp	@b
@@:
	pop	esi
	ret
.nosymb:
	pop	esi
	push	ecx eax
	inc	edi
@@:
	mov	ecx, eax
	shr	eax, 4
	jz	@f
	inc	edi
	jmp	@b
@@:
	pop	eax
	cmp	ecx, 10
	jb	@f
	inc	edi
@@:
	push	edi eax
@@:
	mov	ecx, eax
	and	al, 0xF
	cmp	al, 10
	sbb	al, 69h
	das
	dec	edi
	mov	[edi], al
	mov	eax, ecx
	shr	eax, 4
	jnz	@b
	cmp	ecx, 10
	jb	@f
	mov	byte [edi-1], '0'
@@:
	pop	eax edi ecx
	cmp	eax, 10
	jb	@f
	mov	byte [edi], 'h'
	inc	edi
@@:
	ret
 
iglobal
label disasm_regs32 dword
label disasm_regs dword
	db	'eax',0
	db	'ecx',0
	db	'edx',0
	db	'ebx',0
	db	'esp',0
	db	'ebp',0
	db	'esi',0
	db	'edi',0
disasm_regs16	dw	'ax','cx','dx','bx','sp','bp','si','di'
disasm_regs8	dw	'al','cl','dl','bl','ah','ch','dh','bh'
disasm_scale	db	'1248'
endg
disasm_readrmop:
	call	disasm_get_byte
	test	ch, 40h
	jnz	.skip_size
	push	eax
	and	al, 0xC0
	cmp	al, 0xC0
	pop	eax
	jz	.skip_size
	test	ch, 80h
	jz	.byte
	test	ch, 1
	jnz	.word
	mov	dword [edi], 'dwor'
	mov	byte [edi+4], 'd'
	inc	edi
	jmp	@f
.byte:
	test	ch, 20h
	jz	.qb
	mov	byte [edi], 't'
	inc	edi
.qb:
	mov	dword [edi], 'byte'
	jmp	@f
.word:
	test	ch, 20h
	jz	.qw
	mov	byte [edi], 'q'
	inc	edi
.qw:
	mov	dword [edi], 'word'
@@:
	mov	byte [edi+4], ' '
	add	edi, 5
.skip_size:
	test	ch, 2
	jnz	disasm_readrmop16
	push	ecx
	movzx	ecx, al
	and	eax, 7
	shr	ecx, 6
	jz	.vmod0
	jp	.vmod3
	mov	byte [edi], '['
	inc	edi
	cmp	al, 4
	jz	.sib1
	mov	eax, [disasm_regs+eax*4]
	stosd
	dec	edi
	jmp	@f
.sib1:
	call	.parse_sib
@@:
	mov	al, '+'
	stosb
	dec	ecx
	jz	.vmod1
	call	disasm_get_dword
	jmp	@f
.vmod1:
	call	disasm_get_byte
	movsx	eax, al
@@:
	test	eax, eax
	jns	.2
	neg	eax
	mov	byte [edi-1], '-'
.2:
	call	disasm_write_num
.2a:
	mov	al, ']'
	stosb
	pop	ecx
	ret
.vmod3:
	pop	ecx
	test	ch, 10h
	jnz	.vmod3_mmi
	test	ch, 80h
	jz	.vmod3_byte
	test	ch, 1
	jnz	.vmod3_word
	test	ch, 20h
	jnz	.vmod3_sti
	mov	eax, [disasm_regs32+eax*4]
	stosd
	dec	edi
	ret
.vmod3_byte:
	mov	ax, [disasm_regs8+eax*2]
@@:
	stosw
	ret
.vmod3_word:
	mov	ax, [disasm_regs16+eax*2]
	jmp	@b
.vmod3_sti:
	mov	word [edi], 'st'
	add	al, '0'
	mov	byte [edi+2], al
	add	edi, 3
	ret
.vmod3_mmi:
disasm_write_mmreg = $
	test	ch, 1
	jz	@f
	mov	byte [edi], 'x'
	inc	edi
@@:
	mov	word [edi], 'mm'
	add	al, '0'
	mov	byte [edi+2], al
	add	edi, 3
	ret
.vmod0:
	mov	byte [edi], '['
	inc	edi
	cmp	al, 4
	jz	.sib2
	cmp	al, 5
	jz	.ofs32
	mov	eax, [disasm_regs+eax*4]
	stosd
	mov	byte [edi-1], ']'
	pop	ecx
	ret
.ofs32:
	call	disasm_get_dword
	jmp	.2
.sib2:
	call	.parse_sib
	mov	al, ']'
	stosb
	pop	ecx
	ret
.parse_sib:
	call	disasm_get_byte
	push	edx
	mov	dl, al
	mov	dh, 0
	and	eax, 7
	cmp	al, 5
	jnz	@f
	jecxz	.sib0
@@:
	mov	eax, [disasm_regs+eax*4]
	stosd
	dec	edi
	mov	dh, 1
.sib0:
	mov	al, dl
	shr	eax, 3
	and	eax, 7
	cmp	al, 4
	jz	.sibret
	test	dh, dh
	jz	@f
	mov	byte [edi], '+'
	inc	edi
@@:
	mov	eax, [disasm_regs+eax*4]
	stosd
	dec	edi
	shr	dl, 6
	jz	@f
	mov	al, '*'
	stosb
	movzx	eax, dl
	mov	al, [disasm_scale+eax]
	stosb
@@:
.sibret:
	test	dh, dh
	jnz	.sibret2
	call	disasm_get_dword
	cmp	byte [edi-1], '['
	jz	@f
	mov	byte [edi], '+'
	test	eax, eax
	jns	.sibns
	neg	eax
	mov	byte [edi], '-'
.sibns:
	inc	edi
@@:
	call	disasm_write_num
.sibret2:
	pop	edx
	ret
 
iglobal
disasm_rm16_1	dd	'bxsi','bxdi','bpsi','bpdi'
disasm_rm16_2	dw	'si','di','bp','bx'
endg
disasm_readrmop16:
	push	ecx
	movzx	ecx, al
	and	eax, 7
	shr	ecx, 6
	jz	.vmod0
	jp	disasm_readrmop.vmod3	; mod=3 is the same in 16- and 32-bit code
; 1 or 2
	mov	byte [edi], '['
	inc	edi
	cmp	al, 4
	jae	@f
	mov	eax, [disasm_rm16_1+eax*4]
	stosw
	mov	al, '+'
	stosb
	shr	eax, 16
	jmp	.1
@@:
	mov	eax, dword [disasm_rm16_2+eax*2-4*2]
.1:
	stosw
	mov	al, '+'
	stosb
	xor	eax, eax
	dec	ecx
	jnz	.2
	call	disasm_get_byte
	cbw
	jmp	@f
.2:
	call	disasm_get_word
@@:
	test	ax, ax
	jns	@f
	mov	byte [edi-1], '-'
	neg	ax
@@:
	call	disasm_write_num
.done1:
	mov	al, ']'
	stosb
	pop	ecx
	ret
.vmod0:
	mov	byte [edi], '['
	inc	edi
	cmp	al, 6
	jz	.ofs16
	cmp	al, 4
	jae	@f
	mov	eax, [disasm_rm16_1+eax*4]
	stosw
	mov	al, '+'
	stosb
	shr	eax, 16
	jmp	.3
@@:
	mov	eax, dword [disasm_rm16_2+eax*2-4*2]
.3:
	stosw
	jmp	.done1
.ofs16:
	xor	eax, eax
	call	disasm_get_word
	call	disasm_write_num
	jmp	.done1
 
cpush21:
	mov	eax, 'push'
	stosd
	mov	eax, '    '
	stosd
disasm_i32:
	call	disasm_get_dword
	call	disasm_write_num
	and	byte [edi], 0
	ret
 
cpush22:
	mov	eax, 'push'
	stosd
	mov	eax, '    '
	stosd
	call	disasm_get_byte
	movsx	eax, al
@@:
	call	disasm_write_num
	and	byte [edi], 0
	ret
 
center:
	mov	eax, 'ente'
	stosd
	mov	eax, 'r   '
	stosd
	xor	eax, eax
	call	disasm_get_word
	call	disasm_write_num
	mov	al, ','
	stosb
	mov	al, ' '
	stosb
	xor	eax, eax
	call	disasm_get_byte
	jmp	@b
 
cinc1:
; inc reg32
cdec1:
; dec reg32
cpush1:
; push reg32
cpop1:
; pop reg32
cbswap:
; bswap reg32
	mov	edx, eax
	and	edx, 7
	shr	eax, 3
	sub	al, 8
	mov	esi, 'inc '
	jz	@f
	mov	esi, 'dec '
	dec	al
	jz	@f
	mov	esi, 'push'
	dec	al
	jz	@f
	mov	esi, 'pop '
	dec	al
	jz	@f
	mov	esi, 'bswa'
@@:
	xchg	eax, esi
	stosd
	mov	eax, '    '
	jz	@f
	mov	al, 'p'
@@:
	stosd
	xchg	eax, edx
	call	disasm_write_reg1632
	and	byte [edi], 0
	ret
 
cxchg1:
; xchg eax,reg32
	and	eax, 7
	xchg	eax, edx
	mov	eax, 'xchg'
	stosd
	mov	eax, '    '
	stosd
	xor	eax, eax
	call	disasm_write_reg1632
	mov	ax, ', '
	stosw
	xchg	eax, edx
	call	disasm_write_reg1632
	and	byte [edi], 0
	ret
 
cint:
	mov	eax, 'int '
	stosd
	mov	eax, '    '
	stosd
disasm_i8u:
	xor	eax, eax
	call	disasm_get_byte
	call	disasm_write_num
	and	byte [edi], 0
	ret
 
cmov11:
; mov r8,i8
	mov	ecx, eax
	mov	eax, 'mov '
	stosd
	mov	eax, '    '
	stosd
	and	ecx, 7
	mov	ax, [disasm_regs8+ecx*2]
	stosw
	mov	ax, ', '
	stosw
	jmp	disasm_i8u
 
cmov12:
; mov r32,i32
	xchg	eax, edx
	mov	eax, 'mov '
	stosd
	mov	eax, '    '
	stosd
	xchg	eax, edx
	and	eax, 7
	call	disasm_write_reg1632
	mov	ax, ', '
	stosw
	jmp	cmov2.1
 
iglobal
disasm_shifts	dd	'rol ','ror ','rcl ','rcr ','shl ','shr ','sal ','sar '
endg
cshift2:
; shift r/m,1 = D0/D1
cshift3:
; shift r/m,cl = D2/D3
	disasm_set_modew
	mov	dl, al
	call	disasm_get_byte
	dec	[disasm_cur_pos]
	shr	al, 3
	and	eax, 7
	mov	eax, [disasm_shifts+eax*4]
	stosd
	mov	eax, '    '
	stosd
	call	disasm_readrmop
	cmp	dl, 0xD2
	jb	.s1
	mov	eax, ', cl'
	stosd
	and	byte [edi], 0
	ret
.s1:
	mov	eax, ', 1'
	stosd
	clc
	ret
 
cshift1:
; shift r/m,i8 = C0/C1
	disasm_set_modew
	call	disasm_get_byte
	dec	[disasm_cur_pos]
	shr	al, 3
	and	eax, 7
	mov	eax, [disasm_shifts+eax*4]
	stosd
	mov	eax, '    '
	stosd
	call	disasm_readrmop
	mov	ax, ', '
	stosw
	jmp	disasm_i8u
 
caam:
	mov	eax, 'aam '
	jmp	@f
caad:
	mov	eax, 'aad '
@@:
	stosd
	mov	eax, '    '
	stosd
	xor	eax, eax
	call	disasm_get_byte
	cmp	al, 10
	jz	@f
	call	disasm_write_num
@@:
	and	byte [edi], 0
	ret
 
cmov3:
; A0: mov al,[ofs32]
; A1: mov ax/eax,[ofs32]
; A2: mov [ofs32],al
; A3: mov [ofs32],ax/eax
	mov	edx, 'mov '
	xchg	eax, edx
	stosd
	mov	eax, '    '
	stosd
	test	dl, 2
	jnz	.1
	call	.write_acc
	mov	ax, ', '
	stosw
	call	.write_ofs32
	jmp	.2
.1:
	call	.write_ofs32
	mov	ax, ', '
	stosw
	call	.write_acc
.2:	and	byte [edi], 0
	ret
.write_acc:
	test	dl, 1
	jz	.8bit
	test	ch, 1
	jnz	.16bit
	mov	eax, 'eax'
	stosd
	dec	edi
	ret
.16bit:
	mov	ax, 'ax'
	stosw
	ret
.8bit:
	mov	ax, 'al'
	stosw
	ret
.write_ofs32:
	mov	al, '['
	stosb
	call	disasm_get_dword
	call	disasm_write_num
	mov	al, ']'
	stosb
	ret
 
disasm_write_reg:
	test	ch, 80h
	jnz	disasm_write_reg1632
	mov	ax, [disasm_regs8+eax*2]
	stosw
	ret
disasm_write_reg1632:
	test	ch, 1
	jnz	@f
	mov	eax, [disasm_regs32+eax*4]
	stosd
	dec	edi
	ret
@@:
	mov	ax, [disasm_regs16+eax*2]
	stosw
	ret
 
cmovzx:		; 0F B6/B7
cmovsx:		; 0F BE/BF
	mov	edx, eax
	disasm_set_modew
	mov	eax, 'movz'
	cmp	dl, 0xB8
	jb	@f
	mov	eax, 'movs'
@@:
	stosd
	mov	eax, 'x   '
	stosd
	call	disasm_get_byte
	dec	[disasm_cur_pos]
	shr	al, 3
	and	eax, 7
	call	disasm_write_reg1632
	mov	ax, ', '
	stosw
	or	ch, 1	; 2nd operand - 8 or 16 bits
	call	disasm_readrmop
	and	byte [edi], 0
	ret
 
iglobal
disasm_op2cmds	dd 'add ','or  ','adc ','sbb ','and ','sub ','xor ','cmp '
endg
cop21:
	disasm_set_modew
	mov	esi, 'test'
	cmp	al, 0A8h
	jae	@f
	shr	al, 3
	and	eax, 7
	mov	esi, [disasm_op2cmds+eax*4]
@@:
	xchg	eax, esi
	stosd
	mov	eax, '    '
	stosd
	test	ch, 80h
	jnz	.1632
	mov	eax, 'al, '
	stosd
	jmp	disasm_i8u
.1632:
	test	ch, 1
	jnz	.16
	mov	eax, 'eax,'
	stosd
	mov	al, ' '
	stosb
	call	disasm_get_dword
	jmp	.x
.16:
	mov	eax, 'ax, '
	stosd
	xor	eax, eax
	call	disasm_get_word
.x:
	call	disasm_write_num
	and	byte [edi], 0
	ret
 
carpl:
	xor	edx, edx
	or	ch, 0C1h
	mov	eax, 'arpl'
	jmp	cop22.d2
 
ccmpxchg:
	xor	edx, edx
	disasm_set_modew
	or	ch, 40h
	mov	eax, 'cmpx'
	stosd
	mov	eax, 'chg '
	jmp	cop22.d1
 
cbsf:
cbsr:
	or	ch, 80h
 
cop22:
	disasm_set_modew
	or	ch, 40h
	mov	edx, eax
	mov	esi, 'lea '
	cmp	al, 8Dh
	jz	@f
	mov	esi, 'imul'
	cmp	al, 0xAF
	jz	@f
	mov	esi, 'bsf '
	cmp	al, 0BCh
	jz	@f
	mov	esi, 'bsr '
	cmp	al, 0BDh
	jz	@f
	mov	esi, 'mov '
	cmp	al, 88h
	jae	@f
	mov	esi, 'xchg'
	cmp	al, 86h
	jae	@f
	mov	esi, 'test'
	cmp	al, 84h
	jae	@f
	shr	al, 3
	and	eax, 7
	mov	esi, [disasm_op2cmds+eax*4]
@@:
	xchg	eax, esi
.d2:
	stosd
	mov	eax, '    '
.d1:
	stosd
	call	disasm_get_byte
	dec	[disasm_cur_pos]
	shr	al, 3
	and	eax, 7
	cmp	dl, 0x8D
	jz	@f
	cmp	dl, 0x86
	jz	@f
	cmp	dl, 0x87
	jz	@f
	cmp	dl, 0xBC
	jz	@f
	cmp	dl, 0xBD
	jz	@f
	test	dl, 2
	jz	.d0
@@:
	call	disasm_write_reg
	mov	ax, ', '
	stosw
	call	disasm_readrmop
	and	byte [edi], 0
	ret
.d0:
	push	eax
	call	disasm_readrmop
	mov	ax, ', '
	stosw
	pop	eax
	call	disasm_write_reg
	and	byte [edi], 0
	ret
 
cbound:
	mov	edx, eax
	mov	eax, 'boun'
	stosd
	mov	eax, 'd   '
	or	ch, 0xC0
	jmp	cop22.d1
 
cop23:
	disasm_set_modew
	xchg	eax, edx
	call	disasm_get_byte
	dec	[disasm_cur_pos]
	shr	eax, 3
	and	eax, 7
	mov	eax, [disasm_op2cmds+eax*4]
ctest:
	stosd
	mov	eax, '    '
	stosd
	call	disasm_readrmop
	mov	ax, ', '
	stosw
	test	ch, 80h
	jz	.i8
	cmp	dl, 83h
	jz	.i8
	test	ch, 1
	jnz	.i16
	call	disasm_get_dword
	jmp	.ic
.i8:
	xor	eax, eax
	call	disasm_get_byte
	cmp	dl, 83h
	jnz	.ic
	movsx	eax, al
	jmp	.ic
.i16:
	xor	eax, eax
	call	disasm_get_word
.ic:
	call	disasm_write_num
	and	byte [edi], 0
	ret
 
cmovcc:
	or	ch, 0C0h
	and	eax, 0xF
	mov	ax, [disasm_jcc_codes + eax*2]
	mov	dword [edi], 'cmov'
	add	edi, 4
	stosw
	mov	ax, '  '
	stosw
	call	disasm_get_byte
	dec	[disasm_cur_pos]
	shr	eax, 3
	and	eax, 7
	call	disasm_write_reg1632
	mov	ax, ', '
	stosw
	call	disasm_readrmop
	and	byte [edi], 0
	ret
 
cbtx1:
; btx r/m,i8 = 0F BA
	or	ch, 80h
	call	disasm_get_byte
	dec	[disasm_cur_pos]
	shr	al, 3
	and	eax, 7
	cmp	al, 4
	jb	cunk
	mov	eax, [btx1codes+eax*4-4*4]
	stosd
	mov	eax, '    '
	stosd
	call	disasm_readrmop
	mov	ax, ', '
	stosw
	jmp	disasm_i8u
iglobal
btx1codes	dd	'bt  ','bts ','btr ','btc '
endg
cbtx2:
; btx r/m,r = 0F 101xx011 (A3,AB,B3,BB)
	shr	al, 3
	and	eax, 3
	mov	eax, [btx1codes+eax*4]
	stosd
	mov	eax, '    '
	stosd
	or	ch, 0xC0
	call	disasm_get_byte
	dec	[disasm_cur_pos]
	shr	al, 3
	and	eax, 7
	push	eax
	call	disasm_readrmop
	mov	ax, ', '
	stosw
	pop	eax
	call	disasm_write_reg1632
	and	byte [edi], 0
	ret
 
csetcc:
	and	eax, 0xF
	mov	ax, [disasm_jcc_codes + eax*2]
	mov	dword [edi], 'setc'
	add	edi, 3
	stosw
	mov	ax, '  '
	stosw
	stosb
	call	disasm_readrmop
	and	byte [edi], 0
	ret
 
iglobal
disasm_jcc_codes dw 'o ','no','b ','ae','z ','nz','be','a ','s ','ns','p ','np','l ','ge','le','g '
endg
cjcc1:
cjmp2:
	cmp	al, 0xEB
	jz	.1
	and	eax, 0xF
	mov	ax, [disasm_jcc_codes + eax*2]
	jmp	.2
.1:
	mov	ax, 'mp'
.2:
	mov	byte [edi], 'j'
	inc	edi
	stosw
	mov	eax, '    '
	stosb
	stosd
	call	disasm_get_byte
	movsx	eax, al
disasm_rva:
	add	eax, [disasm_cur_pos]
	call	disasm_write_num
	and	byte [edi], 0
	ret
 
ccall1:
cjmp1:
cjcc2:
	mov	edx, 'call'
	cmp	al, 0xE8
	jz	@f
	mov	edx, 'jmp '
	cmp	al, 0xE9
	jz	@f
	mov	edx, '    '
	and	eax, 0xF
	mov	dx, [disasm_jcc_codes+eax*2]
	shl	edx, 8
	mov	dl, 'j'
@@:
	xchg	eax, edx
	stosd
	mov	eax, '    '
	stosd
	test	ch, 1
	jnz	@f
	call	disasm_get_dword
	jmp	disasm_rva
@@:
	call	disasm_get_word
	add	eax, [disasm_cur_pos]
	and	eax, 0xFFFF
	call	disasm_write_num
	and	byte [edi], 0
	ret
 
ccallf:
	mov	eax, 'call'
	stosd
	mov	eax, '    '
	stosd
	mov	al, 'd'
	test	ch, 1
	jnz	@f
	mov	al, 'p'
@@:
	stosb
	mov	eax, 'word'
	stosd
	mov	al, ' '
	stosb
	test	ch, 1
	jnz	.1
	call	disasm_get_dword
	jmp	.2
.1:
	xor	eax, eax
	call	disasm_get_word
.2:
	push	eax
	xor	eax, eax
	call	disasm_get_word
	call	disasm_write_num
	mov	al, ':'
	stosb
	pop	eax
	call	disasm_write_num
	and	byte [edi], 0
	ret
 
iglobal
op11codes	dd	'test',0,'not ','neg ','mul ','imul','div ','idiv'
op12codes	dd	'inc ','dec ','call',0,'jmp ',0,'push',0
endg
cop1:
	disasm_set_modew
	xchg	eax, edx
	call	disasm_get_byte
	movzx	esi, al
	dec	[disasm_cur_pos]
	shr	al, 3
	and	eax, 7
	cmp	dl, 0xFE
	jnz	@f
	cmp	al, 1
	jbe	@f
.0:
	inc	[disasm_cur_pos]
	jmp	cunk
@@:
	and	edx, 8
	add	eax, edx
	cmp	al, 11
	jz	.callfar
	cmp	al, 13
	jz	.jmpfar
	mov	eax, [op11codes+eax*4]
	test	eax, eax
	jz	.0
	cmp	eax, 'test'
	jz	ctest
.2:
	stosd
	mov	eax, '    '
	stosd
	call	disasm_readrmop
	and	byte [edi], 0
	ret
.callfar:
	mov	eax, 'call'
.1:
	cmp	esi, 0xC0
	jae	.0
	stosd
	mov	eax, '    '
	stosd
	mov	eax, 'far '
	stosd
	mov	al, 'd'
	test	ch, 1
	jnz	@f
	mov	al, 'p'
@@:
	stosb
	or	ch, 1
	call	disasm_readrmop
	and	byte [edi], 0
	ret
.jmpfar:
	mov	eax, 'jmp '
	jmp	.1
 
cpop2:
	or	ch, 80h
	call	disasm_get_byte
	dec	[disasm_cur_pos]
	test	al, 00111000b
	jnz	cunk
	mov	eax, 'pop '
	jmp	cop1.2
 
cloopnz:
	mov	eax, 'loop'
	stosd
	mov	eax, 'nz  '
	test	ch, 2
	jz	@f
	mov	ah, 'w'
@@:	jmp	cloop.cmn
cloopz:
	mov	eax, 'loop'
	stosd
	mov	eax, 'z   '
	test	ch, 2
	jz	@f
	mov	eax, 'zw  '
@@:	jmp	cloop.cmn
 
cjcxz:
cloop:
	cmp	al, 0xE2
	jz	.loop
	test	ch, 2
	jnz	.jcxz
	mov	eax, 'jecx'
	stosd
	mov	eax, 'z   '
	jmp	.cmn
.jcxz:
	mov	eax, 'jcxz'
	stosd
	mov	eax, '    '
	jmp	.cmn
.loop:
	mov	eax, 'loop'
	stosd
	mov	eax, '    '
	test	ch, 2
	jz	.cmn
	mov	al, 'w'
.cmn:
	stosd
	call	disasm_get_byte
	movsx	eax, al
	add	eax, [disasm_cur_pos]
	test	ch, 1
	jz	@f
	and	eax, 0xFFFF
@@:
disasm_write_num_done:
	call	disasm_write_num
	and	byte [edi], 0
	ret
 
cimul1:
; imul r,r/m,i
	or	ch, 80h		; 32bit operation
	xchg	eax, edx
	mov	eax, 'imul'
	stosd
	mov	eax, '    '
	stosd
	call	disasm_get_byte
	dec	[disasm_cur_pos]
	shr	al, 3
	and	eax, 7
	call	disasm_write_reg1632
	mov	ax, ', '
	stosw
	call	disasm_readrmop
	mov	ax, ', '
	stosw
	test	ch, 1
	jnz	.16
	cmp	dl, 0x69
	jz	.op32
	call	disasm_get_byte
	movsx	eax, al
	jmp	disasm_write_num_done
.op32:
	call	disasm_get_dword
	jmp	disasm_write_num_done
.16:
	cmp	dl, 0x69
	jz	.op16
	call	disasm_get_byte
	cbw
	jmp	disasm_write_num_done
.op16:
	xor	eax, eax
	call	disasm_get_word
	jmp	disasm_write_num_done
 
cshld:
cshrd:
	mov	edx, 'shld'
	test	al, 8
	jz	@f
	mov	edx, 'shrd'
@@:
	xchg	eax, edx
	stosd
	mov	eax, '    '
	stosd
	call	disasm_get_byte
	dec	[disasm_cur_pos]
	shr	al, 3
	and	eax, 7
	push	eax
	or	ch, 80h
	call	disasm_readrmop
	mov	ax, ', '
	stosw
	pop	eax
	call	disasm_write_reg1632
	mov	ax, ', '
	stosw
	test	dl, 1
	jz	disasm_i8u
	mov	ax, 'cl'
	stosw
	and	byte [edi], 0
	ret
 
ccbw:
	mov	eax, 'cbw '
	test	ch, 1
	jnz	@f
	mov	eax, 'cwde'
@@:	stosd
	and	byte [edi], 0
	ret
ccwd:
	mov	eax, 'cwd '
	test	ch, 1
	jnz	@b
	mov	eax, 'cdq '
	jmp	@b
 
ccmpxchg8b:
	call	disasm_get_byte
	cmp	al, 0xC0
	jae	cerr
	shr	al, 3
	and	al, 7
	cmp	al, 1
	jnz	cerr
	dec	[disasm_cur_pos]
	mov	eax, 'cmpx'
	stosd
	mov	eax, 'chg8'
	stosd
	mov	al, 'b'
	stosb
	mov	al, ' '
	stosb
	or	ch, 40h
	call	disasm_readrmop
	and	byte [edi], 0
	ret
 
iglobal
fpuD8	dd	'add ','mul ','com ','comp','sub ','subr','div ','divr'
endg
 
cD8:
	call	disasm_get_byte
	dec	[disasm_cur_pos]
	push	eax
	shr	al, 3
	and	eax, 7
	mov	byte [edi], 'f'
	inc	edi
	xchg	eax, edx
	mov	eax, [fpuD8+edx*4]
	stosd
	mov	ax, '  '
	stosw
	stosb
	pop	eax
	cmp	dl, 2
	jb	.1
	cmp	dl, 3
	jbe	.2
.1:
	cmp	al, 0xC0
	jb	.2
	mov	eax, 'st0,'
	stosd
	mov	al, ' '
	stosb
.2:
	or	ch, 80h or 20h
	and	ch, not 1
	call	disasm_readrmop
	and	byte [edi], 0
	ret
 
iglobal
fpuD9_2:
	dq	'fchs    ','fabs    ',0,0,'ftst    ','fxam    ',0,0
	db	'fld1    fldl2t  fldl2e  fldpi   fldlg2  fldln2  fldz    '
	dq	0
	db	'f2xm1   fyl2x   fptan   fpatan  fxtract fprem1  fdecstp fincstp '
	db	'fprem   fyl2xp1 fsqrt   fsincos frndint fscale  fsin    fcos    '
fpuD9_fnop	db	'fnop    '
endg
cD9:
	call	disasm_get_byte
	sub	al, 0xC0
	jae	.l1
	dec	[disasm_cur_pos]
	shr	al, 3
	and	eax, 7
	cmp	al, 7
	jnz	@f
	mov	eax, 'fnst'
	stosd
	mov	eax, 'cw  '
	jmp	.x1
@@:
	cmp	al, 5
	jnz	@f
	mov	eax, 'fldc'
	stosd
	mov	eax, 'w   '
.x1:
	stosd
	or	ch, 0C1h
	jmp	.cmn
@@:
	mov	edx, 'fld '
	test	al, al
	jz	@f
	mov	edx, 'fst '
	cmp	al, 2
	jz	@f
	mov	edx, 'fstp'
	cmp	al, 3
	jnz	cunk
@@:
	xchg	eax, edx
	stosd
	mov	eax, '    '
	stosd
	or	ch, 80h
	and	ch, not 1
.cmn:
	call	disasm_readrmop
	and	byte [edi], 0
	ret
.l1:
	cmp	al, 10h
	jae	.l2
	mov	edx, 'fld '
	cmp	al, 8
	jb	@f
	mov	edx, 'fxch'
@@:
	xchg	eax, edx
	stosd
	mov	eax, '    '
	stosd
	xchg	eax, edx
	and	al, 7
	add	al, '0'
	shl	eax, 16
	mov	ax, 'st'
	stosd
	clc
	ret
.l2:
	cmp	al, 0x10
	jnz	@f
	mov	esi, fpuD9_fnop
	jmp	.l3
@@:
	sub	al, 0x20
	jb	cerr
	lea	esi, [fpuD9_2+eax*8]
	cmp	byte [esi], 0
	jz	cerr
.l3:
	movsd
	movsd
	and	byte [edi-1], 0
	ret
 
cDA:
	call	disasm_get_byte
	cmp	al, 0xC0
	jae	cunk
	dec	[disasm_cur_pos]
	shr	al, 3
	and	eax, 7
	mov	word [edi], 'fi'
	inc	edi
	inc	edi
	mov	eax, [fpuD8+eax*4]
	stosd
	mov	ax, '  '
	stosw
	or	ch, 80h
	and	ch, not 1	; 32-bit operand
	call	disasm_readrmop
	and	byte [edi], 0
	ret
 
iglobal
fpuDB	dd	'ild ',0,'ist ','istp',0,'ld  ',0,'stp '
endg
cDB:
	call	disasm_get_byte
	cmp	al, 0xC0
	jae	.1
	dec	[disasm_cur_pos]
	shr	al, 3
	and	eax, 7
	xchg	eax, edx
	mov	eax, [fpuDB+edx*4]
	test	eax, eax
	jz	cerr
	mov	byte [edi], 'f'
	inc	edi
	stosd
	mov	ax, '  '
	stosw
	stosb
	or	ch, 80h
	and	ch, not 1	; 32-bit operand
	cmp	dl, 4
	jb	@f
	or	ch, 20h
	and	ch, not 80h	; 80-bit operand
@@:
	call	disasm_readrmop
	and	byte [edi], 0
	ret
.1:
	cmp	al, 0xE3
	jnz	cunk
	mov	eax, 'fnin'
	stosd
	mov	eax, 'it'
	stosd
	dec	edi
	ret		; CF cleared
 
iglobal
fpuDC	dd	'add ','mul ',0,0,'subr','sub ','divr','div '
endg
cDC:
	call	disasm_get_byte
	cmp	al, 0xC0
	jae	.1
	dec	[disasm_cur_pos]
	shr	al, 3
	and	eax, 7
	mov	byte [edi], 'f'
	inc	edi
	mov	eax, [fpuD8+eax*4]
	stosd
	mov	ax, '  '
	stosw
	stosb
	or	ch, 0A1h	; qword
	call	disasm_readrmop
	and	byte [edi], 0
	ret
.1:
	mov	dl, al
	shr	al, 3
	and	eax, 7
	mov	eax, [fpuDC+eax*4]
	test	eax, eax
	jz	cerr
	mov	byte [edi], 'f'
	inc	edi
	stosd
	mov	eax, '   s'
	stosd
	mov	al, 't'
	stosb
	and	edx, 7
	lea	eax, [edx+'0']
	stosb
	mov	eax, ', st'
	stosd
	mov	ax, '0'
	stosw
	ret	; CF cleared
 
iglobal
fpuDD	dd	'fld ',0,'fst ','fstp',0,0,0,0
fpuDD_2	dq	'ffree   ',0,'fst     ','fstp    ','fucom   ','fucomp  ',0,0
endg
cDD:
	call	disasm_get_byte
	cmp	al, 0xC0
	jae	.1
	dec	[disasm_cur_pos]
	shr	al, 3
	and	eax, 7
	xchg	eax, edx
	mov	eax, [fpuDD+edx*4]
	test	eax, eax
	jz	cunk
	stosd
	mov	eax, '    '
	stosd
	or	ch, 0A1h	; qword operand
	call	disasm_readrmop
	and	byte [edi], 0
	ret
.1:
	push	eax
	shr	al, 3
	and	eax, 7
	xchg	eax, edx
	mov	eax, dword [fpuDD_2+edx*8]
	test	eax, eax
	jz	cerr
	stosd
	mov	eax, dword [fpuDD_2+4+edx*8]
	stosd
	mov	ax, 'st'
	stosw
	pop	eax
	and	al, 7
	add	al, '0'
	stosb
	and	byte [edi], 0
	ret
 
iglobal
fpuDE	dd	'add ','mul ',0,0,'subr','sub ','divr','div '
endg
cDE:
	call	disasm_get_byte
	cmp	al, 0xC0
	jae	.1
	dec	[disasm_cur_pos]
	mov	word [edi], 'fi'
	inc	edi
	inc	edi
	shr	al, 3
	and	eax, 7
	mov	eax, [fpuD8+eax*4]
	stosd
	mov	ax, '  '
	stosw
	or	ch, 81h		; force 16-bit
	call	disasm_readrmop
	and	byte [edi], 0
	ret
.1:
	push	eax
	shr	al, 3
	and	eax, 7
	xchg	eax, edx
	mov	eax, [fpuDE+edx*4]
	test	eax, eax
	jz	.fcompp
	mov	byte [edi], 'f'
	inc	edi
	stosd
	mov	al, 'p'
	cmp	byte [edi-1], ' '
	jnz	@f
	mov	byte [edi-1], al
	mov	al, ' '
@@:	stosb
	mov	eax, '  st'
	stosd
	pop	eax
	and	al, 7
	add	al, '0'
	stosb
	mov	ax, ', '
	stosw
	mov	eax, 'st0'
	stosd
	ret	; CF cleared
.fcompp:
	pop	eax
	cmp	al, 0xD9
	jnz	cerr
	mov	eax, 'fcom'
	stosd
	mov	ax, 'pp'
	stosw
	and	byte [edi], 0
	ret
 
iglobal
fpuDF	dd	'ild ',0,'ist ','istp','bld ','ild ','bstp','istp'
endg
 
cDF:
	call	disasm_get_byte
	cmp	al, 0xC0
	jae	.1
	dec	[disasm_cur_pos]
	shr	al, 3
	and	eax, 7
	xchg	eax, edx
	mov	eax, [fpuDF+edx*4]
	test	eax, eax
	jz	cerr
	mov	byte [edi], 'f'
	inc	edi
	stosd
	mov	ax, '  '
	stosw
	stosb
	or	ch, 81h		; force 16-bit operand
	cmp	dl, 4
	jb	@f
	or	ch, 20h
	test	dl, 1
	jnz	@f
	or	ch, 40h
@@:
	call	disasm_readrmop
	and	byte [edi], 0
	ret
.1:
	cmp	al, 0xE0
	jnz	cunk
	mov	eax, 'fnst'
	stosd
	mov	eax, 'sw  '
	stosd
	mov	ax, 'ax'
	stosw
	and	byte [edi], 0
	ret
 
cmovd1:
	mov	eax, 'movd'
	stosd
	mov	eax, '    '
	stosd
	call	disasm_get_byte
	dec	[disasm_cur_pos]
	shr	al, 3
	and	eax, 7
	call	disasm_write_mmreg
	mov	ax, ', '
	stosw
	or	ch, 0C0h
	and	ch, not 1
	call	disasm_readrmop
	and	byte [edi], 0
	ret
cmovd2:
	mov	eax, 'movd'
	stosd
	mov	eax, '    '
	stosd
	call	disasm_get_byte
	dec	[disasm_cur_pos]
	shr	al, 3
	and	eax, 7
	push	eax ecx
	or	ch, 0C0h
	and	ch, not 1
	call	disasm_readrmop
	mov	ax, ', '
	stosw
	pop	ecx eax
	call	disasm_write_mmreg
	and	byte [edi], 0
	ret
 
cmovq1:
	test	ch, 1
	jz	.mm
	mov	eax, 'movd'
	stosd
	mov	eax, 'qa  '
	stosd
	jmp	disasm_mmx1
.mm:
	mov	eax, 'movq'
	stosd
	mov	eax, '    '
	stosd
	jmp	disasm_mmx1
cmovq2:
	test	ch, 1
	jz	.mm
	mov	eax, 'movd'
	stosd
	mov	eax, 'qa  '
	stosd
	jmp	disasm_mmx3
.mm:
	mov	eax, 'movq'
disasm_mmx2:
	stosd
	mov	eax, '    '
	stosd
disasm_mmx3:
	or	ch, 50h
	call	disasm_get_byte
	dec	[disasm_cur_pos]
	push	eax
	call	disasm_readrmop
	mov	ax, ', '
	stosw
	pop	eax
	shr	al, 3
	and	eax, 7
	call	disasm_write_mmreg
	and	byte [edi], 0
	ret
 
iglobal
mmx_cmds:
	db	0x60,'unpcklbw'
	db	0x61,'unpcklwd'
	db	0x62,'unpckldq'
	db	0x63,'packsswb'
	db	0x64,'pcmpgtb '
	db	0x65,'pcmpgtw '
	db	0x66,'pcmpgtd '
	db	0x67,'packuswb'
	db	0x68,'unpckhbw'
	db	0x69,'unpckhwd'
	db	0x6A,'unpckhdq'
	db	0x6B,'packssdw'
	db	0x74,'pcmpeqb '
	db	0x75,'pcmpeqw '
	db	0x76,'pcmpeqd '
	db	0xD4,'paddq   '
	db	0xD5,'pmullw  '
	db	0xD8,'psubusb '
	db	0xD9,'psubusw '
	db	0xDA,'pminub  '
	db	0xDB,'pand    '
	db	0xDC,'paddusb '
	db	0xDD,'paddusw '
	db	0xDE,'pmaxub  '
	db	0xDF,'pandn   '
	db	0xE0,'pavgb   '
	db	0xE3,'pavgw   '
	db	0xE4,'pmulhuw '
	db	0xE5,'pmulhw  '
	db	0xE8,'psubsb  '
	db	0xE9,'psubsw  '
	db	0xEA,'pminsw  '
	db	0xEB,'por     '
	db	0xEC,'paddsb  '
	db	0xED,'paddsw  '
	db	0xEE,'pmaxsw  '
	db	0xEF,'pxor    '
	db	0xF4,'pmuludq '
	db	0xF5,'pmaddwd '
	db	0xF6,'psadbw  '
	db	0xF8,'psubb   '
	db	0xF9,'psubw   '
	db	0xFA,'psubd   '
	db	0xFB,'psubq   '
	db	0xFC,'paddb   '
	db	0xFD,'paddw   '
	db	0xFE,'paddd   '
endg
cpcmn:
	mov	esi, mmx_cmds
@@:
	cmp	al, [esi]
	jz	@f
	add	esi, 9
	jmp	@b
@@:
	inc	esi
	mov	al, 'p'
	cmp	byte [esi], al
	jz	@f
	stosb
@@:
	movsd
	movsd
	cmp	byte [edi-1], ' '
	jz	@f
	mov	al, ' '
	stosb
@@:
 
disasm_mmx1:
	or	ch, 50h
	call	disasm_get_byte
	dec	[disasm_cur_pos]
	shr	al, 3
	and	eax, 7
	call	disasm_write_mmreg
	mov	ax, ', '
	stosw
	call	disasm_readrmop
	cmp	word [disasm_string], 'cm'
	jz	.cmp
	and	byte [edi], 0
	ret
.cmp:
	call	disasm_get_byte
	and	eax, 7
	mov	dx, 'eq'
	dec	eax
	js	@f
	mov	dx, 'lt'
	jz	@f
	mov	dh, 'e'
	dec	eax
	jnz	.no2
@@:
	xchg	dx, word [disasm_string+3]
	mov	word [disasm_string+5], dx
	and	byte [edi], 0
	ret
.no2:
	dec	eax
	jnz	@f
	add	edi, 2
	push	edi
	lea	esi, [edi-3]
	lea	ecx, [esi-(disasm_string+8)+2]
	std
	rep	movsb
	cld
	mov	cx, word [esi-3]
	mov	dword [esi-3], 'unor'
	mov	byte [esi+1], 'd'
	mov	word [esi+2], cx
	pop	edi
	and	byte [edi+1], 0
	ret
@@:
	mov	edx, 'neq'
	dec	eax
	jz	@f
	mov	edx, 'nlt'
	dec	eax
	jz	@f
	mov	edx, 'nle'
	dec	eax
	jz	@f
	mov	edx, 'ord'
@@:
	push	edi
	lea	esi, [edi-1]
	lea	ecx, [esi-(disasm_string+8)+2]
	std
	rep	movsb
	cld
	mov	cx, word [esi-3]
	mov	dword [esi-3], edx
	mov	word [esi], cx
	pop	edi
	and	byte [edi+1], 0
	ret
 
cpsrlw:
	mov	eax, 'psrl'
	jmp	@f
cpsraw:
	mov	eax, 'psra'
	jmp	@f
cpsllw:
	mov	eax, 'psll'
@@:
	stosd
	mov	eax, 'w   '
	stosd
	jmp	disasm_mmx1
cpsrld:
	mov	eax, 'psrl'
	jmp	@f
cpsrad:
	mov	eax, 'psra'
	jmp	@f
cpslld:
	mov	eax, 'psll'
@@:
	stosd
	mov	eax, 'd   '
	stosd
	jmp	disasm_mmx1
cpsrlq:
	mov	eax, 'psrl'
	jmp	@f
cpsllq:
	mov	eax, 'psll'
@@:
	stosd
	mov	eax, 'q   '
	stosd
	jmp	disasm_mmx1
 
csse1:
iglobal
sse_cmds1:
	db	0x2F,4,'comi'
	db	0x54,3,'and'
	db	0x55,4,'andn'
	db	0x58,3,'add'
	db	0xC2,3,'cmp'
endg
	mov	esi, sse_cmds1+1
.1:
@@:
	movzx	edx, byte [esi]
	cmp	al, [esi-1]
	jz	@f
	lea	esi, [esi+edx+2]
	jmp	@b
@@:
	push	ecx
	mov	ecx, edx
	inc	esi
	rep	movsb
	pop	ecx
	mov	al, 's'
	cmp	byte [edi-1], 'i'
	jz	@f
	mov	al, 'p'
@@:
	stosb
	mov	al, 'd'
	test	ch, 1
	jnz	@f
	mov	al, 's'
@@:
	stosb
	push	ecx
	push	5
	pop	ecx
	sub	ecx, edx
	adc	ecx, 1
	mov	al, ' '
	rep	stosb
	pop	ecx
	or	ch, 1		; force XMM reg
	jmp	disasm_mmx1
 
csse2:
iglobal
sse_cmds2:
	db	0xD0,6,'addsub'
	db	0,0
endg
	test	ch, 1
	jz	cerr
	mov	esi, sse_cmds2+1
	jmp	csse1.1
 
cpshift:
	mov	dl, al
	mov	ax, 'ps'
	stosw
	call	disasm_get_byte
	push	eax
	and	al, 0xC0
	cmp	al, 0xC0
	jnz	.pop_cunk
	pop	eax
	push	eax
	shr	al, 3
	and	eax, 7
	cmp	al, 2
	jz	.rl
	cmp	al, 4
	jz	.ra
	cmp	al, 6
	jz	.ll
.pop_cunk:
	pop	eax
	jmp	cunk
.ll:
	mov	ax, 'll'
	jmp	@f
.rl:
	mov	ax, 'rl'
	jmp	@f
.ra:
	cmp	dl, 0x73
	jz	.pop_cunk
	mov	ax, 'ra'
@@:
	stosw
	mov	al, 'w'
	cmp	dl, 0x71
	jz	@f
	mov	al, 'd'
	cmp	dl, 0x72
	jz	@f
	mov	al, 'q'
@@:
	stosb
	mov	ax, '  '
	stosw
	stosb
	pop	eax
	and	eax, 7
	call	disasm_write_mmreg
	mov	ax, ', '
	stosw
	xor	eax, eax
	call	disasm_get_byte
	call	disasm_write_num
	and	byte [edi], 0
	ret
 
iglobal
grp15c1	dq	'fxsave  ','fxrstor ','ldmxcsr ','stmxcsr ',0,0,0,'clflush '
endg
cgrp15:
	call	disasm_get_byte
	cmp	al, 0xC0
	jae	cunk
	shr	al, 3
	and	eax, 7
	mov	edx, eax
	mov	eax, dword [grp15c1+eax*8]
	test	eax, eax
	jz	cerr
	dec	[disasm_cur_pos]
	stosd
	mov	eax, dword [grp15c1+4+edx*8]
	stosd
	or	ch, 40h
	call	disasm_readrmop
	and	byte [edi], 0
	ret
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; DATA ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
caption_str db 'Kolibri Debugger',0
caption_len = $ - caption_str
begin_str db	'Kolibri Debugger, version 0.32',10
	db	'Hint: type "help" for help, "quit" for quit'
newline	db	10,0
prompt	db	'> ',0
 
help_groups:
	dd	aControl, 0, 0, help_control_msg
	db	0
	dd	aData, 0, 0, help_data_msg
	db	0
	dd	aBreakpoints, 0, 0, help_breaks_msg
	db	0
; 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
commands:
	dd	_aH, OnHelp, HelpSyntax, HelpHelp
	db	0Fh
	dd	aHelp, OnHelp, HelpSyntax, HelpHelp
	db	0Fh
	dd	aQuit, OnQuit, QuitSyntax, QuitHelp
	db	0Dh
	dd	aLoad, OnLoad, LoadSyntax, LoadHelp
	db	6
	dd	aReload, OnReload, ReloadSyntax, ReloadHelp
	db	0Dh
	dd	aTerminate, OnTerminate, TerminateSyntax, TerminateHelp
	db	9
	dd	aDetach, OnDetach, DetachSyntax, DetachHelp
	db	9
	dd	aSuspend, OnSuspend, SuspendSyntax, SuspendHelp
	db	9
	dd	aResume, OnResume, ResumeSyntax, ResumeHelp
	db	0Bh
	dd	aStep, OnStep, StepSyntax, StepHelp
	db	9
	dd	aProceed, OnProceed, ProceedSyntax, ProceedHelp
	db	9
	dd	aCalc, OnCalc, CalcSyntax, CalcHelp
	db	0Eh
	dd	aDump, OnDump, DumpSyntax, DumpHelp
	db	0Bh
	dd	aUnassemble, OnUnassemble, UnassembleSyntax, UnassembleHelp
	db	0Bh
	dd	aBp, OnBp, BpSyntax, BpHelp
	db	0Ah
	dd	aBpm, OnBpmb, BpmSyntax, BpmHelp
	db	0Ah
	dd	aBpmb, OnBpmb, BpmSyntax, BpmHelp
	db	0Ah
	dd	aBpmw, OnBpmw, BpmSyntax, BpmHelp
	db	0Ah
	dd	aBpmd, OnBpmd, BpmSyntax, BpmHelp
	db	0Ah
	dd	aBl, OnBl, BlSyntax, BlHelp
	db	0Bh
	dd	aBc, OnBc, BcSyntax, BcHelp
	db	0Ah
	dd	aBd, OnBd, BdSyntax, BdHelp
	db	0Ah
	dd	aBe, OnBe, BeSyntax, BeHelp
	db	0Ah
	dd	aReg, OnReg, RSyntax, RHelp
	db	0Ah
	dd	aUnpack, OnUnpack, UnpackSyntax, UnpackHelp
	db	9
	dd	aLoadSymbols, OnLoadSymbols, LoadSymbolsSyntax, LoadSymbolsHelp
	db	0Ah
	dd	0
aHelp	db	5,'help',0
_aH	db	2,'h',0
HelpHelp db	'Help on specified function',10
HelpSyntax db	'Usage: h or help [group | command]',10,0
 
help_msg db	'List of known command groups:',10
	db	'"help control"     - display list of control commands',10
	db	'"help data"        - display list of commands concerning data',10
	db	'"help breakpoints" - display list of commands concerning breakpoints',10,0
aControl db	8,'control',0
help_control_msg db	'List of control commands:',10
	db	'h = help             - help',10
	db	'quit                 - exit from debugger',10
	db	'load  [params] - load program for debugging',10
	db	'reload               - reload debugging program',10
	db	'load-symbols   - load information on symbols for program',10
	db	'terminate            - terminate loaded program',10
	db	'detach               - detach from debugging program',10
	db	'stop                 - suspend execution of debugging program',10
	db	'g []     - go on (resume execution of debugging program)',10
	db	's =         - program step',10
	db	'p =         - program wide step',10
	db	'unpack               - try to bypass unpacker code (heuristic)',10,0
aData	db	5,'data',0
help_data_msg db	'List of data commands:',10
	db	'?        - calculate value of expression',10
	db	'd []     - dump data at given address',10
	db	'u []     - unassemble instructions at given address',10
	db	'r   or',10
	db	'r = - set register value',10,0
aBreakpoints db 12,'breakpoints',0
help_breaks_msg db	'List of breakpoints commands:',10
	db	'bp       - set breakpoint on execution',10
	db	'bpm[b|w|d]   - set breakpoint on memory access',10
	db	'bl []        - breakpoint(s) info',10
	db	'bc ...       - clear breakpoint',10
	db	'bd ...       - disable breakpoint',10
	db	'be ...       - enable breakpoint',10,0
 
aQuit	db	5,'quit',0
QuitHelp db	'Quit from debugger',10
QuitSyntax db	'Usage: quit',10,0
 
aLoad	db	5,'load',0
LoadHelp db	'Load program for debugging',10
LoadSyntax db	'Usage: load  [parameters]',10,0
 
aReload db	7,'reload',0
ReloadHelp db	'Reload debugging program (restart debug session)',10
ReloadSyntax db	'Usage: reload',10,0
 
aTerminate db	10,'terminate',0
TerminateHelp db 'Terminate debugged program',10
TerminateSyntax db 'Usage: terminate',10,0
 
aDetach	db	7,'detach',0
DetachHelp db	'Detach from debugged program',10
DetachSyntax db	'Usage: detach',10,0
 
aSuspend db	5,'stop',0
SuspendHelp db	'Suspend execution of debugged program',10
SuspendSyntax db 'Usage: stop',10,0
 
aResume db	2,'g',0
ResumeHelp db	'Go (resume execution of debugged program)',10
ResumeSyntax db	'Usage: g',10
	db	'   or: g  - wait until specified address is reached',10,0
 
aStep	db	2,'s',0
StepHelp db	'Make step in debugged program',10
StepSyntax db	'Usage: s',10,0
 
aProceed db	2,'p',0
ProceedHelp db	'Make wide step in debugged program (step over CALL, REPxx, LOOP)',10
ProceedSyntax db 'Usage: p',10,0
 
aDump	db	2,'d',0
DumpHelp db	'Dump data of debugged program',10
DumpSyntax db	'Usage: d  - dump data at specified address',10
	db	'   or: d              - continue current dump',10,0
 
aCalc	db	2,'?',0
CalcHelp db	'Calculate value of expression',10
CalcSyntax db	'Usage: ? ',10,0
 
aUnassemble db	2,'u',0
UnassembleHelp db 'Unassemble',10
UnassembleSyntax:
	db	'Usage: u  - unassemble instructions at specified address',10
	db	'   or: u              - continue current unassemble screen',10,0
 
aReg	db	2,'r',0
RHelp	db	'Set register value',10
RSyntax:
	db	'Usage: r  ',10
	db	'   or: r = - set value of  to ',10,0
 
aBp	db	3,'bp',0
BpHelp	db	'set BreakPoint on execution',10
BpSyntax db	'Usage: bp ',10,0
 
aBpm	db	4,'bpm',0
aBpmb	db	5,'bpmb',0
aBpmw	db	5,'bpmw',0
aBpmd	db	5,'bpmd',0
BpmHelp	db	'set BreakPoint on Memory access',10
	db	'Maximum 4 breakpoints of this type are allowed',10
	db	'Note that for this breaks debugger is activated after access',10
BpmSyntax db	'Usage: bpmb [w] ',10
	db	'       bpmw [w] ',10
	db	'       bpmd [w] ',10
	db	'       bpm is synonym for bpmd',10
	db	'"w" means break only on writes (default is on read/write)',10,0
 
aBl	db	3,'bl',0
BlHelp	db	'Breakpoint List',10
BlSyntax db	'Usage: bl          - list all breakpoints',10
	db	'       bl  - display info on particular breakpoint',10,0
 
aBc	db	3,'bc',0
BcHelp	db	'Breakpoint Clear',10
BcSyntax db	'Usage: bc ',10
	db	'Examples: bc 2',10
	db	'          bc 1 3 4 A',10,0
 
aBd	db	3,'bd',0
BdHelp	db	'Breakpoint Disable',10
BdSyntax db	'Usage: bd ',10
	db	'Examples: bd 2',10
	db	'          bd 1 3 4 A',10,0
 
aBe	db	3,'be',0
BeHelp	db	'Breakpoint Enable',10
BeSyntax db	'Usage: be ',10
	db	'Examples: be 2',10
	db	'          be 1 3 4 A',10,0
 
aUnpack	db	7,'unpack',0
UnpackHelp db	'Try to bypass unpacker code',10
UnpackSyntax db	'Usage: unpack',10,0
 
aLoadSymbols db	13,'load-symbols',0
LoadSymbolsHelp db 'Load symbolic information for executable',10
LoadSymbolsSyntax db 'Usage: load-symbols ',10,0
 
aUnknownCommand db 'Unknown command',10,0
 
load_err_msg	db	'Cannot load program. ',0
unk_err_msg	db	'Unknown error code -%4X',10,0
aCannotLoadFile	db	'Cannot load file. ',0
unk_err_msg2	db	'Unknown error code %4X.',10,0
load_err_msgs:
	dd	.1, 0, .3, 0, .5, .6, 0, 0, .9, .A, 0, 0, 0, 0, 0, 0
	dd	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, .1E, .1F, .20
.1		db	'HD undefined.',10,0
.3		db	'Unknown FS.',10,0
.5		db	'File not found.',10,0
.6		db	'Unexpected EOF.',10,0
.9		db	'FAT table corrupted.',10,0
.A		db	'Access denied.',10,0
.1E		db	'No memory.',10,0
.1F		db	'Not Menuet/Kolibri executable.',10,0
.20		db	'Too many processes.',10,0
load_succ_msg	db	'Program loaded successfully! PID=%4X. Use "g" to run.',10,0
need_debuggee	db	'No program loaded. Use "load" command.',10,0
aAlreadyLoaded	db	'Program is already loaded. Use "terminate" or "detach" commands',10,0
terminated_msg	db	'Program terminated.',10,0
aException	db	'Debugged program caused an exception %2X. '
aSuspended	db	'Suspended',10,0
aContinued	db	'Continuing',10,0
aRunningErr	db	'Program is running',10,0
read_mem_err	db	'ERROR: cannot read process memory!!!',10,0
aBreakpointLimitExceeded db 'Breakpoint limit exceeded',10,0
aBreakErr	db	'Cannot activate breakpoint, it will be disabled',10,0
aDuplicateBreakpoint db	'Duplicate breakpoint',10,0
aInvalidBreak	db	'Invalid breakpoint number',10,0
OnBeErrMsg	db	'There is already enabled breakpoint on this address',10,0
aBreakNum	db	'%2X: at %8X',0
aMemBreak1	db	'%2X: on ',0
aMemBreak2	db	'read from ',0
aMemBreak3	db	'access of ',0
aMemBreak4	db	'byte',0
aMemBreak5	db	'word',0
aMemBreak6	db	'dword',0
aMemBreak7	db	' at %8X',0
aOneShot	db	', one-shot',0
aDisabled	db	', disabled',0
aBreakStop	db	'Breakpoint #%2X',10,0
aUserBreak	db	'int3 command at %8X',10,0
;dbgmsg_str	db	'Debug message for process %4X.',10,0
aInvAddr	db	'Invalid address',10,0
NoPrgLoaded_str	db	'No program loaded'
NoPrgLoaded_len = $ - NoPrgLoaded_str
aRunning	db	'Running'
aPaused		db	'Paused'
aPoint		db	0x1C
aMinus		db	'-'
aColon		db	':'
aSpace		db	' '
aQuests		db	'??'
aDots		db	'...'
aParseError	db	'Parse error',10,0
aDivByZero	db	'Division by 0',10,0
calc_string	db	'%8X',10,0
aNoMemory	db	'No memory',10,0
aSymbolsLoaded	db	'Symbols loaded',10,0
aUnaligned	db	'Unaligned address',10,0
aEnabledBreakErr db	'Enabled breakpoints are not allowed',10,0
aInterrupted	db	'Interrupted',10,0
aUnpacked	db	'Unpacked successful!',10,0
aPacked1	db	'Program is probably packed with ',0
aPacked2	db	'.',10,'Try to unpack automatically? [y/n]: ',0
aY_str		db	'y',10,0
aN_str		db	'n',10,0
mxp_nrv_name	db	'mxp_nrv',0
mxp_name	db	'mxp',0
mxp_lzo_name	db	'mxp_lzo',0
mtappack_name	db	'mtappack',0
flags		db	'CPAZSDO'
flags_bits	db	0,2,4,6,7,10,11
regs_strs:
	db	'EAX='
	db	'EBX='
	db	'ECX='
	db	'EDX='
	db	'ESI='
	db	'EDI='
	db	'EBP='
	db	'ESP='
	db	'EIP='
	db	'EFLAGS='
 
debuggee_pid	dd	0
bSuspended	db	0
bAfterGo	db	0
temp_break	dd	0
 
disasm_table_1:
	dd	cop22, cop22, cop22, cop22, cop21, cop21, cop0,  cop0		; 0x
	dd	cop22, cop22, cop22, cop22, cop21, cop21, cop0,  cF
	dd	cop22, cop22, cop22, cop22, cop21, cop21, cop0,  cop0		; 1x
	dd	cop22, cop22, cop22, cop22, cop21, cop21, cop0,  cop0
	dd	cop22, cop22, cop22, cop22, cop21, cop21, cseges,cop0		; 2x
	dd	cop22, cop22, cop22, cop22, cop21, cop21, csegcs,cop0
	dd	cop22, cop22, cop22, cop22, cop21, cop21, csegss,cop0		; 3x
	dd	cop22, cop22, cop22, cop22, cop21, cop21, csegds,cop0
	dd	cinc1, cinc1, cinc1, cinc1, cinc1, cinc1, cinc1, cinc1		; 4x
	dd	cdec1, cdec1, cdec1, cdec1, cdec1, cdec1, cdec1, cdec1
	dd	cpush1,cpush1,cpush1,cpush1,cpush1,cpush1,cpush1,cpush1		; 5x
	dd	cpop1, cpop1, cpop1, cpop1, cpop1, cpop1, cpop1, cpop1
	dd	cop0,  cop0,  cbound,carpl, csegfs,cseggs,c66,   c67		; 6x
	dd	cpush21,cimul1,cpush22,cimul1,cunk,cunk,  cunk,  cunk
	dd	cjcc1, cjcc1, cjcc1, cjcc1, cjcc1, cjcc1, cjcc1, cjcc1		; 7x
	dd	cjcc1, cjcc1, cjcc1, cjcc1, cjcc1, cjcc1, cjcc1, cjcc1
	dd	cop23, cop23, cop23, cop23, cop22, cop22, cop22, cop22		; 8x
	dd	cop22, cop22, cop22, cop22, cunk,  cop22, cunk,  cpop2
	dd	cop0,  cxchg1,cxchg1,cxchg1,cxchg1,cxchg1,cxchg1,cxchg1		; 9x
	dd	ccbw,  ccwd,  ccallf,cop0,  cop0,  cop0,  cop0,  cop0
	dd	cmov3, cmov3, cmov3, cmov3, cop0,  cop0,  cop0,  cop0		; Ax
	dd	cop21, cop21, cop0,  cop0,  cop0,  cop0,  cop0,  cop0
	dd	cmov11,cmov11,cmov11,cmov11,cmov11,cmov11,cmov11,cmov11		; Bx
	dd	cmov12,cmov12,cmov12,cmov12,cmov12,cmov12,cmov12,cmov12
	dd	cshift1,cshift1,cret2,cop0, cunk,  cunk,  cmov2, cmov2		; Cx
	dd	center,cop0,  cunk,  cunk,  cop0,  cint,  cunk,  cunk
	dd	cshift2,cshift2,cshift3,cshift3,caam,caad,cunk,  cxlat		; Dx
	dd	cD8,   cD9,   cDA,   cDB,   cDC,   cDD,   cDE,   cDF
	dd	cloopnz,cloopz,cloop,cjcxz, cunk,  cunk,  cunk,  cunk		; Ex
	dd	ccall1,cjmp1, cunk,  cjmp2, cunk,  cunk,  cunk,  cunk
	dd	clock, cunk,  crepnz,crep,  cunk,  cop0,  cop1,  cop1		; Fx
	dd	cop0,  cop0,  cop0,  cop0,  cop0,  cop0,  cop1,  cop1
 
disasm_table_2:
	dd	cunk,  cunk,  cunk,  cunk,  cunk,  cop0_F,cop0_F,cunk		; 0x
	dd	cunk,  cunk,  cunk,  cunk,  cunk,  cunk,  cunk,  cunk
	dd	cunk,  cunk,  cunk,  cunk,  cunk,  cunk,  cunk,  cunk		; 1x
	dd	cunk,  cunk,  cunk,  cunk,  cunk,  cunk,  cunk,  cunk
	dd	cunk,  cunk,  cunk,  cunk,  cunk,  cunk,  cunk,  cunk		; 2x
	dd	cunk,  cunk,  cunk,  cunk,  cunk,  cunk,  cunk,  csse1
	dd	cunk,  crdtsc,cunk,  cunk,  cop0_F,cunk,  cunk,  cunk		; 3x
	dd	cunk,  cunk,  cunk,  cunk,  cunk,  cunk,  cunk,  cunk
	dd	cmovcc,cmovcc,cmovcc,cmovcc,cmovcc,cmovcc,cmovcc,cmovcc		; 4x
	dd	cmovcc,cmovcc,cmovcc,cmovcc,cmovcc,cmovcc,cmovcc,cmovcc
	dd	cunk,  cunk,  cunk,  cunk,  csse1, csse1, cunk,  cunk		; 5x
	dd	csse1, cunk,  cunk,  cunk,  cunk,  cunk,  cunk,  cunk
	dd	cpcmn, cpcmn, cpcmn, cpcmn, cpcmn, cpcmn, cpcmn, cpcmn		; 6x
	dd	cpcmn, cpcmn, cpcmn, cpcmn, cunk,  cunk,  cmovd1,cmovq1
	dd	cunk,  cpshift,cpshift,cpshift,cpcmn,cpcmn,cpcmn,cemms		; 7x
	dd	cunk,  cunk,  cunk,  cunk,  cunk,  cunk,  cmovd2,cmovq2
	dd	cjcc2, cjcc2, cjcc2, cjcc2, cjcc2, cjcc2, cjcc2, cjcc2		; 8x
	dd	cjcc2, cjcc2, cjcc2, cjcc2, cjcc2, cjcc2, cjcc2, cjcc2
	dd	csetcc,csetcc,csetcc,csetcc,csetcc,csetcc,csetcc,csetcc		; 9x
	dd	csetcc,csetcc,csetcc,csetcc,csetcc,csetcc,csetcc,csetcc
	dd	cunk,  cunk,  ccpuid,cbtx2, cshld, cshld, cunk,  cunk		; Ax
	dd	cunk,  cunk,  cunk,  cbtx2, cshrd, cshrd, cgrp15,cop22
	dd	ccmpxchg,ccmpxchg,cunk,cbtx2,cunk, cunk,  cmovzx,cmovzx		; Bx
	dd	cunk,  cunk,  cbtx1, cbtx2, cbsf,  cbsr,  cmovsx,cmovsx
	dd	cunk,  cunk,  csse1, cunk,  cunk,  cunk,  cunk,  ccmpxchg8b	; Cx
	dd	cbswap,cbswap,cbswap,cbswap,cbswap,cbswap,cbswap,cbswap
	dd	csse2, cpsrlw,cpsrlw,cpsrlq,cpcmn, cpcmn, cunk,  cunk		; Dx
	dd	cpcmn, cpcmn, cpcmn, cpcmn, cpcmn, cpcmn, cpcmn, cpcmn
	dd	cpcmn, cpsraw,cpsrad,cpcmn, cpcmn, cpcmn, cunk,  cunk		; Ex
	dd	cpcmn, cpcmn, cpcmn, cpcmn, cpcmn, cpcmn, cpcmn, cpcmn
	dd	cunk,  cpsllw,cpslld,cpsllq,cpcmn, cpcmn, cpcmn, cunk		; Fx
	dd	cpcmn, cpcmn, cpcmn, cpcmn, cpcmn, cpcmn, cpcmn, cunk
 
reg_table:
	db	2,'al',0
	db	2,'cl',1
	db	2,'dl',2
	db	2,'bl',3
	db	2,'ah',4
	db	2,'ch',5
	db	2,'dh',6
	db	2,'bh',7
	db	2,'ax',8
	db	2,'cx',9
	db	2,'dx',10
	db	2,'bx',11
	db	2,'sp',12
	db	2,'bp',13
	db	2,'si',14
	db	2,'di',15
	db	3,'eax',16
	db	3,'ecx',17
	db	3,'edx',18
	db	3,'ebx',19
	db	3,'esp',20
	db	3,'ebp',21
	db	3,'esi',22
	db	3,'edi',23
	db	3,'eip',24
	db	0
 
IncludeIGlobals
 
fn70_read_block:
	dd	0
	dq	0
	dd	?
	dd	?
	db	0
	dd	?
 
fn70_attr_block:
	dd	5
	dd	0,0,0
	dd	fileattr
	db	0
	dd	?
 
fn70_load_block:
	dd	7
	dd	1
load_params dd	0
	dd	0
	dd	0
i_end:
loadname:
	db	0
	rb	255
 
symbolsfile	rb	260
 
prgname_ptr dd ?
prgname_len dd ?
 
IncludeUGlobals
 
dbgwnd		dd	?
 
messages	rb	messages_height*messages_width
messages_pos	dd	?
 
cmdline		rb	cmdline_width+1
cmdline_len	dd	?
cmdline_pos	dd	?
curarg		dd	?
 
was_temp_break	db	?
 
dbgbufsize	dd	?
dbgbuflen	dd	?
dbgbuf		rb	256
 
fileattr	rb	40
 
needzerostart:
 
context:
_eip	dd	?
_eflags	dd	?
_eax	dd	?
_ecx	dd	?
_edx	dd	?
_ebx	dd	?
_esp	dd	?
_ebp	dd	?
_esi	dd	?
_edi	dd	?
 
oldcontext rb $-context
 
dumpread dd	?
dumppos dd	?
dumpdata rb	dump_height*10h
 
; breakpoint structure:
; dword +0: address
; byte +4: flags
; bit 0: 1 <=> breakpoint valid
; bit 1: 1 <=> breakpoint disabled
; bit 2: 1 <=> one-shot breakpoint
; bit 3: 1 <=> DRx breakpoint
; byte +5: overwritten byte
;          for DRx breaks: flags + (index shl 6)
breakpoints_n = 256
breakpoints	rb	breakpoints_n*6
drx_break	rd	4
 
disasm_buf_size		dd	?
 
symbols		dd	?
num_symbols	dd	?
 
bReload			db	?
 
needzeroend:
 
disasm_buffer		rb	256
disasm_start_pos	dd	?
disasm_cur_pos		dd	?
disasm_cur_str		dd	?
disasm_string		rb	256
 
i_param		rb	256
 
; stack
	align	400h
	rb	400h
used_mem:

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

Subversion Repositories Kolibri OS

(root)/programs/develop/mtdbg/mtdbg.asm – Rev 1265 → 1269