mirror of
https://github.com/python/cpython.git
synced 2024-11-27 23:47:29 +01:00
895 lines
25 KiB
Python
895 lines
25 KiB
Python
import sys
|
|
import bdb
|
|
import types
|
|
import os
|
|
|
|
import W
|
|
import WASTEconst
|
|
import PyBrowser
|
|
from Carbon import Qd
|
|
from Carbon import Evt
|
|
from Carbon import Lists
|
|
import MacOS
|
|
_filenames = {}
|
|
|
|
SIMPLE_TYPES = (
|
|
types.NoneType,
|
|
types.IntType,
|
|
types.LongType,
|
|
types.FloatType,
|
|
types.ComplexType,
|
|
types.StringType
|
|
)
|
|
|
|
|
|
class Debugger(bdb.Bdb):
|
|
|
|
def __init__(self, title = 'Debugger'):
|
|
bdb.Bdb.__init__(self)
|
|
self.closed = 1
|
|
self.title = title
|
|
self.breaksviewer = None
|
|
self.reset()
|
|
self.tracing = 0
|
|
self.tracingmonitortime = Evt.TickCount()
|
|
self.editors = {}
|
|
|
|
prefs = W.getapplication().getprefs()
|
|
if prefs.debugger:
|
|
for file, breaks in prefs.debugger.breaks.items():
|
|
for b in breaks:
|
|
self.set_break(file, b)
|
|
self.bounds, self.horpanes, self.verpanes = prefs.debugger.windowsettings
|
|
self.tracemagic = prefs.debugger.tracemagic
|
|
else:
|
|
self.breaks = {}
|
|
self.horpanes = (0.4, 0.6)
|
|
self.verpanes = (0.3, 0.35, 0.35)
|
|
self.bounds = (600, 400)
|
|
self.tracemagic = 0
|
|
self.laststacksel = None
|
|
|
|
def canonic(self, filename):
|
|
# override: the provided canonic() method breaks our
|
|
# file-less Untitled windows
|
|
return filename
|
|
|
|
def reset(self):
|
|
self.currentframe = None
|
|
self.file = None
|
|
self.laststack = None
|
|
self.reason = 'Not running'
|
|
self.continuewithoutdebugger = 0
|
|
bdb.Bdb.reset(self)
|
|
self.forget()
|
|
|
|
def start(self, bottomframe = None, running = 0):
|
|
W.getapplication().DebuggerQuit = bdb.BdbQuit
|
|
from Carbon import Menu
|
|
Menu.HiliteMenu(0)
|
|
if self.closed:
|
|
self.setupwidgets(self.title)
|
|
self.closed = 0
|
|
if not self.w.parent.debugger_quitting:
|
|
self.w.select()
|
|
raise W.AlertError, 'There is another debugger session busy.'
|
|
self.reset()
|
|
self.botframe = bottomframe
|
|
if running:
|
|
self.set_continue()
|
|
self.reason = 'Running\xc9'
|
|
self.setstate('running')
|
|
else:
|
|
self.set_step()
|
|
self.reason = 'stopped'
|
|
self.setstate('stopped')
|
|
sys.settrace(self.trace_dispatch)
|
|
|
|
def stop(self):
|
|
self.set_quit()
|
|
if self.w.parent:
|
|
self.exit_mainloop()
|
|
self.resetwidgets()
|
|
|
|
def set_continue_without_debugger(self):
|
|
sys.settrace(None)
|
|
self.set_quit()
|
|
self.clear_tracefuncs()
|
|
self.continuewithoutdebugger = 1
|
|
if hasattr(self, "w") and self.w.parent:
|
|
self.exit_mainloop()
|
|
self.resetwidgets()
|
|
|
|
def clear_tracefuncs(self):
|
|
try:
|
|
raise 'spam'
|
|
except:
|
|
pass
|
|
frame = sys.exc_traceback.tb_frame
|
|
while frame is not None:
|
|
del frame.f_trace
|
|
frame = frame.f_back
|
|
|
|
def postmortem(self, exc_type, exc_value, traceback):
|
|
if self.closed:
|
|
self.setupwidgets(self.title)
|
|
self.closed = 0
|
|
if not self.w.parent.debugger_quitting:
|
|
raise W.AlertError, 'There is another debugger session busy.'
|
|
self.reset()
|
|
if traceback:
|
|
self.botframe = traceback.tb_frame
|
|
while traceback.tb_next <> None:
|
|
traceback = traceback.tb_next
|
|
frame = traceback.tb_frame
|
|
else:
|
|
self.botframe = None
|
|
frame = None
|
|
self.w.panes.bottom.buttons.killbutton.enable(1)
|
|
self.reason = '(dead) ' + self.formatexception(exc_type, exc_value)
|
|
self.w.select()
|
|
self.setup(frame, traceback)
|
|
self.setstate('dead')
|
|
self.showstack(self.curindex)
|
|
self.showframe(self.curindex)
|
|
|
|
def setupwidgets(self, title):
|
|
self.w = w = W.Window(self.bounds, title, minsize = (500, 300))
|
|
|
|
w.panes = W.HorizontalPanes((8, 4, -8, -8), self.horpanes)
|
|
|
|
w.panes.browserpanes = browserpanes = W.VerticalPanes(None, self.verpanes)
|
|
|
|
browserpanes.stacklist = W.Group(None)
|
|
browserpanes.stacklist.title = W.TextBox((4, 0, 0, 12), 'Stack')
|
|
browserpanes.stacklist.stack = W.List((0, 16, 0, 0), callback = self.do_stack, flags = Lists.lOnlyOne)
|
|
|
|
browserpanes.locals = W.Group(None)
|
|
browserpanes.locals.title = W.TextBox((4, 0, 0, 12), 'Local variables')
|
|
browserpanes.locals.browser = PyBrowser.BrowserWidget((0, 16, 0, 0))
|
|
|
|
browserpanes.globals = W.Group(None)
|
|
browserpanes.globals.title = W.TextBox((4, 0, 0, 12), 'Global variables')
|
|
browserpanes.globals.browser = PyBrowser.BrowserWidget((0, 16, 0, 0))
|
|
|
|
w.panes.bottom = bottom = W.Group(None)
|
|
bottom.src = src = W.Group((0, 64, 0, 0))
|
|
source = SourceViewer((1, 1, -15, -15), readonly = 1, debugger = self)
|
|
src.optionsmenu = W.PopupMenu((-16, 0, 16, 16), [])
|
|
src.optionsmenu.bind('<click>', self.makeoptionsmenu)
|
|
|
|
src._barx = W.Scrollbar((0, -16, -15, 16), source.hscroll, max = 32767)
|
|
src._bary = W.Scrollbar((-16, 15, 16, -15), source.vscroll, max = 32767)
|
|
src.source = source
|
|
src.frame = W.Frame((0, 0, -15, -15))
|
|
|
|
bottom.tracingmonitor = TracingMonitor((0, 23, 6, 6))
|
|
bottom.state = W.TextBox((12, 24, 0, 16), self.reason)
|
|
|
|
bottom.srctitle = W.TextBox((12, 44, 0, 16))
|
|
bottom.buttons = buttons = W.Group((12, 0, 0, 20))
|
|
|
|
buttons.runbutton = W.Button((0, 0, 50, 16), "Run", self.do_run)
|
|
buttons.stopbutton = W.Button((58, 0, 50, 16), "Stop", self.do_stop)
|
|
buttons.killbutton = W.Button((116, 0, 50, 16), "Kill", self.do_kill)
|
|
buttons.line = W.VerticalLine((173, 0, 0, 0))
|
|
buttons.stepbutton = W.Button((181, 0, 60, 16), "Step", self.do_step)
|
|
buttons.stepinbutton = W.Button((249, 0, 60, 16), "Step in", self.do_stepin)
|
|
buttons.stepoutbutton = W.Button((317, 0, 60, 16), "Step out", self.do_stepout)
|
|
|
|
w.bind('cmdr', buttons.runbutton.push)
|
|
w.bind('cmd.', buttons.stopbutton.push)
|
|
w.bind('cmdk', buttons.killbutton.push)
|
|
w.bind('cmds', buttons.stepbutton.push)
|
|
w.bind('cmdt', buttons.stepinbutton.push)
|
|
w.bind('cmdu', buttons.stepoutbutton.push)
|
|
|
|
w.bind('<close>', self.close)
|
|
|
|
w.open()
|
|
w.xxx___select(w.panes.bottom.src.source)
|
|
|
|
def makeoptionsmenu(self):
|
|
options = [('Clear breakpoints', self.w.panes.bottom.src.source.clearbreakpoints),
|
|
('Clear all breakpoints', self.clear_all_breaks),
|
|
('Edit breakpoints\xc9', self.edit_breaks), '-',
|
|
(self.tracemagic and
|
|
'Disable __magic__ tracing' or 'Enable __magic__ tracing', self.togglemagic)]
|
|
self.w.panes.bottom.src.optionsmenu.set(options)
|
|
|
|
def edit_breaks(self):
|
|
if self.breaksviewer:
|
|
self.breaksviewer.select()
|
|
else:
|
|
self.breaksviewer = BreakpointsViewer(self)
|
|
|
|
def togglemagic(self):
|
|
self.tracemagic = not self.tracemagic
|
|
|
|
def setstate(self, state):
|
|
self.w.panes.bottom.tracingmonitor.reset()
|
|
self.w.panes.bottom.state.set(self.reason)
|
|
buttons = self.w.panes.bottom.buttons
|
|
if state == 'stopped':
|
|
buttons.runbutton.enable(1)
|
|
buttons.stopbutton.enable(0)
|
|
buttons.killbutton.enable(1)
|
|
buttons.stepbutton.enable(1)
|
|
buttons.stepinbutton.enable(1)
|
|
buttons.stepoutbutton.enable(1)
|
|
elif state == 'running':
|
|
buttons.runbutton.enable(0)
|
|
buttons.stopbutton.enable(1)
|
|
buttons.killbutton.enable(1)
|
|
buttons.stepbutton.enable(0)
|
|
buttons.stepinbutton.enable(0)
|
|
buttons.stepoutbutton.enable(0)
|
|
elif state == 'idle':
|
|
buttons.runbutton.enable(0)
|
|
buttons.stopbutton.enable(0)
|
|
buttons.killbutton.enable(0)
|
|
buttons.stepbutton.enable(0)
|
|
buttons.stepinbutton.enable(0)
|
|
buttons.stepoutbutton.enable(0)
|
|
elif state == 'dead':
|
|
buttons.runbutton.enable(0)
|
|
buttons.stopbutton.enable(0)
|
|
buttons.killbutton.enable(1)
|
|
buttons.stepbutton.enable(0)
|
|
buttons.stepinbutton.enable(0)
|
|
buttons.stepoutbutton.enable(0)
|
|
else:
|
|
print 'unknown state:', state
|
|
|
|
def resetwidgets(self):
|
|
self.reason = ''
|
|
self.w.panes.bottom.srctitle.set('')
|
|
self.w.panes.bottom.src.source.set('')
|
|
self.w.panes.browserpanes.stacklist.stack.set([])
|
|
self.w.panes.browserpanes.locals.browser.set({})
|
|
self.w.panes.browserpanes.globals.browser.set({})
|
|
self.setstate('idle')
|
|
|
|
# W callbacks
|
|
|
|
def close(self):
|
|
self.set_quit()
|
|
self.exit_mainloop()
|
|
self.closed = 1
|
|
|
|
self.unregister_editor(self.w.panes.bottom.src.source,
|
|
self.w.panes.bottom.src.source.file)
|
|
self.horpanes = self.w.panes.getpanesizes()
|
|
self.verpanes = self.w.panes.browserpanes.getpanesizes()
|
|
self.bounds = self.w.getbounds()
|
|
prefs = W.getapplication().getprefs()
|
|
prefs.debugger.breaks = self.breaks
|
|
prefs.debugger.windowsettings = self.bounds, self.horpanes, self.verpanes
|
|
prefs.debugger.tracemagic = self.tracemagic
|
|
prefs.save()
|
|
|
|
# stack list callback
|
|
|
|
def do_stack(self, isdbl):
|
|
sel = self.w.panes.browserpanes.stacklist.stack.getselection()
|
|
if isdbl:
|
|
if sel:
|
|
frame, lineno = self.stack[sel[0] + 1]
|
|
filename = frame.f_code.co_filename
|
|
editor = self.w._parentwindow.parent.openscript(filename, lineno)
|
|
if self.breaks.has_key(filename):
|
|
editor.showbreakpoints(1)
|
|
else:
|
|
if sel and sel <> self.laststacksel:
|
|
self.showframe(sel[0] + 1)
|
|
self.laststacksel = sel
|
|
|
|
def geteditor(self, filename):
|
|
if filename[:1] == '<' and filename[-1:] == '>':
|
|
editor = W.getapplication().getscript(filename[1:-1])
|
|
else:
|
|
editor = W.getapplication().getscript(filename)
|
|
return editor
|
|
|
|
# button callbacks
|
|
|
|
def do_run(self):
|
|
self.running()
|
|
self.set_continue()
|
|
self.exit_mainloop()
|
|
|
|
def do_stop(self):
|
|
self.set_step()
|
|
|
|
def do_kill(self):
|
|
self.set_quit()
|
|
self.exit_mainloop()
|
|
self.resetwidgets()
|
|
|
|
def do_step(self):
|
|
self.running()
|
|
self.set_next(self.curframe)
|
|
self.exit_mainloop()
|
|
|
|
def do_stepin(self):
|
|
self.running()
|
|
self.set_step()
|
|
self.exit_mainloop()
|
|
|
|
def do_stepout(self):
|
|
self.running()
|
|
self.set_return(self.curframe)
|
|
self.exit_mainloop()
|
|
|
|
def running(self):
|
|
W.SetCursor('watch')
|
|
self.reason = 'Running\xc9'
|
|
self.setstate('running')
|
|
#self.w.panes.bottom.src.source.set('')
|
|
#self.w.panes.browserpanes.stacklist.stack.set([])
|
|
#self.w.panes.browserpanes.locals.browser.set({})
|
|
#self.w.panes.browserpanes.globals.browser.set({})
|
|
|
|
def exit_mainloop(self):
|
|
self.w.parent.debugger_quitting = 1
|
|
|
|
#
|
|
|
|
def showframe(self, stackindex):
|
|
(frame, lineno) = self.stack[stackindex]
|
|
W.SetCursor('watch')
|
|
filename = frame.f_code.co_filename
|
|
if filename <> self.file:
|
|
editor = self.geteditor(filename)
|
|
if editor:
|
|
self.w.panes.bottom.src.source.set(editor.get(), filename)
|
|
else:
|
|
try:
|
|
f = open(filename, 'rU')
|
|
data = f.read()
|
|
f.close()
|
|
except IOError:
|
|
if filename[-3:] == '.py':
|
|
import imp
|
|
modname = os.path.basename(filename)[:-3]
|
|
try:
|
|
f, filename, (suff, mode, dummy) = imp.find_module(modname)
|
|
except ImportError:
|
|
self.w.panes.bottom.src.source.set("can't find file")
|
|
else:
|
|
if f:
|
|
f.close()
|
|
if f and suff == '.py':
|
|
f = open(filename, 'rU')
|
|
data = f.read()
|
|
f.close()
|
|
self.w.panes.bottom.src.source.set(data, filename)
|
|
else:
|
|
self.w.panes.bottom.src.source.set("can't find file")
|
|
else:
|
|
self.w.panes.bottom.src.source.set("can't find file")
|
|
else:
|
|
data = data.replace('\n', '\r')
|
|
self.w.panes.bottom.src.source.set(data, filename)
|
|
self.file = filename
|
|
self.w.panes.bottom.srctitle.set('Source: ' + filename + ((lineno > 0) and (' (line %d)' % lineno) or ' '))
|
|
self.goto_line(lineno)
|
|
self.lineno = lineno
|
|
self.showvars((frame, lineno))
|
|
|
|
def showvars(self, (frame, lineno)):
|
|
if frame.f_locals is not frame.f_globals:
|
|
locals = frame.f_locals
|
|
else:
|
|
locals = {'Same as Globals':''}
|
|
filteredlocals = {}
|
|
for key, value in locals.items():
|
|
# empty key is magic for Python 1.4; '.' is magic for 1.5...
|
|
if not key or key[0] <> '.':
|
|
filteredlocals[key] = value
|
|
self.w.panes.browserpanes.locals.browser.set(filteredlocals)
|
|
self.w.panes.browserpanes.globals.browser.set(frame.f_globals)
|
|
|
|
def showstack(self, stackindex):
|
|
stack = []
|
|
for frame, lineno in self.stack[1:]:
|
|
filename = frame.f_code.co_filename
|
|
try:
|
|
filename = _filenames[filename]
|
|
except KeyError:
|
|
if filename[:1] + filename[-1:] <> '<>':
|
|
filename = os.path.basename(filename)
|
|
_filenames[frame.f_code.co_filename] = filename
|
|
funcname = frame.f_code.co_name
|
|
if funcname == '?':
|
|
funcname = '<toplevel>'
|
|
stack.append(filename + ': ' + funcname)
|
|
if stack <> self.laststack:
|
|
self.w.panes.browserpanes.stacklist.stack.set(stack)
|
|
self.laststack = stack
|
|
sel = [stackindex - 1]
|
|
self.w.panes.browserpanes.stacklist.stack.setselection(sel)
|
|
self.laststacksel = sel
|
|
|
|
def goto_line(self, lineno):
|
|
if lineno > 0:
|
|
self.w.panes.bottom.src.source.selectline(lineno - 1)
|
|
else:
|
|
self.w.panes.bottom.src.source.setselection(0, 0)
|
|
|
|
# bdb entry points
|
|
|
|
# def user_call(self, frame, argument_list):
|
|
# self.reason = 'Calling'
|
|
# self.interaction(frame, None)
|
|
|
|
def user_line(self, frame):
|
|
# This function is called when we stop or break at this line
|
|
self.reason = 'Stopped'
|
|
self.interaction(frame, None)
|
|
|
|
def user_return(self, frame, return_value):
|
|
# This function is called when a return trap is set here
|
|
fname = frame.f_code.co_name
|
|
if fname <> '?':
|
|
self.reason = 'Returning from %s()' % frame.f_code.co_name
|
|
frame.f_locals['__return__'] = return_value
|
|
elif frame.f_back is self.botframe:
|
|
self.reason = 'Done'
|
|
else:
|
|
self.reason = 'Returning'
|
|
self.interaction(frame, None, 1)
|
|
|
|
def user_exception(self, frame, (exc_type, exc_value, exc_traceback)):
|
|
# This function is called when we stop or break at this line
|
|
self.reason = self.formatexception(exc_type, exc_value)
|
|
self.interaction(frame, exc_traceback)
|
|
|
|
def formatexception(self, exc_type, exc_value):
|
|
if exc_type == SyntaxError:
|
|
try:
|
|
value, (filename, lineno, charno, line) = exc_value
|
|
except:
|
|
pass
|
|
else:
|
|
return str(exc_type) + ': ' + str(value)
|
|
if type(exc_type) == types.ClassType:
|
|
nice = exc_type.__name__
|
|
else:
|
|
nice = str(exc_type)
|
|
value = str(exc_value)
|
|
if exc_value and value:
|
|
nice = nice + ": " + value
|
|
return nice
|
|
|
|
def forget(self):
|
|
self.stack = []
|
|
self.curindex = 0
|
|
self.curframe = None
|
|
|
|
def setup(self, f, t, isreturning = 0):
|
|
self.forget()
|
|
self.stack, self.curindex = self.get_stack(f, t)
|
|
self.curframe = self.stack[self.curindex - isreturning][0]
|
|
|
|
def interaction(self, frame, traceback, isreturning = 0):
|
|
saveport = Qd.GetPort()
|
|
self.w.select()
|
|
try:
|
|
self.setup(frame, traceback, isreturning)
|
|
self.setstate('stopped')
|
|
stackindex = self.curindex
|
|
if isreturning:
|
|
if frame.f_back is not self.botframe:
|
|
stackindex = stackindex - 1
|
|
self.showstack(stackindex)
|
|
self.showframe(stackindex)
|
|
self.w.parent.debugger_mainloop()
|
|
self.forget()
|
|
finally:
|
|
Qd.SetPort(saveport)
|
|
|
|
# bdb customization
|
|
|
|
def trace_dispatch(self, frame, event, arg, TickCount = Evt.TickCount):
|
|
if TickCount() - self.tracingmonitortime > 15:
|
|
self.tracingmonitortime = TickCount()
|
|
self.w.panes.bottom.tracingmonitor.toggle()
|
|
try:
|
|
try:
|
|
if hasattr(MacOS, 'EnableAppswitch'):
|
|
MacOS.EnableAppswitch(0)
|
|
if self.quitting:
|
|
# returning None is not enough, a former BdbQuit exception
|
|
# might have been eaten by the print statement
|
|
raise bdb.BdbQuit
|
|
if event == 'line':
|
|
return self.dispatch_line(frame)
|
|
if event == 'call':
|
|
return self.dispatch_call(frame, arg)
|
|
if event == 'return':
|
|
return self.dispatch_return(frame, arg)
|
|
if event == 'exception':
|
|
return self.dispatch_exception(frame, arg)
|
|
print 'bdb.Bdb.dispatch: unknown debugging event:', repr(event)
|
|
return self.trace_dispatch
|
|
finally:
|
|
if hasattr(MacOS, 'EnableAppswitch'):
|
|
MacOS.EnableAppswitch(-1)
|
|
except KeyboardInterrupt:
|
|
self.set_step()
|
|
return self.trace_dispatch
|
|
except bdb.BdbQuit:
|
|
if self.continuewithoutdebugger:
|
|
self.clear_tracefuncs()
|
|
return
|
|
else:
|
|
raise bdb.BdbQuit
|
|
except:
|
|
print 'XXX Exception during debugger interaction.', \
|
|
self.formatexception(sys.exc_type, sys.exc_value)
|
|
import traceback
|
|
traceback.print_exc()
|
|
return self.trace_dispatch
|
|
|
|
def dispatch_call(self, frame, arg):
|
|
if not self.tracemagic and \
|
|
frame.f_code.co_name[:2] == '__' == frame.f_code.co_name[-2:] and \
|
|
frame.f_code.co_name <> '__init__':
|
|
return
|
|
if self.botframe is None:
|
|
# First call of dispatch since reset()
|
|
self.botframe = frame.f_back # xxx !!! added f_back
|
|
return self.trace_dispatch
|
|
if not (self.stop_here(frame) or self.break_anywhere(frame)):
|
|
# No need to trace this function
|
|
return # None
|
|
self.user_call(frame, arg)
|
|
if self.quitting:
|
|
raise bdb.BdbQuit
|
|
return self.trace_dispatch
|
|
|
|
def set_continue(self):
|
|
# Don't stop except at breakpoints or when finished
|
|
self.stopframe = self.botframe
|
|
self.returnframe = None
|
|
self.quitting = 0
|
|
# unlike in bdb/pdb, there's a chance that breakpoints change
|
|
# *while* a program (this program ;-) is running. It's actually quite likely.
|
|
# So we don't delete frame.f_trace until the bottom frame if there are no breakpoints.
|
|
|
|
def set_break(self, filename, lineno):
|
|
if not self.breaks.has_key(filename):
|
|
self.breaks[filename] = []
|
|
list = self.breaks[filename]
|
|
if lineno in list:
|
|
return 'There is already a breakpoint there!'
|
|
list.append(lineno)
|
|
list.sort() # I want to keep them neatly sorted; easier for drawing
|
|
if hasattr(bdb, "Breakpoint"):
|
|
# 1.5.2b1 specific
|
|
bp = bdb.Breakpoint(filename, lineno, 0, None)
|
|
self.update_breaks(filename)
|
|
|
|
def clear_break(self, filename, lineno):
|
|
bdb.Bdb.clear_break(self, filename, lineno)
|
|
self.update_breaks(filename)
|
|
|
|
def clear_all_file_breaks(self, filename):
|
|
bdb.Bdb.clear_all_file_breaks(self, filename)
|
|
self.update_breaks(filename)
|
|
|
|
def clear_all_breaks(self):
|
|
bdb.Bdb.clear_all_breaks(self)
|
|
for editors in self.editors.values():
|
|
for editor in editors:
|
|
editor.drawbreakpoints()
|
|
|
|
# special
|
|
|
|
def toggle_break(self, filename, lineno):
|
|
if self.get_break(filename, lineno):
|
|
self.clear_break(filename, lineno)
|
|
else:
|
|
self.set_break(filename, lineno)
|
|
|
|
def clear_breaks_above(self, filename, above):
|
|
if not self.breaks.has_key(filename):
|
|
return 'There are no breakpoints in that file!'
|
|
for lineno in self.breaks[filename][:]:
|
|
if lineno > above:
|
|
self.breaks[filename].remove(lineno)
|
|
if not self.breaks[filename]:
|
|
del self.breaks[filename]
|
|
|
|
# editor stuff
|
|
|
|
def update_breaks(self, filename):
|
|
if self.breaksviewer:
|
|
self.breaksviewer.update()
|
|
if self.editors.has_key(filename):
|
|
for editor in self.editors[filename]:
|
|
if editor._debugger: # XXX
|
|
editor.drawbreakpoints()
|
|
else:
|
|
print 'xxx dead editor!'
|
|
|
|
def update_allbreaks(self):
|
|
if self.breaksviewer:
|
|
self.breaksviewer.update()
|
|
for filename in self.breaks.keys():
|
|
if self.editors.has_key(filename):
|
|
for editor in self.editors[filename]:
|
|
if editor._debugger: # XXX
|
|
editor.drawbreakpoints()
|
|
else:
|
|
print 'xxx dead editor!'
|
|
|
|
def register_editor(self, editor, filename):
|
|
if not filename:
|
|
return
|
|
if not self.editors.has_key(filename):
|
|
self.editors[filename] = [editor]
|
|
elif editor not in self.editors[filename]:
|
|
self.editors[filename].append(editor)
|
|
|
|
def unregister_editor(self, editor, filename):
|
|
if not filename:
|
|
return
|
|
try:
|
|
self.editors[filename].remove(editor)
|
|
if not self.editors[filename]:
|
|
del self.editors[filename]
|
|
# if this was an untitled window, clear the breaks.
|
|
if filename[:1] == '<' and filename[-1:] == '>' and \
|
|
self.breaks.has_key(filename):
|
|
self.clear_all_file_breaks(filename)
|
|
except (KeyError, ValueError):
|
|
pass
|
|
|
|
|
|
class SourceViewer(W.PyEditor):
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
apply(W.PyEditor.__init__, (self,) + args, kwargs)
|
|
self.bind('<click>', self.clickintercept)
|
|
|
|
def clickintercept(self, point, modifiers):
|
|
if self._parentwindow._currentwidget <> self and not self.pt_in_breaks(point):
|
|
self._parentwindow.xxx___select(self)
|
|
return 1
|
|
|
|
def _getviewrect(self):
|
|
l, t, r, b = self._bounds
|
|
if self._debugger:
|
|
return (l + 12, t + 2, r - 1, b - 2)
|
|
else:
|
|
return (l + 5, t + 2, r - 1, b - 2)
|
|
|
|
def select(self, onoff, isclick = 0):
|
|
if W.SelectableWidget.select(self, onoff):
|
|
return
|
|
self.SetPort()
|
|
#if onoff:
|
|
# self.ted.WEActivate()
|
|
#else:
|
|
# self.ted.WEDeactivate()
|
|
self.drawselframe(onoff)
|
|
|
|
def drawselframe(self, onoff):
|
|
pass
|
|
|
|
|
|
class BreakpointsViewer:
|
|
|
|
def __init__(self, debugger):
|
|
self.debugger = debugger
|
|
self.w = W.Window((300, 250), 'Breakpoints', minsize = (200, 200))
|
|
self.w.panes = W.HorizontalPanes((8, 8, -8, -32), (0.3, 0.7))
|
|
self.w.panes.files = W.List(None, callback = self.filehit) #, flags = Lists.lOnlyOne)
|
|
self.w.panes.gr = W.Group(None)
|
|
self.w.panes.gr.breaks = W.List((0, 0, -130, 0), callback = self.linehit) #, flags = Lists.lOnlyOne)
|
|
self.w.panes.gr.openbutton = W.Button((-80, 4, 0, 16), 'View\xc9', self.openbuttonhit)
|
|
self.w.panes.gr.deletebutton = W.Button((-80, 28, 0, 16), 'Delete', self.deletebuttonhit)
|
|
|
|
self.w.bind('<close>', self.close)
|
|
self.w.bind('backspace', self.w.panes.gr.deletebutton.push)
|
|
|
|
self.setup()
|
|
self.w.open()
|
|
self.w.panes.gr.openbutton.enable(0)
|
|
self.w.panes.gr.deletebutton.enable(0)
|
|
self.curfile = None
|
|
|
|
def deletebuttonhit(self):
|
|
if self.w._currentwidget == self.w.panes.files:
|
|
self.del_filename()
|
|
else:
|
|
self.del_number()
|
|
self.checkbuttons()
|
|
|
|
def del_number(self):
|
|
if self.curfile is None:
|
|
return
|
|
sel = self.w.panes.gr.breaks.getselectedobjects()
|
|
for lineno in sel:
|
|
self.debugger.clear_break(self.curfile, lineno)
|
|
|
|
def del_filename(self):
|
|
sel = self.w.panes.files.getselectedobjects()
|
|
for filename in sel:
|
|
self.debugger.clear_all_file_breaks(filename)
|
|
self.debugger.update_allbreaks()
|
|
|
|
def setup(self):
|
|
files = self.debugger.breaks.keys()
|
|
files.sort()
|
|
self.w.panes.files.set(files)
|
|
|
|
def close(self):
|
|
self.debugger.breaksviewer = None
|
|
self.debugger = None
|
|
|
|
def update(self):
|
|
sel = self.w.panes.files.getselectedobjects()
|
|
self.setup()
|
|
self.w.panes.files.setselectedobjects(sel)
|
|
sel = self.w.panes.files.getselection()
|
|
if len(sel) == 0 and self.curfile:
|
|
self.w.panes.files.setselectedobjects([self.curfile])
|
|
self.filehit(0)
|
|
|
|
def select(self):
|
|
self.w.select()
|
|
|
|
def selectfile(self, file):
|
|
self.w.panes.files.setselectedobjects([file])
|
|
self.filehit(0)
|
|
|
|
def openbuttonhit(self):
|
|
self.filehit(1)
|
|
|
|
def filehit(self, isdbl):
|
|
sel = self.w.panes.files.getselectedobjects()
|
|
if isdbl:
|
|
for filename in sel:
|
|
lineno = None
|
|
if filename == self.curfile:
|
|
linesel = self.w.panes.gr.breaks.getselectedobjects()
|
|
if linesel:
|
|
lineno = linesel[-1]
|
|
elif self.w.panes.gr.breaks:
|
|
lineno = self.w.panes.gr.breaks[0]
|
|
editor = self.w._parentwindow.parent.openscript(filename, lineno)
|
|
editor.showbreakpoints(1)
|
|
return
|
|
if len(sel) == 1:
|
|
file = sel[0]
|
|
filebreaks = self.debugger.breaks[file][:]
|
|
if self.curfile == file:
|
|
linesel = self.w.panes.gr.breaks.getselectedobjects()
|
|
self.w.panes.gr.breaks.set(filebreaks)
|
|
if self.curfile == file:
|
|
self.w.panes.gr.breaks.setselectedobjects(linesel)
|
|
self.curfile = file
|
|
else:
|
|
if len(sel) <> 0:
|
|
self.curfile = None
|
|
self.w.panes.gr.breaks.set([])
|
|
self.checkbuttons()
|
|
|
|
def linehit(self, isdbl):
|
|
if isdbl:
|
|
files = self.w.panes.files.getselectedobjects()
|
|
if len(files) <> 1:
|
|
return
|
|
filename = files[0]
|
|
linenos = self.w.panes.gr.breaks.getselectedobjects()
|
|
if not linenos:
|
|
return
|
|
lineno = linenos[-1]
|
|
editor = self.w._parentwindow.parent.openscript(filename, lineno)
|
|
editor.showbreakpoints(1)
|
|
self.checkbuttons()
|
|
|
|
def checkbuttons(self):
|
|
if self.w.panes.files.getselection():
|
|
self.w.panes.gr.openbutton.enable(1)
|
|
self.w._parentwindow.setdefaultbutton(self.w.panes.gr.openbutton)
|
|
if self.w._currentwidget == self.w.panes.files:
|
|
if self.w.panes.files.getselection():
|
|
self.w.panes.gr.deletebutton.enable(1)
|
|
else:
|
|
self.w.panes.gr.deletebutton.enable(0)
|
|
else:
|
|
if self.w.panes.gr.breaks.getselection():
|
|
self.w.panes.gr.deletebutton.enable(1)
|
|
else:
|
|
self.w.panes.gr.deletebutton.enable(0)
|
|
else:
|
|
self.w.panes.gr.openbutton.enable(0)
|
|
self.w.panes.gr.deletebutton.enable(0)
|
|
|
|
|
|
class TracingMonitor(W.Widget):
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
apply(W.Widget.__init__, (self,) + args, kwargs)
|
|
self.state = 0
|
|
|
|
def toggle(self):
|
|
if hasattr(self, "_parentwindow") and self._parentwindow is not None:
|
|
self.state = self.state % 2 + 1
|
|
port = Qd.GetPort()
|
|
self.SetPort()
|
|
self.draw()
|
|
Qd.SetPort(port)
|
|
|
|
def reset(self):
|
|
if self._parentwindow:
|
|
self.state = 0
|
|
port = Qd.GetPort()
|
|
self.SetPort()
|
|
self.draw()
|
|
Qd.SetPort(port)
|
|
|
|
def draw(self, visRgn = None):
|
|
if self.state == 2:
|
|
Qd.PaintOval(self._bounds)
|
|
else:
|
|
Qd.EraseOval(self._bounds)
|
|
|
|
|
|
# convenience funcs
|
|
|
|
def postmortem(exc_type, exc_value, tb):
|
|
d = getdebugger()
|
|
d.postmortem(exc_type, exc_value, tb)
|
|
|
|
def start(bottomframe = None):
|
|
d = getdebugger()
|
|
d.start(bottomframe)
|
|
|
|
def startfromhere():
|
|
d = getdebugger()
|
|
try:
|
|
raise 'spam'
|
|
except:
|
|
frame = sys.exc_traceback.tb_frame.f_back
|
|
d.start(frame)
|
|
|
|
def startfrombottom():
|
|
d = getdebugger()
|
|
d.start(_getbottomframe(), 1)
|
|
|
|
def stop():
|
|
d = getdebugger()
|
|
d.stop()
|
|
|
|
def cont():
|
|
sys.settrace(None)
|
|
d = getdebugger()
|
|
d.set_continue_without_debugger()
|
|
|
|
def _getbottomframe():
|
|
try:
|
|
raise 'spam'
|
|
except:
|
|
pass
|
|
frame = sys.exc_traceback.tb_frame
|
|
while 1:
|
|
if frame.f_code.co_name == 'mainloop' or frame.f_back is None:
|
|
break
|
|
frame = frame.f_back
|
|
return frame
|
|
|
|
_debugger = None
|
|
|
|
def getdebugger():
|
|
if not __debug__:
|
|
raise W.AlertError, "Can't debug in \"Optimize bytecode\" mode.\r(see \"Default startup options\" in EditPythonPreferences)"
|
|
global _debugger
|
|
if _debugger is None:
|
|
_debugger = Debugger()
|
|
return _debugger
|