mirror of
https://github.com/python/cpython.git
synced 2024-12-01 11:15:56 +01:00
550 lines
14 KiB
Python
550 lines
14 KiB
Python
# Window-interface-independent part of twit
|
|
import sys
|
|
import types
|
|
import bdb
|
|
import types
|
|
import os
|
|
|
|
SIMPLE_TYPES=(
|
|
types.NoneType,
|
|
types.IntType,
|
|
types.LongType,
|
|
types.FloatType,
|
|
types.ComplexType,
|
|
types.StringType
|
|
)
|
|
|
|
# XXXX Mac-specific
|
|
ICON_NORMAL=500
|
|
ICON_RETURN=503
|
|
ICON_CALL=504
|
|
ICON_ZERO=505
|
|
ICON_DEAD=506
|
|
|
|
class DebuggerStuff(bdb.Bdb):
|
|
|
|
def __init__(self, parent):
|
|
bdb.Bdb.__init__(self)
|
|
self.parent = parent
|
|
self.exception_info = (None, None)
|
|
self.reason = 'Not running'
|
|
self.icon = ICON_NORMAL
|
|
self.reset()
|
|
|
|
def reset(self):
|
|
bdb.Bdb.reset(self)
|
|
self.forget()
|
|
|
|
def forget(self):
|
|
self.lineno = None
|
|
self.stack = []
|
|
self.curindex = 0
|
|
self.curframe = None
|
|
|
|
def run(self, cmd, locals, globals):
|
|
self.reason = 'Running'
|
|
bdb.Bdb.run(self, cmd, locals, globals)
|
|
print 'RETURN from run'
|
|
self.reason = 'Not running'
|
|
|
|
def setup(self, f, t):
|
|
self.forget()
|
|
self.stack, self.curindex = self.get_stack(f, t)
|
|
self.curframe = self.stack[self.curindex][0]
|
|
|
|
def interaction(self, frame, traceback):
|
|
self.setup(frame, traceback)
|
|
self.parent.interact()
|
|
self.exception_info = (None, None)
|
|
|
|
# def user_call(self, frame, argument_list):
|
|
# self.reason = 'Calling'
|
|
# self.icon = ICON_CALL
|
|
# self.interaction(frame, None)
|
|
|
|
def user_line(self, frame):
|
|
self.reason = 'Stopped'
|
|
self.icon = ICON_NORMAL
|
|
self.interaction(frame, None)
|
|
|
|
def user_return(self, frame, return_value):
|
|
self.reason = 'Returning'
|
|
self.icon = ICON_RETURN
|
|
self.interaction(frame, None)
|
|
|
|
def user_exception(self, frame, (exc_type, exc_value, exc_traceback)):
|
|
self.reason = 'Exception occurred'
|
|
self.icon = ICON_DEAD
|
|
self.parent.setstate('tb')
|
|
self.exception_info = (exc_type, exc_value)
|
|
self.interaction(frame, exc_traceback)
|
|
|
|
def getexception(self):
|
|
tp, value = self.exception_info
|
|
if tp <> None and type(tp) <> type(''):
|
|
tp = tp.__name__
|
|
if value <> None and type(value) <> type(''):
|
|
value = `value`
|
|
return tp, value
|
|
|
|
def getstacktrace(self):
|
|
names, locations = [], []
|
|
for frame, lineno in self.stack:
|
|
name = frame.f_code.co_name
|
|
if not name:
|
|
name = "<lambda>"
|
|
elif name == '?':
|
|
name = "<not a function>"
|
|
else:
|
|
name = name + '()'
|
|
names.append(name)
|
|
|
|
if lineno == -1:
|
|
lineno = getframelineno(frame)
|
|
|
|
modname = getframemodname(frame)
|
|
if not modname: modname = "<unknown>"
|
|
|
|
locations.append("%s:%d" % (modname, lineno))
|
|
return names, locations
|
|
|
|
def getframe(self, number):
|
|
if number < 0 or number >= len(self.stack):
|
|
return None
|
|
return self.stack[number][0]
|
|
|
|
def getframevars(self, number, show_complex=1, show_system=1):
|
|
frame = self.getframe(number)
|
|
if not frame:
|
|
return [], []
|
|
return getvarsfromdict(frame.f_locals, show_complex, show_system)
|
|
|
|
def getframevar(self, number, var):
|
|
frame = self.getframe(number)
|
|
return frame.f_locals[var]
|
|
|
|
def getframefilepos(self, frameno):
|
|
if frameno == None or frameno < 0 or frameno >= len(self.stack):
|
|
return None, None, None
|
|
frame, line = self.stack[frameno]
|
|
if line == -1:
|
|
line = getframelineno(frame)
|
|
modname = getframemodname(frame)
|
|
filename = frame.f_code.co_filename
|
|
return filename, modname, line
|
|
|
|
def getprogramstate(self):
|
|
return self.reason
|
|
|
|
class Application:
|
|
"""Base code for the application"""
|
|
|
|
def mi_init(self, sessiontype, arg):
|
|
self.dbg = DebuggerStuff(self)
|
|
self.run_dialog = self.new_stack_browser(self)
|
|
self.run_dialog.open()
|
|
self.module_dialog = None
|
|
self.initial_cmd = None
|
|
self.cur_string_name = None
|
|
if sessiontype == 'tb':
|
|
while arg.tb_next <> None:
|
|
arg = arg.tb_next
|
|
self.dbg.setup(arg.tb_frame, arg)
|
|
self.run_dialog.setup()
|
|
elif sessiontype == 'run':
|
|
self.initial_cmd = arg
|
|
|
|
def breaks_changed(self, filename):
|
|
self.run_dialog.breaks_changed(filename)
|
|
if self.module_dialog:
|
|
self.module_dialog.breaks_changed(filename)
|
|
|
|
def to_debugger(self):
|
|
cmd = self.initial_cmd
|
|
self.initial_cmd = None
|
|
self.setstate('run')
|
|
self.switch_to_app()
|
|
apply(self.dbg.run, cmd)
|
|
self.setstate('none')
|
|
self.switch_to_dbg()
|
|
self.run_dialog.update_views()
|
|
if self.module_dialog:
|
|
self.module_dialog.update_views()
|
|
|
|
def interact(self):
|
|
# Interact with user. First, display correct info
|
|
self.switch_to_dbg()
|
|
self.run_dialog.update_views()
|
|
if self.module_dialog:
|
|
self.module_dialog.update_views()
|
|
|
|
# Next, go into mainloop
|
|
self.one_mainloop()
|
|
|
|
# Finally (before we start the debuggee again) show state
|
|
self.switch_to_app()
|
|
self.run_dialog.show_it_running()
|
|
|
|
def quit_bdb(self):
|
|
self.dbg.set_quit()
|
|
|
|
def run(self):
|
|
cmd = self.AskString('Statement to execute:')
|
|
self.runstring(cmd)
|
|
|
|
def runfile(self, path):
|
|
dir, file = os.path.split(path)
|
|
try:
|
|
os.chdir(dir)
|
|
except os.error, arg:
|
|
self.Message("%s: %s"%(dir, arg))
|
|
return
|
|
ns = {'__name__':'__main__', '__file__':path}
|
|
cmd = "execfile('%s')"%file
|
|
self.runstring(cmd, ns, ns)
|
|
|
|
def runstring(self, cmd, globals={}, locals={}):
|
|
self.cur_string_name = '<string: "%s">'%cmd
|
|
try:
|
|
cmd = compile(cmd, self.cur_string_name, 'exec')
|
|
except SyntaxError, arg:
|
|
self.Message('Syntax error: %s'%`arg`)
|
|
return
|
|
self.initial_cmd = (cmd, globals, locals)
|
|
self.exit_mainloop()
|
|
|
|
def cont(self):
|
|
self.dbg.set_continue()
|
|
self.exit_mainloop()
|
|
|
|
def step(self, frame):
|
|
self.dbg.set_next(frame)
|
|
self.exit_mainloop()
|
|
|
|
def step_in(self):
|
|
self.dbg.set_step()
|
|
self.exit_mainloop()
|
|
|
|
def step_out(self, frame):
|
|
self.dbg.set_return(frame)
|
|
self.exit_mainloop()
|
|
|
|
def kill(self):
|
|
self.dbg.set_quit()
|
|
self.exit_mainloop()
|
|
|
|
def quit(self):
|
|
self.do_quit()
|
|
|
|
def browse(self, module):
|
|
if not self.module_dialog:
|
|
self.module_dialog = self.new_module_browser(self)
|
|
self.module_dialog.open(module)
|
|
else:
|
|
self.module_dialog.focus(module)
|
|
|
|
def browse_var(self, var):
|
|
b = self.new_var_browser(self, var)
|
|
|
|
class StackBrowser:
|
|
"""Base code for stack browser"""
|
|
def mi_open(self):
|
|
"""Setup initial data structures"""
|
|
self.cur_stackitem = None
|
|
self.cur_source = None
|
|
self.cur_modname = None
|
|
self.cur_line = None
|
|
self.show_complex = 1
|
|
self.show_system = 0
|
|
self.setup()
|
|
|
|
# create_items(self) should create self.modules, self.vars and self.source
|
|
|
|
def setup(self):
|
|
self.parent.SetWatch()
|
|
"""Fill the various widgets with values"""
|
|
name, value = self.parent.dbg.getexception()
|
|
self.setexception(name, value)
|
|
self.setprogramstate(self.parent.dbg.getprogramstate())
|
|
|
|
names, locations = self.parent.dbg.getstacktrace()
|
|
self.stack_setcontent(names, locations)
|
|
self.cur_stackitem = len(names)-1
|
|
self.stack_select(self.cur_stackitem)
|
|
self.setup_frame()
|
|
|
|
def setup_frame(self):
|
|
"""Setup frame-dependent widget data"""
|
|
self.parent.SetWatch()
|
|
self.cont_varnames, self.cont_varvalues = \
|
|
self.parent.dbg.getframevars(self.cur_stackitem,
|
|
self.show_complex, self.show_system)
|
|
self.setvars()
|
|
self.set_var_buttons()
|
|
|
|
msg = ""
|
|
if self.cur_stackitem == None:
|
|
self.cur_source = None
|
|
self.cur_modname = None
|
|
self.cur_line = None
|
|
msg = "No stackframe selected"
|
|
else:
|
|
self.cur_source, self.cur_modname, optnextline = \
|
|
self.parent.dbg.getframefilepos(self.cur_stackitem)
|
|
if optnextline >= 0:
|
|
self.cur_line = optnextline
|
|
if self.cur_source == '<string>':
|
|
self.cur_source = None
|
|
msg = "Executing from unknown <string>"
|
|
elif type(self.cur_source) == types.StringType and \
|
|
self.cur_source[:8] == '<string:':
|
|
msg = "Executing from "+self.cur_source
|
|
self.cur_source = None
|
|
|
|
self.setsource(msg)
|
|
if not self.cur_line:
|
|
self.source_setline(1, ICON_ZERO)
|
|
else:
|
|
self.source_setline(self.cur_line, self.parent.dbg.icon)
|
|
self.breaks_changed(self.cur_source)
|
|
|
|
|
|
self.parent.SetCursor()
|
|
|
|
# setsource(msg) should display cur_source+content, or msg if None
|
|
|
|
def show_it_running(self):
|
|
self.setprogramstate("Running")
|
|
|
|
def update_views(self):
|
|
self.setup()
|
|
|
|
def click_stack(self, number, *dummy):
|
|
if number == self.cur_stackitem: return
|
|
self.cur_stackitem = number
|
|
self.stack_select(self.cur_stackitem)
|
|
self.setup_frame()
|
|
|
|
def click_var(self, var, *dummy):
|
|
v = self.parent.dbg.getframevar(self.cur_stackitem, var)
|
|
self.parent.browse_var(v)
|
|
|
|
def click_source(self, lineno, inborder):
|
|
if not inborder:
|
|
self.source_select(lineno)
|
|
self.cur_line = lineno
|
|
if lineno == None or not self.cur_source or not inborder:
|
|
return
|
|
if self.parent.dbg.get_break(self.cur_source, lineno):
|
|
self.parent.dbg.clear_break(self.cur_source, lineno)
|
|
else:
|
|
self.parent.dbg.set_break(self.cur_source, lineno)
|
|
self.parent.breaks_changed(self.cur_source)
|
|
|
|
def breaks_changed(self, filename):
|
|
if filename == self.cur_source:
|
|
list = self.parent.dbg.get_file_breaks(filename)
|
|
self.source_setbreaks(list)
|
|
|
|
def click_quit(self):
|
|
self.parent.quit()
|
|
|
|
def click_run(self):
|
|
self.parent.run()
|
|
|
|
def click_continue(self):
|
|
self.parent.cont()
|
|
|
|
def click_step(self):
|
|
if self.cur_stackitem <> None:
|
|
frame = self.parent.dbg.getframe(self.cur_stackitem)
|
|
self.parent.step(frame)
|
|
else:
|
|
self.parent.step_in()
|
|
|
|
def click_step_in(self):
|
|
self.parent.step_in()
|
|
|
|
def click_step_out(self):
|
|
if self.cur_stackitem <> None:
|
|
frame = self.parent.dbg.getframe(self.cur_stackitem)
|
|
self.parent.step_out(frame)
|
|
else:
|
|
self.parent.step_in()
|
|
|
|
def click_kill(self):
|
|
self.parent.kill()
|
|
|
|
def click_browse(self):
|
|
self.parent.browse(self.cur_modname)
|
|
|
|
def click_edit(self):
|
|
lino = self.cur_line
|
|
if not lino:
|
|
lino = 1
|
|
if self.cur_source:
|
|
self.parent.edit(self.cur_source, lino)
|
|
|
|
class ModuleBrowser:
|
|
"""Base code for a module-browser"""
|
|
|
|
def mi_open(self, module):
|
|
"""Setup initial data structures"""
|
|
self.cur_module = module
|
|
self.cur_source = None
|
|
self.cur_line = None
|
|
self.cont_modules = []
|
|
self.value_windows = []
|
|
self.setup()
|
|
|
|
# create_items(self) should create self.modules, self.vars and self.source
|
|
|
|
def setup(self):
|
|
"""Fill the various widgets with values"""
|
|
self.parent.SetWatch()
|
|
modnames = getmodulenames()
|
|
if not self.cur_module in modnames:
|
|
self.cur_module = None
|
|
if modnames <> self.cont_modules:
|
|
self.cont_modules = modnames
|
|
self.setmodulenames()
|
|
if self.cur_module:
|
|
self.module_select(self.cont_modules.index(self.cur_module))
|
|
else:
|
|
self.module_select(None)
|
|
self.setup_module()
|
|
|
|
def setup_module(self):
|
|
"""Setup module-dependent widget data"""
|
|
self.parent.SetWatch()
|
|
if not self.cur_module:
|
|
self.cont_varnames = []
|
|
self.cont_varvalues = []
|
|
else:
|
|
self.cont_varnames, self.cont_varvalues = getmodulevars(self.cur_module)
|
|
self.setvars()
|
|
|
|
msg = ""
|
|
if not self.cur_module:
|
|
self.cur_source = None
|
|
msg = "No module selected"
|
|
else:
|
|
m = sys.modules[self.cur_module]
|
|
try:
|
|
self.cur_source = m.__file__
|
|
except AttributeError:
|
|
self.cur_source = None
|
|
msg = "Not a python module"
|
|
self.cur_lineno = 0
|
|
self.setsource(msg)
|
|
self.source_select(self.cur_line)
|
|
self.breaks_changed(self.cur_source)
|
|
|
|
self.parent.SetCursor()
|
|
|
|
# setsource(msg) should display cur_source+content, or msg if None
|
|
|
|
def update_views(self):
|
|
self.setup_module()
|
|
|
|
def click_module(self, module, *dummy):
|
|
if not module or module == self.cur_module: return
|
|
self.focus(module)
|
|
|
|
def focus(self, module):
|
|
self.cur_module = module
|
|
self.setup()
|
|
|
|
def click_var(self, var, *dummy):
|
|
if not var: return
|
|
m = sys.modules[self.cur_module]
|
|
dict = m.__dict__
|
|
self.parent.browse_var(dict[var])
|
|
|
|
def click_source(self, lineno, inborder):
|
|
if not inborder:
|
|
self.source_select(lineno)
|
|
self.cur_lineno = lineno
|
|
if lineno == None or not self.cur_source or not inborder:
|
|
return
|
|
if self.parent.dbg.get_break(self.cur_source, lineno):
|
|
self.parent.dbg.clear_break(self.cur_source, lineno)
|
|
else:
|
|
self.parent.dbg.set_break(self.cur_source, lineno)
|
|
self.parent.breaks_changed(self.cur_source)
|
|
|
|
def breaks_changed(self, filename):
|
|
if filename == self.cur_source:
|
|
list = self.parent.dbg.get_file_breaks(filename)
|
|
self.source_setbreaks(list)
|
|
|
|
def click_edit(self):
|
|
lino = self.cur_lineno
|
|
if not lino:
|
|
lino = 1
|
|
if self.cur_source:
|
|
self.parent.edit(self.cur_source, lino)
|
|
|
|
|
|
def getmodulenames():
|
|
"""Return a list of all current modules, sorted"""
|
|
list = sys.modules.keys()[:]
|
|
list.sort()
|
|
return list
|
|
|
|
def getmodulevars(name):
|
|
"""For given module return lists with names and values"""
|
|
m = sys.modules[name]
|
|
try:
|
|
dict = m.__dict__
|
|
except AttributeError:
|
|
dict = {}
|
|
return getvarsfromdict(dict)
|
|
|
|
def getvarsfromdict(dict, show_complex=1, show_system=1):
|
|
allnames = dict.keys()[:]
|
|
allnames.sort()
|
|
names = []
|
|
for n in allnames:
|
|
if not show_complex:
|
|
if not type(dict[n]) in SIMPLE_TYPES:
|
|
continue
|
|
if not show_system:
|
|
if n[:2] == '__' and n[-2:] == '__':
|
|
continue
|
|
names.append(n)
|
|
values = []
|
|
for n in names:
|
|
v = pretty(dict[n])
|
|
values.append(v)
|
|
return names, values
|
|
|
|
def pretty(var):
|
|
t = type(var)
|
|
if t == types.FunctionType: return '<function>'
|
|
if t == types.ClassType: return '<class>'
|
|
return `var`
|
|
|
|
def getframelineno(frame):
|
|
"""Given a frame return the line number"""
|
|
return getcodelineno(frame.f_code)
|
|
|
|
def getfunclineno(func):
|
|
"""Given a function return the line number"""
|
|
return getcodelineno(func.func_code)
|
|
|
|
def getcodelineno(cobj):
|
|
"""Given a code object return the line number"""
|
|
code = cobj.co_code
|
|
lineno = -1
|
|
if ord(code[0]) == 127: # SET_LINENO instruction
|
|
lineno = ord(code[1]) | (ord(code[2]) << 8)
|
|
return lineno
|
|
|
|
def getframemodname(frame):
|
|
"""Given a frame return the module name"""
|
|
globals = frame.f_globals
|
|
if globals.has_key('__name__'):
|
|
return globals['__name__']
|
|
return None
|