metasm 1.0.0

data/lib/metasm/gui/dasm_opcodes.rb

@@ -0,0 +1,291 @@
+#    This file is part of Metasm, the Ruby assembly manipulation suite
+#    Copyright (C) 2006-2009 Yoann GUILLOT
+#
+#    Licence is LGPL, see LICENCE in the top-level directory
+
+module Metasm
+module Gui
+class AsmOpcodeWidget < DrawableWidget
+	attr_accessor :dasm
+	# nr of raw data bytes to display next to decoded instructions
+	attr_accessor :raw_data_length
+	
+	def initialize_widget(dasm, parent_widget)
+		@dasm = dasm
+		@parent_widget = parent_widget
+
+		@raw_data_length = 5
+
+		@line_text = {}
+		@line_address = {}
+		@view_min = @dasm.sections.keys.min rescue nil
+		@view_max = @dasm.sections.map { |s, e| s + e.length }.max rescue nil
+		@view_addr = @dasm.prog_binding['entrypoint'] || @view_min || 0
+
+		@default_color_association = { :comment => :darkblue, :label => :darkgreen, :text => :black,
+			:instruction => :black, :address => :blue, :caret => :black, :raw_data => :black,
+			:background => :white, :cursorline_bg => :paleyellow, :hl_word => :palered }
+	end
+
+	def resized(w, h)
+		w /= @font_width
+		h /= @font_height
+		@caret_x = w-1 if @caret_x >= w
+		@caret_y = h-1 if @caret_y >= h
+	end
+
+	def click(x, y)
+		@caret_x = (x-1).to_i / @font_width
+		@caret_y = y.to_i / @font_height
+		update_caret
+	end
+
+	def rightclick(x, y)
+		click(x, y)
+		@parent_widget.clone_window(@hl_word, :opcodes)
+	end
+
+	def doubleclick(x, y)
+		click(x, y)
+		@parent_widget.focus_addr(@hl_word)
+	end
+
+	def mouse_wheel(dir, x, y)
+		case dir
+		when :up; (height/@font_height/4).times { scrollup }
+		when :down; (height/@font_height/4).times { scrolldown }
+		end
+	end
+
+	def di_at(addr)
+		s = @dasm.get_section_at(addr) and s[0].ptr < s[0].length and update_di_args(@dasm.cpu.decode_instruction(s[0], addr))
+	end
+
+	def update_di_args(di)
+		if di
+			di.instruction.args.map! { |e|
+				next e if not e.kind_of? Expression
+				@dasm.get_label_at(e) || e
+			}
+		end
+		di
+	end
+
+	def scrollup
+		return if @view_min and @view_addr < @view_min
+		# keep current instrs in sync
+		16.times { |o|
+			o += 1
+			if di = di_at(@view_addr-o) and di.bin_length == o
+				@view_addr -= o
+				@line_address = {}
+				redraw
+				return
+			end
+		}
+		@view_addr -= 1
+		@line_address = {}
+		redraw
+	end
+
+	def scrolldown
+		return if @view_max and @view_addr >= @view_max
+		if di = di_at(@view_addr)
+			@view_addr += di.bin_length
+		else
+			@view_addr += 1
+		end
+		@line_address = {}
+		redraw
+	end
+
+	def paint
+		# draw caret line background
+		draw_rectangle_color(:cursorline_bg, 0, @caret_y*@font_height, width, @font_height)
+
+		want_update_caret = true if @line_address == {}
+
+		# map lineno => address shown
+		@line_address = Hash.new(-1)
+		# map lineno => raw text
+		@line_text = Hash.new('')
+
+		# current address drawing
+		curaddr = @view_addr
+		# current line text buffer
+		fullstr = ''
+		# current line number
+		line = 0
+		# current window position
+		x = 1
+		y = 0
+
+		# renders a string at current cursor position with a color
+		# must not include newline
+		render = lambda { |str, color|
+			fullstr << str
+			if @hl_word
+				stmp = str
+				pre_x = 0
+				while stmp =~ /^(.*?)(\b#{Regexp.escape @hl_word}\b)/
+					s1, s2 = $1, $2
+					pre_x += s1.length * @font_width
+					hl_x = s2.length * @font_width
+					draw_rectangle_color(:hl_word, x+pre_x, y, hl_x, @font_height)
+					pre_x += hl_x
+					stmp = stmp[s1.length+s2.length..-1]
+				end
+			end
+			draw_string_color(color, x, y, str)
+			x += str.length * @font_width
+		}
+
+		# newline: current line is fully rendered, update @line_address/@line_text etc
+		nl = lambda {
+			@line_text[line] = fullstr
+			@line_address[line] = curaddr
+			fullstr = ''
+			line += 1
+			x = 1
+			y += @font_height
+		}
+
+		invb = @dasm.prog_binding.invert
+
+		# draw text until screen is full
+		while y < height
+			if label = invb[curaddr]
+				nl[]
+				@dasm.label_alias[curaddr].to_a.each { |name|
+					render["#{name}:", :label]
+					nl[]
+				}
+			end
+			render["#{Expression[curaddr]}    ", :address]
+
+			if di = di_at(curaddr)
+				if @raw_data_length.to_i > 0
+					if s = @dasm.get_section_at(curaddr)
+						raw = s[0].read(di.bin_length)
+						raw = raw.unpack('H*').first
+					else
+						raw = ''
+					end
+					raw = raw.ljust(@raw_data_length*2)[0, @raw_data_length*2]
+					raw += (di.bin_length > @raw_data_length ? '-  ' : '   ')
+					render[raw, :raw_data]
+				end
+				render["#{di.instruction} ", :instruction]
+			else
+				if s = @dasm.get_section_at(curaddr) and s[0].ptr < s[0].length
+					render["db #{Expression[s[0].read(1).unpack('C')]} ", :instruction]
+				end
+			end
+			nl[]
+			curaddr += di ? di.bin_length : 1
+		end
+
+		if focus?
+			# draw caret
+			cx = @caret_x*@font_width+1
+			cy = @caret_y*@font_height
+			draw_line_color(:caret, cx, cy, cx, cy+@font_height-1)
+		end
+
+		update_caret if want_update_caret
+	end
+
+	def keypress(key)
+		case key
+		when :left
+			if @caret_x >= 1
+				@caret_x -= 1
+				update_caret
+			end
+		when :up
+			if @caret_y >= 1
+				@caret_y -= 1
+			else
+				scrollup
+			end
+			update_caret
+		when :right
+			if @caret_x <= @line_text.values.map { |s| s.length }.max
+				@caret_x += 1
+				update_caret
+			end
+		when :down
+			if @caret_y < @line_text.length-3
+				@caret_y += 1
+			else
+				scrolldown
+			end
+			update_caret
+		when :pgup
+			(height/@font_height/2).times { scrollup }
+		when :pgdown
+			@view_addr = @line_address.fetch(@line_address.length/2, @view_addr+15)
+			redraw
+		when :home
+			@caret_x = 0
+			update_caret
+		when :end
+			@caret_x = @line_text[@caret_y].length
+			update_caret
+		else return false
+		end
+		true
+	end
+
+	def get_cursor_pos
+		[@view_addr, @caret_x, @caret_y]
+	end
+
+	def set_cursor_pos(p)
+		@view_addr, @caret_x, @caret_y = p
+		redraw
+		update_caret
+	end
+
+	# hint that the caret moved
+	# redraws the caret, change the hilighted word, redraw if needed
+	def update_caret
+		if update_hl_word(@line_text[@caret_y], @caret_x) or @caret_y != @oldcaret_y
+			redraw 
+		elsif @oldcaret_x != @caret_x
+			invalidate_caret(@oldcaret_x, @oldcaret_y)
+			invalidate_caret(@caret_x, @caret_y)
+		end
+
+		@oldcaret_x, @oldcaret_y = @caret_x, @caret_y
+	end
+
+	# focus on addr
+	# returns true on success (address exists)
+	def focus_addr(addr)
+		return if not addr = @parent_widget.normalize(addr)
+		if l = @line_address.index(addr) and l < @line_address.keys.max - 4
+			@caret_y, @caret_x = @line_address.keys.find_all { |k| @line_address[k] == addr }.max, 0
+		elsif @dasm.get_section_at(addr)
+			@view_addr, @caret_x, @caret_y = addr, 0, 0
+			redraw
+		else
+			return
+		end
+		update_caret
+		true
+	end
+
+	# returns the address of the data under the cursor
+	def current_address
+		@line_address[@caret_y]
+	end
+
+	def gui_update
+		@view_min = @dasm.sections.keys.min rescue nil
+		@view_max = @dasm.sections.map { |s, e| s + e.length }.max rescue nil
+		redraw
+	end
+end
+end
+end

data/lib/metasm/gui/debug.rb

@@ -0,0 +1,1228 @@
+#    This file is part of Metasm, the Ruby assembly manipulation suite
+#    Copyright (C) 2006-2009 Yoann GUILLOT
+#
+#    Licence is LGPL, see LICENCE in the top-level directory
+
+require 'metasm/gui/dasm_main'
+
+module Metasm
+module Gui
+
+# TODO invalidate dbg.disassembler on selfmodifying code
+class DbgWidget < ContainerVBoxWidget
+	attr_accessor :dbg, :console, :regs, :code, :mem, :win
+	attr_accessor :watchpoint
+	attr_accessor :parent_widget, :keyboard_callback, :keyboard_callback_ctrl
+	def initialize_widget(dbg)
+		@dbg = dbg
+		@keyboard_callback = {}
+		@keyboard_callback_ctrl = {}
+		@parent_widget = nil
+
+		@regs = DbgRegWidget.new(dbg, self)
+		@mem  = DisasmWidget.new(dbg.disassembler)
+		@code = DisasmWidget.new(dbg.disassembler)	# after mem so that dasm.gui == @code
+		@console = DbgConsoleWidget.new(dbg, self)
+		@code.parent_widget = self
+		@mem.parent_widget = self
+		@dbg.disassembler.disassemble_fast(@dbg.pc)
+
+		oldcb = @code.bg_color_callback
+		@code.bg_color_callback = lambda { |a|
+			if a == @dbg.pc
+				'f88'
+				# TODO breakpoints & stuff
+			elsif oldcb; oldcb[a]
+			end
+		}
+		# TODO popup menu, set bp, goto here, show arg in memdump..
+
+		@children = [@code, @mem, @regs]
+
+		add @regs, 'expand' => false	# XXX
+		add @mem
+		add @code
+		add @console
+
+		@watchpoint = { @code => @dbg.register_pc }
+
+		pc = @dbg.resolve_expr(@watchpoint[@code])
+		graph = :graph if @dbg.disassembler.function_blocks(pc).to_a.length < 100
+		@code.focus_addr(pc, graph)
+		@mem.focus_addr(0, :hex)
+	end
+
+	def swapin_tid
+		@regs.swapin_tid
+		@dbg.disassembler.disassemble_fast(@dbg.pc)
+		@children.each { |c|
+			if wp = @watchpoint[c]
+				c.focus_addr @dbg.resolve_expr(wp), nil, true
+			end
+		}
+		redraw
+	end
+
+	def swapin_pid
+		@mem.dasm = @dbg.disassembler
+		@code.dasm = @dbg.disassembler
+		swapin_tid
+		gui_update
+	end
+
+	def keypress(key)
+		return true if @keyboard_callback[key] and @keyboard_callback[key][key]
+		case key
+		when :f5;  protect { dbg_continue }
+		when :f10; protect { dbg_stepover }
+		when :f11; protect { dbg_singlestep }
+		when :f12; protect { dbg_stepout }
+		when ?.; @console.grab_focus
+		else return @parent_widget ? @parent_widget.keypress(key) : false
+		end
+		true
+	end
+
+	def keypress_ctrl(key)
+		return true if @keyboard_callback_ctrl[key] and @keyboard_callback_ctrl[key][key]
+		case key
+		when :f5;  protect { @dbg.pass_current_exception ; dbg.continue }
+		else return @parent_widget ? @parent_widget.keypress_ctrl(key) : false
+		end
+		true
+	end
+
+	def pre_dbg_run
+		@regs.pre_dbg_run
+	end
+
+	# TODO check_target always, incl when :stopped
+	def post_dbg_run
+		want_redraw = true
+		return if @idle_checking ||= nil	# load only one bg proc
+		@idle_checking = true
+		Gui.idle_add {
+			@dbg.check_target
+			if @dbg.state == :running
+				redraw if want_redraw	# redraw once if the target is running (less flicker with singlestep)
+				want_redraw = false
+				sleep 0.01
+				next true
+			end
+			@idle_checking = false
+			@dbg.dasm_invalidate
+			@mem.gui_update
+			@dbg.disassembler.sections.clear if @dbg.state == :dead
+			@dbg.disassembler.disassemble_fast(@dbg.pc)
+			@children.each { |c|
+				if wp = @watchpoint[c]
+					c.focus_addr @dbg.resolve_expr(wp), nil, true
+				end
+			}
+			redraw
+			false
+		}
+	end
+
+	def wrap_run
+		pre_dbg_run
+		yield
+		post_dbg_run
+	end
+
+	def dbg_continue(*a) wrap_run { @dbg.continue(*a) } end
+	def dbg_singlestep(*a) wrap_run { @dbg.singlestep(*a) } end
+	def dbg_stepover(*a) wrap_run { @dbg.stepover(*a) } end
+	def dbg_stepout(*a) wrap_run { @dbg.stepout(*a) } end
+
+	def redraw
+		super
+		@console.redraw
+		@regs.gui_update
+		@children.each { |c| c.redraw }
+	end
+
+	def gui_update
+		@console.redraw
+		@children.each { |c| c.gui_update }
+	end
+
+	def prompt_attach(caption='chose target')
+		l = nil
+		i = inputbox(caption) { |name|
+			i = nil ; l.destroy if l and not l.destroyed?
+			@dbg.attach(name)
+		}
+
+		# build process list in bg (exe name resolution takes a few seconds)
+		list = [['pid', 'name']]
+		list_pr = OS.current.list_processes
+		Gui.idle_add {
+			if pr = list_pr.shift
+				list << [pr.pid, pr.path] if pr.path
+				true
+			elsif i
+				me = ::Process.pid.to_s
+				l = listwindow('running processes', list,
+					       :noshow => true,
+					       :color_callback => lambda { |le| [:grey, :palegrey] if le[0] == me }
+					      ) { |e| i.text = e[0] }
+					      l.x += l.width
+					      l.show
+					      false
+			end
+		} if not list_pr.empty?
+	end
+
+	def prompt_createprocess(caption='chose path')
+		openfile(caption) { |path|
+			path = '"' + path + '"' if @dbg.shortname == 'windbg' and path =~ /\s/
+			inputbox('target args?', :text => path) { |pa|
+				@dbg.create_process(pa)
+			}
+		}
+	end
+
+	def prompt_datawatch
+		inputbox('data watch', :text => @watchpoint[@mem].to_s) { |e|
+			case e
+			when '', 'nil', 'none', 'delete'
+				@watchpoint.delete @mem
+			else
+				@watchpoint[@mem] = @console.parse_expr(e)
+			end
+		}
+	end
+
+	def dragdropfile(f)
+		case f
+		when /\.(c|h|cpp)$/; @dbg.disassembler.parse_c_file(f)
+		when /\.map$/; @dbg.load_map(f)
+		when /\.rb$/; @dbg.load_plugin(f)
+		else messagebox("unsupported file extension #{f}")
+		end
+	end
+end
+
+
+# a widget that displays values of registers of a Debugger
+# also controls the Debugger and commands slave windows (showing listing & memory)
+class DbgRegWidget < DrawableWidget
+	attr_accessor :dbg
+
+	def initialize_widget(dbg, parent_widget)
+		@dbg = dbg
+		@parent_widget = parent_widget
+
+		@caret_x = @caret_reg = 0
+		@oldcaret_x = @oldcaret_reg = 42
+
+		@tid_stuff = {}
+		swapin_tid
+
+		@reg_pos = []	# list of x y w h vx of the reg drawing on widget, vx is x of value
+	
+		@default_color_association = { :label => :black, :data => :blue, :write_pending => :darkred,
+				       	:changed => :darkgreen, :caret => :black, :background => :white,
+					:inactive => :palegrey }
+	end
+
+	def swapin_tid
+		stf = @tid_stuff[[@dbg.pid, @dbg.tid]] ||= {}
+		return if not @dbg.cpu
+		@write_pending = stf[:write_pending] ||= {}	# addr -> newvalue (bytewise)
+		@registers = stf[:registers] ||= @dbg.register_list
+		@flags = stf[:flags] ||= @dbg.flag_list
+		@register_size = stf[:reg_sz] ||= @registers.inject(Hash.new(1)) { |h, r| h.update r => @dbg.register_size[r]/4 }
+		@reg_cache = stf[:reg_cache] ||= Hash.new(0)
+		@reg_cache_old = stf[:reg_cache_old] ||= {}
+	end
+
+	def initialize_visible
+		gui_update
+	end
+
+	def click(ex, ey)
+		if p = @reg_pos.find { |x, y, w, h, vx| x <= ex and x+w >= ex and y <= ey and y+h >= ey }
+			@caret_reg = @reg_pos.index(p)
+			@caret_x = ((ex - p[4]) / @font_width).to_i
+			rs = @register_size[@registers[@caret_reg]]
+			@caret_x = rs-1 if @caret_x > rs-1
+			@caret_x = 0 if @caret_x < 0
+			update_caret
+		end
+	end
+
+	def rightclick(x, y)
+		doubleclick(x, y)	# XXX
+	end
+
+	def doubleclick(x, y)
+		gui_update	# XXX
+	end
+
+	def paint
+		curaddr = 0
+		x = 1
+		y = 0
+
+		w_w = width
+
+		render = lambda { |str, color|
+			draw_string_color(color, x, y, str)
+			x += str.length * @font_width
+		}
+
+		@reg_pos = []
+		running = (@dbg.state != :stopped)
+		regstrlen = @registers.map { |reg| reg.to_s.length + 1 }.max
+		@registers.each { |reg|
+			strlen = regstrlen + @register_size[reg]
+			if x + strlen*@font_width >= w_w
+				x = 1
+				y += @font_height
+			end
+			@reg_pos << [x, y, (strlen+1)*@font_width, @font_height, x+regstrlen*@font_width]
+
+			render["#{reg}=".ljust(regstrlen), :label]
+			v = @write_pending[reg] || @reg_cache[reg]
+			col = running ? :inactive : @write_pending[reg] ? :write_pending : @reg_cache_old.fetch(reg, v) != v ? :changed : :data
+			render["%0#{@register_size[reg]}x " % v, col]
+			x += @font_width	# space
+		}
+
+		@flags.each { |reg|
+			if x + @font_width >= w_w	# XXX nowrap flags ?
+				x = 1
+				y += @font_height
+			end
+			@reg_pos << [x, y, @font_width, @font_height, x]
+
+			v = @write_pending[reg] || @reg_cache[reg]
+			col = running ? :inactive : @write_pending[reg] ? :write_pending : @reg_cache_old.fetch(reg, v) != v ? :changed : :data
+			v = v == 0 ? reg.to_s.downcase : reg.to_s.upcase
+			render[v, col]
+			x += @font_width	# space
+		}
+
+		if focus?
+			# draw caret
+			cx = @reg_pos[@caret_reg][4] + @caret_x*@font_width
+			cy = @reg_pos[@caret_reg][1]
+			draw_line_color(:caret, cx, cy, cx, cy+@font_height-1)
+		end
+
+		@oldcaret_x, @oldcaret_reg = @caret_x, @caret_reg
+
+		@parent_widget.resize_child(self, width, y+@font_height)
+	end
+
+	# keyboard binding
+	# basic navigation (arrows, pgup etc)
+	def keypress(key)
+		case key
+		when :left
+			if @caret_x > 0
+				@caret_x -= 1
+				update_caret
+			end
+		when :right
+			if @caret_x < @register_size[@registers[@caret_reg]]-1
+				@caret_x += 1
+				update_caret
+			end
+		when :up
+			if @caret_reg > 0
+				@caret_reg -= 1
+			else
+				@caret_reg = @registers.length+@flags.length-1
+			end
+			@caret_x = 0
+			update_caret
+		when :down
+			if @caret_reg < @registers.length+@flags.length-1
+				@caret_reg += 1
+			else
+				@caret_reg = 0
+			end
+			@caret_x = 0
+			update_caret
+		when :home
+			@caret_x = 0
+			update_caret
+		when :end
+			@caret_x = @register_size[@registers[@caret_reg]]-1
+			update_caret
+		when :tab
+			if @caret_reg < @registers.length+@flags.length-1
+				@caret_reg += 1
+			else
+				@caret_reg = 0
+			end
+			@caret_x = 0
+			update_caret
+		when :backspace
+			# TODO
+		when :enter
+			commit_writes
+			redraw
+		when :esc
+			@write_pending.clear
+			redraw
+
+		when ?\x20..?\x7e
+			if ?a.kind_of?(String)
+				v = key.ord
+				case key
+				when ?\x20; v = nil	# keep current value
+				when ?0..?9; v -= ?0.ord
+				when ?a..?f; v -= ?a.ord-10
+				when ?A..?F; v -= ?A.ord-10
+				else return false
+				end
+			else
+				case v = key
+				when ?\x20; v = nil
+				when ?0..?9; v -= ?0
+				when ?a..?f; v -= ?a-10
+				when ?A..?F; v -= ?A-10
+				else return false
+				end
+			end
+
+			reg = @registers[@caret_reg] || @flags[@caret_reg-@registers.length]
+			rsz = @register_size[reg]
+			if v and rsz != 1
+				oo = 4*(rsz-@caret_x-1)
+				ov = @write_pending[reg] || @reg_cache[reg]
+				ov &= ~(0xf << oo)
+				ov |= v << oo
+				@write_pending[reg] = ov
+			elsif v and (v == 0 or v == 1)	# TODO change z flag by typing 'z' or 'Z'
+				@write_pending[reg] = v
+				rsz = 1
+			end
+			
+			if rsz == 1
+				@caret_reg += 1
+				@caret_reg = @registers.length if @caret_reg >= @registers.length + @flags.length
+			elsif @caret_x < rsz-1
+				@caret_x += 1
+			else
+				@caret_x = 0
+			end
+			redraw
+		else return false
+		end
+		true
+	end
+
+	def pre_dbg_run
+		@reg_cache_old.replace @reg_cache if @reg_cache
+	end
+
+	def commit_writes
+		@write_pending.each { |k, v|
+			if @registers.index(k)
+				@dbg.set_reg_value(k, v)
+			else
+				@dbg.set_flag_value(k, v)
+			end
+			@reg_cache[k] = v
+		}
+		@write_pending.clear
+	end
+
+	def gui_update
+		@reg_cache.replace @registers.inject({}) { |h, r| h.update r => @dbg.get_reg_value(r) }
+		@flags.each { |f| @reg_cache[f] = @dbg.get_flag_value(f) }
+		redraw
+	end
+
+	# hint that the caret moved
+	def update_caret
+		return if @oldcaret_x == @caret_x and @oldcaret_reg == @caret_reg
+
+		invalidate_caret(@oldcaret_x, 0, *@reg_pos[@oldcaret_reg].values_at(4, 1))
+		invalidate_caret(@caret_x, 0, *@reg_pos[@caret_reg].values_at(4, 1))
+
+		@oldcaret_x, @oldcaret_reg = @caret_x, @caret_reg
+	end
+
+end
+
+
+# a widget that displays logs of the debugger, and a cli interface to the dbg
+class DbgConsoleWidget < DrawableWidget
+	attr_accessor :dbg, :cmd_history, :log, :statusline, :commands, :cmd_help
+
+	def initialize_widget(dbg, parent_widget)
+		@dbg = dbg
+		@parent_widget = parent_widget
+		@dbg.gui = self
+
+		@log = []
+		@log_length = 4000
+		@log_offset = 0
+		@curline = ''
+		@statusline = 'type \'help\' for help'
+		@cmd_history = ['']
+		@cmd_history_length = 200	# number of past commands to remember
+		@cmd_histptr = nil
+
+		@dbg.set_log_proc { |l| add_log l }
+
+		@default_color_association = { :log => :palegrey, :curline => :white, :caret => :yellow,
+			:background => :black, :status => :black, :status_bg => '088' }
+
+		init_commands
+	end
+
+	def initialize_visible
+		grab_focus
+		gui_update
+	end
+
+	def swapin_tid
+		@parent_widget.swapin_tid
+	end
+
+	def swapin_pid
+		@parent_widget.swapin_pid
+	end
+
+	def click(x, y)
+		@caret_x = (x-1).to_i / @font_width - 1
+		@caret_x = [[@caret_x, 0].max, @curline.length].min
+		update_caret
+	end
+
+	def doubleclick(x, y)
+		# TODO real copy/paste
+		# for now, copy the line under the dblclick
+		y -= height % @font_height
+		y = y.to_i / @font_height
+		hc = height / @font_height
+		if y == hc - 1
+			txt = @statusline
+		elsif y == hc - 2
+			txt = @curline
+		else
+			txt = @log.reverse[@log_offset + hc - y - 3].to_s
+		end
+		clipboard_copy(txt)
+	end
+
+	def mouse_wheel(dir, x, y)
+		case dir
+		when :up; @log_offset += 3
+		when :down; @log_offset -= 3
+		end
+		redraw
+	end
+
+	def paint
+		y = height
+
+		render = lambda { |str, color|
+			draw_string_color(color, 1, y, str)
+			y -= @font_height
+		}
+
+		w_w = width
+
+	       	y -= @font_height
+		draw_rectangle_color(:status_bg, 0, y, w_w, @font_height)
+		str = "#{@dbg.pid}:#{@dbg.tid} #{@dbg.state} #{@dbg.info}"
+		draw_string_color(:status, w_w-str.length*@font_width-1, y, str)
+		draw_string_color(:status, 1+@font_width, y, @statusline)
+	       	y -= @font_height
+
+		w_w_c = w_w/@font_width
+		@caret_y = y
+		if @caret_x < w_w_c-1
+			render[':' + @curline, :curline]
+		else
+			render['~' + @curline[@caret_x-w_w_c+2, w_w_c], :curline]
+		end
+
+		l_nr = -1
+		lastline = nil
+		@log_offset = 0 if @log_offset < 0
+		@log.reverse.each { |l|
+			l.scan(/.{1,#{w_w/@font_width}}/).reverse_each { |l_|
+				lastline = l_
+				l_nr += 1
+				next if l_nr < @log_offset
+				render[l_, :log]
+			}
+			break if y < 0
+		}
+		if lastline and l_nr < @log_offset
+			render[lastline, :log]
+			@log_offset = l_nr-1
+		end
+
+		if focus?
+			cx = [@caret_x+1, w_w_c-1].min*@font_width+1
+			cy = @caret_y
+			draw_line_color(:caret, cx, cy, cx, cy+@font_height-1)
+		end
+
+		@oldcaret_x = @caret_x
+	end
+
+	def keypress(key)
+		case key
+		when :left
+			if @caret_x > 0
+				@caret_x -= 1
+				update_caret
+			end
+		when :right
+			if @caret_x < @curline.length
+				@caret_x += 1
+				update_caret
+			end
+		when :up
+			if not @cmd_histptr
+				if @curline != ''
+					@cmd_history << @curline
+					@cmd_histptr = 2
+				else
+					@cmd_histptr = 1
+				end
+			else
+				@cmd_histptr += 1
+				@cmd_histptr = 1 if @cmd_histptr > @cmd_history.length
+			end
+			@curline = @cmd_history[-@cmd_histptr].dup
+			@caret_x = @curline.length
+			update_status_cmd
+			redraw
+
+		when :down
+			if not @cmd_histptr
+				@cmd_history << @curline if @curline != ''
+				@cmd_histptr = @cmd_history.length
+			else
+				@cmd_histptr -= 1
+				@cmd_histptr = @cmd_history.length if @cmd_histptr < 1
+			end
+			@curline = @cmd_history[-@cmd_histptr].dup
+			@caret_x = @curline.length
+			update_status_cmd
+			redraw
+
+		when :home
+			@caret_x = 0
+			update_caret
+		when :end
+			@caret_x = @curline.length
+			update_caret
+
+		when :pgup
+			@log_offset += height/@font_height - 3
+			redraw
+		when :pgdown
+			@log_offset -= height/@font_height - 3
+			redraw
+
+		when :tab
+			# autocomplete
+			if @caret_x > 0 and not @curline[0, @caret_x].index(?\ ) and st = @curline[0, @caret_x] and not @commands[st]
+				keys = @commands.keys.find_all { |k| k[0, st.length] == st }
+				while st.length < keys.first.to_s.length and keys.all? { |k| k[0, st.length+1] == keys.first[0, st.length+1] }
+					st << keys.first[st.length]
+					@curline[@caret_x, 0] = st[-1, 1]
+					@caret_x += 1
+				end
+				update_status_cmd
+				redraw
+			end
+
+		when :enter
+			@cmd_histptr = nil
+			handle_command
+			update_status_cmd
+		when :esc
+		when :delete
+			if @caret_x < @curline.length
+				@curline[@caret_x, 1] = ''
+				update_status_cmd
+				redraw
+			end
+		when :backspace
+			if @caret_x > 0
+				@caret_x -= 1
+				@curline[@caret_x, 1] = ''
+				update_status_cmd
+				redraw
+			end
+
+		when :insert
+			if keyboard_state(:shift)
+				txt = clipboard_paste.to_s
+				@curline[@caret_x, 0] = txt
+				@caret_x += txt.length
+				update_status_cmd
+				redraw
+			end
+
+		when Symbol; return false	# avoid :shift cannot coerce to Int warning
+		when ?\x20..?\x7e
+			@curline[@caret_x, 0] = key.chr
+			@caret_x += 1
+			update_status_cmd
+			redraw
+
+		else return false
+		end
+		true
+	end
+
+	def keypress_ctrl(key)
+		case key
+		when ?v
+			txt = clipboard_paste.to_s
+			@curline[@caret_x, 0] = txt
+			@caret_x += txt.length
+			update_status_cmd
+			redraw
+		else return false
+		end
+		true
+	end
+
+	def update_status_cmd
+		st = @curline.split.first
+		if @commands[st]
+			@statusline = "#{st}: #{@cmd_help[st]}"
+		else
+			keys = @commands.keys.find_all { |k| k[0, st.length] == st } if st
+			if keys and not keys.empty?
+				@statusline = keys.sort.join(' ')
+			else
+				@statusline = 'type \'help\' for help'
+			end
+		end
+	end
+
+	def new_command(*cmd, &b)
+		hlp = cmd.pop if cmd.last.include? ' '
+		cmd.each { |c|
+			@cmd_help[c] = hlp || 'nodoc'
+			@commands[c] = lambda { |*a| protect { b.call(*a) } }
+		}
+	end
+
+	# arg str -> expr value, with special codeptr/dataptr = code/data.curaddr
+	def parse_expr(arg)
+		parse_expr!(arg.dup)
+	end
+
+	def parse_expr!(arg)
+		@dbg.parse_expr!(arg) { |e|
+			case e.downcase
+			when 'code_addr', 'codeptr'; @parent_widget.code.curaddr
+			when 'data_addr', 'dataptr'; @parent_widget.mem.curaddr
+			end
+		}
+	end
+
+	def solve_expr(arg)
+		return arg if arg.kind_of? Integer
+		solve_expr!(arg.dup)
+	end
+
+	def solve_expr!(arg)
+		return if not e = parse_expr!(arg)
+		@dbg.resolve_expr(e)
+	end
+
+	# update the data window, or dump data to console if len given
+	def cmd_dd(addr, dlen=nil, len=nil)
+		if addr.kind_of? String
+			s = addr.strip
+			addr = solve_expr!(s)
+			if not s.empty?
+				s = s[1..-1] if s[0] == ?,
+				len ||= solve_expr(s)
+			end
+		end
+
+		if len
+			while len > 0
+				data = @dbg.memory[addr, [len, 16].min]
+				le = (@dbg.cpu.endianness == :little)
+				data = '' if @dbg.memory.page_invalid?(addr)
+				case dlen
+				when nil; add_log "#{Expression[addr]}  #{data.unpack('C*').map { |c| '%02X' % c }.join(' ').ljust(2*16+15)}  #{data.tr("\0-\x1f\x7f-\xff", '.')}"
+				when 1;   add_log "#{Expression[addr]}  #{data.unpack('C*').map { |c| '%02X' % c }.join(' ')}"
+				when 2;   add_log "#{Expression[addr]}  #{data.unpack(le ? 'v*' : 'n*').map { |c| '%04X' % c }.join(' ')}"
+				when 4;   add_log "#{Expression[addr]}  #{data.unpack(le ? 'V*' : 'N*').map { |c| '%08X' % c }.join(' ')}"
+				when 8;   add_log "#{Expression[addr]}  #{data.unpack('Q*').map { |c| '%016X' % c }.join(' ')}"
+				end
+				addr += 16
+				len -= 16
+			end
+		else
+			@parent_widget.mem.view(:hex).data_size = dlen if dlen
+			@parent_widget.mem.focus_addr(solve_expr(addr)) if addr and addr != ''
+			@parent_widget.mem.gui_update
+		end
+	end
+
+	def init_commands
+		@commands = {}
+		@cmd_help = {}
+		p = @parent_widget
+		new_command('help') { add_log @commands.keys.sort.join(' ') } # TODO help <subject>
+		new_command('d', 'focus data window on an address') { |arg| cmd_dd(arg) }
+		new_command('db', 'dump/focus bytes in data window')  { |arg| cmd_dd(arg, 1) }
+		new_command('dw', 'dump/focus words in data window')  { |arg| cmd_dd(arg, 2) }
+		new_command('dd', 'dump/focus dwords in data window') { |arg| cmd_dd(arg, 4) }
+		new_command('dq', 'dump/focus qwords in data window') { |arg| cmd_dd(arg, 8) }
+		new_command('u', 'focus code window on an address') { |arg| p.code.focus_addr(solve_expr(arg)) }
+		new_command('.', 'focus code window on current address') { p.code.focus_addr(solve_expr(@dbg.register_pc.to_s)) }
+		new_command('wc', 'set code window height') { |arg|
+			if arg == ''
+				p.code.curview.grab_focus
+			else
+				p.resize_child(p.code, width, arg.to_i*@font_height)
+			end
+		}
+		new_command('wd', 'set data window height') { |arg|
+			if arg == ''
+				p.mem.curview.grab_focus
+			else
+				p.resize_child(p.mem, width, arg.to_i*@font_height)
+			end
+		}
+		new_command('wp', 'set console window height') { |arg|
+			if arg == ''
+				grab_focus
+			else
+				p.resize_child(self, width, arg.to_i*@font_height)
+			end
+		}
+		new_command('width', 'set window width (chars)') { |arg|
+			if a = solve_expr(arg); p.win.width = a*@font_width
+			else add_log "width #{p.win.width/@font_width}"
+			end
+		}
+		new_command('height', 'set window height (chars)') { |arg|
+			if a = solve_expr(arg); p.win.height = a*@font_height
+			else add_log "height #{p.win.height/@font_height}"
+			end
+		}
+		new_command('continue', 'run', 'let the target run until something occurs') { p.dbg_continue }
+		new_command('stepinto', 'singlestep', 'run a single instruction of the target') { p.dbg_singlestep }
+		new_command('stepover', 'run a single instruction of the target, do not enter into subfunctions') { p.dbg_stepover }
+		new_command('stepout', 'stepover until getting out of the current function') { p.dbg_stepout }
+		new_command('bpx', 'set a breakpoint') { |arg|
+			arg =~ /^(.*?)( once)?(?: if (.*?))?(?: do (.*?))?(?: if (.*?))?$/i
+			e, o, c, a = $1, $2, ($3 || $5), $4
+			o = o ? true : false
+			cd = parse_expr(c) if c
+			cb = lambda { a.split(';').each { |aaa| run_command(aaa) } } if a
+			@dbg.bpx(solve_expr(e), o, cd, &cb)
+		}
+		new_command('hwbp', 'set a hardware breakpoint') { |arg|
+			arg =~ /^(.*?)(?: if (.*?))?(?: do (.*?))?(?: if (.*?))?$/i
+			e, c, a = $1, ($2 || $4), $3
+			cd = parse_expr(c) if c
+			cb = lambda { a.split(';').each { |aaa| run_command(aaa) } } if a
+			@dbg.hwbp(solve_expr(e), :x, 1, false, cd, &cb)
+		}
+		new_command('bpm', 'set a hardware memory breakpoint: bpm r 0x4800ff 16') { |arg|
+			arg =~ /^(.*?)(?: if (.*?))?(?: do (.*?))?(?: if (.*?))?$/i
+			e, c, a = $1, ($2 || $4), $3
+			cd = parse_expr(c) if c
+			cb = lambda { a.split(';').each { |aaa| run_command(aaa) } } if a
+			raise 'bad syntax: bpm r|w|x addr [len]' unless e =~ /^([rwx]) (.*)/i
+			mode = $1.downcase.to_sym
+			e = $2
+			exp = solve_expr!(e)
+			len = solve_expr(e) if e != ''
+			len ||= 1
+			@dbg.hwbp(exp, mode, len, false, cd, &cb)
+		}
+		new_command('g', 'wait until target reaches the specified address') { |arg|
+			arg =~ /^(.*?)(?: if (.*?))?(?: do (.*?))?(?: if (.*?))?$/i
+			e, c, a = $1, ($2 || $4), $3
+			cd = parse_expr(c) if c
+			cb = lambda { a.split(';').each { |aaa| run_command(aaa) } } if a
+			@dbg.bpx(solve_expr(e), true, cd, &cb) if arg
+			p.dbg_continue
+		}
+		new_command('refresh', 'redraw', 'update', 'update the target memory/register cache') {
+			@dbg.invalidate
+			@dbg.dasm_invalidate
+			p.gui_update
+		}
+		new_command('bl', 'list breakpoints') {
+			@bl = []
+			@dbg.all_breakpoints.each { |b|
+				add_log "#{@bl.length} #{@dbg.addrname!(b.address)} #{b.type} #{b.state}#{" if #{b.condition}" if b.condition}"
+				@bl << b
+			}
+		}
+		new_command('bc', 'clear breakpoints') { |arg|
+			@bl ||= @dbg.all_breakpoints
+			if arg == '*'
+				@bl.each { |b| @dbg.del_bp(b) }
+			else
+				next if not i = solve_expr(arg)
+				if b = @bl[i]
+					@dbg.del_bp(b)
+				end
+			end
+		}
+		new_command('break', 'interrupt a running target') { |arg| @dbg.break ; p.post_dbg_run }
+		new_command('kill', 'kill the target') { |arg| @dbg.kill(arg) ; p.post_dbg_run }
+		new_command('detach', 'detach from the target') { @dbg.detach ; p.post_dbg_run }
+		new_command('r', 'read/write the content of a register') { |arg|
+			reg, val = arg.split(/\s+|\s*=\s*/, 2)
+			if reg == 'fl'
+				@dbg.toggle_flag(val.to_sym)
+			elsif not reg
+				@dbg.register_list.each { |r|
+					add_log "#{r} = #{Expression[@dbg.get_reg_value(r)]}"
+				}
+			elsif not val
+				add_log "#{reg} = #{Expression[@dbg.get_reg_value(reg.to_sym)]}"
+			else
+				@dbg.set_reg_value(reg.to_sym, solve_expr(val))
+			end
+			p.regs.gui_update
+		}
+		new_command('ma', 'memory_ascii', 'write memory (ascii) - ma <addr> foo bar') { |arg|
+			next if not addr = solve_expr!(arg)
+			data = arg.strip
+			@dbg.memory[addr, data.length] = data
+			@dbg.invalidate
+			@dbg.dasm_invalidate
+			p.gui_update
+		}
+		new_command('mx', 'memory_hex', 'write memory (hex) - mx <addr> 0011223344') { |arg|
+			next if not addr = solve_expr!(arg)
+			data = [arg.delete(' ')].pack('H*')
+			@dbg.memory[addr, data.length] = data
+			@dbg.invalidate
+			@dbg.dasm_invalidate
+			p.gui_update
+		}
+		new_command('?', 'display a value') { |arg|
+			next if not v = solve_expr(arg)
+			add_log "#{v} 0x#{v.to_s(16)} #{[v & 0xffff_ffff].pack('L').inspect} #{@dbg.addrname!(v)}"
+		}
+		new_command('exit', 'quit', 'quit the debugger interface') { p.win.destroy }
+		new_command('ruby', 'execute arbitrary ruby code') { |arg|
+			case ret = eval(arg)
+			when nil, true, false, Symbol; add_log ret.inspect
+			when String; add_log ret[0, 64].inspect
+			when Integer, Expression; add_log Expression[ret].to_s
+			else add_log "#<#{ret.class}>"
+			end
+		}
+		new_command('loadsyms', 'load symbols from a mapped module') { |arg|
+			if not arg.empty? and arg = (solve_expr(arg) rescue arg)
+				@dbg.loadsyms(arg)
+			else
+				@dbg.loadallsyms { |a|
+					@statusline = "loading symbols from #{Expression[a]}"
+					redraw
+					Gui.main_iter
+				}
+			end
+			p.gui_update
+		}
+		new_command('scansyms', 'scan target memory for loaded modules') {
+			if defined? @scan_addr and @scan_addr
+				add_log 'scanning @%08x' % @scan_addr
+				next
+			end
+			@scan_addr = 0
+			Gui.idle_add {
+				if @scan_addr <= 0xffff_f000	# cpu.size?
+					protect { @dbg.loadsyms(@scan_addr) }
+					@scan_addr += 0x1000
+					true
+				else
+					add_log 'scansyms finished'
+					@scan_addr = nil
+					p.gui_update
+					nil
+				end
+			}
+		}
+		new_command('symbol', 'display information on symbols') { |arg|
+			arg = arg.to_s.downcase
+			@dbg.symbols.map { |k, v| an = @dbg.addrname(k) ; [k, an] if an.downcase.include? arg }.compact.sort_by { |k, v| v.downcase }.each { |k, v|
+				add_log "#{Expression[k]} #{@dbg.addrname(k)}"
+			}
+		}
+		new_command('maps', 'show file mappings from parsed modules') { |arg|
+			want = arg.to_s.downcase
+			want = nil if want == ''
+			@dbg.modulemap.map { |n, (a_b, a_e)|
+				[a_b, "#{Expression[a_b]}-#{Expression[a_e]} #{n}"] if not want or n.downcase.include?(want)
+			}.compact.sort.each { |s1, s2|
+				add_log s2
+			}
+		}
+		new_command('rawmaps', 'show OS file mappings') { |arg|
+			# XXX listwindow
+			@dbg.mappings.sort.each { |a, l, *i|
+				foo = i*' '
+				next if arg.to_s != '' and foo !~ /#{arg}/i
+				add_log "%08x %06x %s" % [a, l, i*' ']
+			}
+		}
+		new_command('add_symbol', 'add a symbol name') { |arg|
+			name, val = arg.to_s.split(/\s+/, 2)
+			val = solve_expr(val)
+			if val.kind_of? Integer
+				@dbg.symbols[val] = name
+				@dbg.disassembler.set_label_at(val, name)
+				p.gui_update
+			end
+		}
+		new_command('bt', 'backtrace', 'stacktrace', 'bt [limit] - show a stack trace from current pc') { |arg|
+			arg = solve_expr(arg) if arg
+			arg = 500 if not arg.kind_of? ::Integer
+			@dbg.stacktrace(arg) { |a, s| add_log "#{Expression[a]} #{s}" }
+		}
+		new_command('dasm', 'disassemble_fast', 'disassembles from an address') { |arg|
+			addr = solve_expr(arg)
+			dasm = @dbg.disassembler
+			dasm.disassemble_fast(addr)
+			dasm.function_blocks(addr).keys.sort.each { |a|
+				next if not di = dasm.di_at(a)
+				dasm.dump_block(di.block) { |l| add_log l }
+			}
+			p.gui_update
+		}
+		new_command('save_hist', 'save the command buffer to a file') { |arg|
+			File.open(arg, 'w') { |fd| fd.puts @log }
+		}
+
+		new_command('watch', 'follow an expression in the data view (none to delete)') { |arg|
+			if not arg
+				add_log p.watchpoint[p.mem].to_s
+			elsif arg == 'nil' or arg == 'none' or arg == 'delete'
+				p.watchpoint.delete p.mem
+			else
+				p.watchpoint[p.mem] = parse_expr(arg)
+			end
+		}
+
+		new_command('list_pid', 'list pids currently debugged') { |arg|
+			add_log @dbg.list_debug_pids.sort.map { |pp| pp == @dbg.pid ? "*#{pp}" : pp }.join(' ')
+		}
+		new_command('list_tid', 'list tids currently debugged') { |arg|
+			add_log @dbg.list_debug_tids.sort.map { |tt| tt == @dbg.tid ? "*#{tt}" : tt }.join(' ')
+		}
+
+		new_command('list_processes', 'list processes available for debugging') { |arg|
+			@dbg.list_processes.each { |pp|
+				add_log "#{pp.pid} #{pp.path}"
+			}
+		}
+		new_command('list_threads', 'list thread ids of the current process') { |arg|
+			@dbg.list_threads.each { |t|
+				stf = { :state => @dbg.state, :info => @dbg.info } if t == @dbg.tid
+				stf ||= @dbg.tid_stuff[t]
+				stf ||= {}
+				add_log "#{t} #{stf[:state]} #{stf[:info]}"
+			}
+		}
+		
+		new_command('pid', 'select a pid') { |arg|
+			if pid = solve_expr(arg)
+				@dbg.pid = pid
+			else
+				add_log "pid #{@dbg.pid}"
+			end
+		}
+		new_command('tid', 'select a tid') { |arg|
+			if tid = solve_expr(arg)
+				@dbg.tid = tid
+			else
+				add_log "tid #{@dbg.tid} #{@dbg.state} #{@dbg.info}"
+			end
+		}
+
+		new_command('exception_pass', 'pass the exception unhandled to the target on next continue') {
+			@dbg.pass_current_exception
+		}
+		new_command('exception_handle', 'handle the exception, hide it from the target on next continue') {
+			@dbg.pass_current_exception false
+		}
+
+		new_command('exception_pass_all', 'ignore all target exceptions') {
+			@dbg.pass_all_exceptions = true
+		}
+		new_command('exception_handle_all', 'break on target exceptions') {
+			@dbg.pass_all_exceptions = false
+		}
+
+		new_command('thread_events_break', 'break on thread creation/termination') {
+			@dbg.ignore_newthread = false
+			@dbg.ignore_endthread = false
+		}
+		new_command('thread_event_ignore', 'ignore thread creation/termination') {
+			@dbg.ignore_newthread = true
+			@dbg.ignore_endthread = true
+		}
+
+		new_command('trace_children', 'trace children of debuggee (0|1)') { |arg|
+			arg = case arg.to_s.strip.downcase
+			when '0', 'no', 'false'; false
+			else true
+			end
+			add_log "trace children #{arg ? 'active' : 'inactive'}"
+			# update the flag for future debugee
+			@dbg.trace_children = arg
+			# change current debugee setting if supported
+			@dbg.do_trace_children if @dbg.respond_to?(:do_trace_children)
+		}
+
+		new_command('attach', 'attach to a running process') { |arg|
+			if pr = @dbg.list_processes.find { |pp| pp.path.to_s.downcase.include?(arg.downcase) }
+				pid = pr.pid
+			else
+				pid = solve_expr(arg)
+			end
+			@dbg.attach(pid)
+		}
+		new_command('create_process', 'create a new process and debug it') { |arg|
+			@dbg.create_process(arg)
+		}
+
+		@dbg.ui_command_setup(self) if @dbg.respond_to? :ui_command_setup
+	end
+
+	def wrap_run(&b) @parent_widget.wrap_run(&b) end
+	def keyboard_callback; @parent_widget.keyboard_callback end
+	def keyboard_callback_ctrl; @parent_widget.keyboard_callback_ctrl end
+
+	def handle_command
+		add_log(":#@curline")
+		return if @curline == ''
+		@cmd_history << @curline
+		@cmd_history.shift if @cmd_history.length > @cmd_history_length
+		@log_offset = 0
+		cmd = @curline
+		@curline = ''
+		@caret_x = 0
+
+		run_command(cmd)
+	end
+
+	def run_command(cmd)
+		cn = cmd.split.first
+		if not @commands[cn]
+			a = @commands.keys.find_all { |k| k[0, cn.length] == cn }
+			cn = a.first if a.length == 1
+		end
+		if pc = @commands[cn] 
+			pc[cmd.split(/\s+/, 2)[1].to_s]
+		else
+			add_log 'unknown command'
+		end
+	end
+
+	def add_log(l)
+		@log << l.to_s
+		@log.shift if log.length > @log_length
+		redraw
+	end
+
+	def gui_update
+		redraw
+	end
+
+	# hint that the caret moved
+	def update_caret
+		return if @oldcaret_x == @caret_x
+		w_w = width - @font_width
+		x1 = (@oldcaret_x+1) * @font_width + 1
+		x2 = (@caret_x+1) * @font_width + 1
+		y = @caret_y
+
+		if x1 > w_w or x2 > w_w
+			invalidate(0, y, 100000, @font_height)
+		else
+			invalidate(x1-1, y, 2, @font_height)
+			invalidate(x2-1, y, 2, @font_height)
+		end
+
+		@oldcaret_x = @caret_x
+	end
+end
+
+class DbgWindow < Window
+	attr_accessor :dbg_widget
+	def initialize_window(dbg = nil, title='metasm debugger')
+		self.title = title
+		display(dbg) if dbg
+	end
+
+	# show a new DbgWidget
+	def display(dbg)
+		@dbg_widget = DbgWidget.new(dbg)
+		@dbg_widget.win = self
+		self.widget = @dbg_widget
+		@dbg_widget
+	end
+
+	def build_menu
+		filemenu = new_menu
+		addsubmenu(filemenu, '_attach process') { @dbg_widget.prompt_attach }
+		addsubmenu(filemenu, 'create _process') { @dbg_widget.prompt_createprocess }
+		addsubmenu(filemenu, 'open _dasm window') { DasmWindow.new }
+		addsubmenu(filemenu)
+		addsubmenu(filemenu, 'QUIT') { destroy }
+
+		addsubmenu(@menu, filemenu, '_File')
+
+		dbgmenu = new_menu
+		addsubmenu(dbgmenu, 'continue', '<f5>') { @dbg_widget.dbg_continue }
+		addsubmenu(dbgmenu, 'step over', '<f10>') { @dbg_widget.dbg_stepover }
+		addsubmenu(dbgmenu, 'step into', '<f11>') { @dbg_widget.dbg_singlestep }
+		addsubmenu(dbgmenu, '_kill target') { @dbg_widget.dbg.kill }
+		addsubmenu(dbgmenu, '_detach target') { @dbg_widget.dbg.detach }
+		addsubmenu(dbgmenu)
+		addsubmenu(dbgmenu, 'QUIT') { destroy }
+
+		addsubmenu(@menu, dbgmenu, '_Debug')
+
+		codeviewmenu = new_menu
+		addsubmenu(codeviewmenu, '_listing') { @dbg_widget.code.focus_addr(@dbg_widget.code.curaddr, :listing) }
+		addsubmenu(codeviewmenu, '_graph') { @dbg_widget.code.focus_addr(@dbg_widget.code.curaddr, :graph) }
+		addsubmenu(codeviewmenu, 'raw _opcodes') { @dbg_widget.code.focus_addr(@dbg_widget.code.curaddr, :opcodes) }
+
+		dataviewmenu = new_menu
+		addsubmenu(dataviewmenu, '_hexa') { @dbg_widget.mem.focus_addr(@dbg_widget.mem.curaddr, :hex) }
+		addsubmenu(dataviewmenu, 'raw _opcodes') { @dbg_widget.mem.focus_addr(@dbg_widget.mem.curaddr, :opcodes) }
+		addsubmenu(dataviewmenu, '_c struct') { @dbg_widget.mem.focus_addr(@dbg_widget.mem.curaddr, :cstruct) }
+
+		focusmenu = new_menu
+		addsubmenu(focusmenu, '_regs') { @dbg_widget.regs.grab_focus ; @dbg_widget.redraw }
+		addsubmenu(focusmenu, '_data') { @dbg_widget.mem.grab_focus ; @dbg_widget.redraw }
+		addsubmenu(focusmenu, '_code') { @dbg_widget.code.grab_focus ; @dbg_widget.redraw }
+		addsubmenu(focusmenu, 'conso_le', '.') { @dbg_widget.console.grab_focus ; @dbg_widget.redraw }
+
+		viewmenu = new_menu
+		addsubmenu(viewmenu, codeviewmenu, '_code display')
+		addsubmenu(viewmenu, dataviewmenu, '_data display')
+		addsubmenu(viewmenu, focusmenu, '_focus')
+		addsubmenu(viewmenu, 'data _watch') { @dbg_widget.prompt_datawatch }
+		addsubmenu(@menu, viewmenu, '_Views')
+	end
+end
+
+end
+end