985 lines
31 KiB
Python
985 lines
31 KiB
Python
# debugger.py
|
|
|
|
# A debugger for Pythonwin. Built from pdb.
|
|
|
|
# Mark Hammond (MHammond@skippinet.com.au) - Dec 94.
|
|
|
|
# usage:
|
|
# >>> import pywin.debugger
|
|
# >>> pywin.debugger.GetDebugger().run("command")
|
|
|
|
import pdb
|
|
import bdb
|
|
import sys
|
|
import string
|
|
import os
|
|
import types
|
|
|
|
import win32ui
|
|
import win32api
|
|
import win32con
|
|
import pywin.docking.DockingBar
|
|
from pywin.mfc import dialog, object, afxres, window
|
|
from pywin.framework import app, interact, editor, scriptutils
|
|
from pywin.framework.editor.color.coloreditor import MARKER_CURRENT, MARKER_BREAKPOINT
|
|
from pywin.tools import browser, hierlist
|
|
import commctrl
|
|
import traceback
|
|
|
|
#import win32traceutil
|
|
if win32ui.UNICODE:
|
|
LVN_ENDLABELEDIT = commctrl.LVN_ENDLABELEDITW
|
|
else:
|
|
LVN_ENDLABELEDIT = commctrl.LVN_ENDLABELEDITA
|
|
|
|
from .dbgcon import *
|
|
|
|
error = "pywin.debugger.error"
|
|
|
|
def SetInteractiveContext(globs, locs):
|
|
if interact.edit is not None and interact.edit.currentView is not None:
|
|
interact.edit.currentView.SetContext(globs, locs)
|
|
|
|
def _LineStateToMarker(ls):
|
|
if ls==LINESTATE_CURRENT:
|
|
return MARKER_CURRENT
|
|
# elif ls == LINESTATE_CALLSTACK:
|
|
# return MARKER_CALLSTACK
|
|
return MARKER_BREAKPOINT
|
|
|
|
class HierListItem(browser.HLIPythonObject):
|
|
pass
|
|
|
|
class HierFrameItem(HierListItem):
|
|
def __init__(self, frame, debugger):
|
|
HierListItem.__init__(self, frame, repr(frame))
|
|
self.debugger = debugger
|
|
def GetText(self):
|
|
name = self.myobject.f_code.co_name
|
|
if not name or name == '?' :
|
|
# See if locals has a '__name__' (ie, a module)
|
|
if '__name__' in self.myobject.f_locals:
|
|
name = str(self.myobject.f_locals['__name__']) + " module"
|
|
else:
|
|
name = '<Debugger Context>'
|
|
|
|
return "%s (%s:%d)" % (name, os.path.split(self.myobject.f_code.co_filename)[1], self.myobject.f_lineno)
|
|
def GetBitmapColumn(self):
|
|
if self.debugger.curframe is self.myobject:
|
|
return 7
|
|
else:
|
|
return 8
|
|
def GetSubList(self):
|
|
ret = []
|
|
ret.append(HierFrameDict(self.myobject.f_locals, "Locals", 2))
|
|
ret.append(HierFrameDict(self.myobject.f_globals, "Globals", 1))
|
|
return ret
|
|
def IsExpandable(self):
|
|
return 1
|
|
def TakeDefaultAction(self):
|
|
# Set the default frame to be this frame.
|
|
self.debugger.set_cur_frame(self.myobject)
|
|
return 1
|
|
|
|
class HierFrameDict(browser.HLIDict):
|
|
def __init__(self, dict, name, bitmapColumn):
|
|
self.bitmapColumn=bitmapColumn
|
|
browser.HLIDict.__init__(self, dict, name)
|
|
def GetBitmapColumn(self):
|
|
return self.bitmapColumn
|
|
|
|
class NoStackAvailableItem(HierListItem):
|
|
def __init__(self, why):
|
|
HierListItem.__init__(self, None, why)
|
|
def IsExpandable(self):
|
|
return 0
|
|
def GetText(self):
|
|
return self.name
|
|
def GetBitmapColumn(self):
|
|
return 8
|
|
|
|
class HierStackRoot(HierListItem):
|
|
def __init__( self, debugger ):
|
|
HierListItem.__init__(self, debugger, None)
|
|
self.last_stack = []
|
|
## def __del__(self):
|
|
## print "HierStackRoot dieing"
|
|
def GetSubList(self):
|
|
debugger = self.myobject
|
|
# print self.debugger.stack, self.debugger.curframe
|
|
ret = []
|
|
if debugger.debuggerState==DBGSTATE_BREAK:
|
|
stackUse=debugger.stack[:]
|
|
stackUse.reverse()
|
|
self.last_stack = []
|
|
for frame, lineno in stackUse:
|
|
self.last_stack.append( (frame, lineno) )
|
|
if frame is debugger.userbotframe: # Dont bother showing frames below our bottom frame.
|
|
break
|
|
for frame, lineno in self.last_stack:
|
|
ret.append( HierFrameItem( frame, debugger ) )
|
|
## elif debugger.debuggerState==DBGSTATE_NOT_DEBUGGING:
|
|
## ret.append(NoStackAvailableItem('<nothing is being debugged>'))
|
|
## else:
|
|
## ret.append(NoStackAvailableItem('<stack not available while running>'))
|
|
return ret
|
|
def GetText(self):
|
|
return 'root item'
|
|
def IsExpandable(self):
|
|
return 1
|
|
|
|
class HierListDebugger(hierlist.HierListWithItems):
|
|
""" Hier List of stack frames, breakpoints, whatever """
|
|
def __init__(self):
|
|
hierlist.HierListWithItems.__init__(self, None, win32ui.IDB_DEBUGGER_HIER, None, win32api.RGB(255,0,0))
|
|
def Setup(self, debugger):
|
|
root = HierStackRoot(debugger)
|
|
self.AcceptRoot(root)
|
|
# def Refresh(self):
|
|
# self.Setup()
|
|
|
|
class DebuggerWindow(window.Wnd):
|
|
def __init__(self, ob):
|
|
window.Wnd.__init__(self, ob)
|
|
self.debugger = None
|
|
|
|
def Init(self, debugger):
|
|
self.debugger = debugger
|
|
|
|
def GetDefRect(self):
|
|
defRect = app.LoadWindowSize("Debugger Windows\\" + self.title)
|
|
if defRect[2]-defRect[0]==0:
|
|
defRect = 0, 0, 150, 150
|
|
return defRect
|
|
|
|
def OnDestroy(self, msg):
|
|
newSize = self.GetWindowPlacement()[4]
|
|
pywin.framework.app.SaveWindowSize("Debugger Windows\\" + self.title, newSize)
|
|
return window.Wnd.OnDestroy(self, msg)
|
|
|
|
def OnKeyDown(self, msg):
|
|
key = msg[2]
|
|
if key in [13, 27, 32]: return 1
|
|
if key in [46,8]: # delete/BS key
|
|
self.DeleteSelected()
|
|
return 0
|
|
view = scriptutils.GetActiveView()
|
|
try:
|
|
firer = view.bindings.fire_key_event
|
|
except AttributeError:
|
|
firer = None
|
|
if firer is not None:
|
|
return firer(msg)
|
|
else:
|
|
return 1
|
|
|
|
def DeleteSelected(self):
|
|
win32api.MessageBeep()
|
|
|
|
def EditSelected(self):
|
|
win32api.MessageBeep()
|
|
|
|
class DebuggerStackWindow(DebuggerWindow):
|
|
title = "Stack"
|
|
def __init__(self):
|
|
DebuggerWindow.__init__(self, win32ui.CreateTreeCtrl())
|
|
self.list = HierListDebugger()
|
|
self.listOK = 0
|
|
def SaveState(self):
|
|
self.list.DeleteAllItems()
|
|
self.listOK = 0
|
|
win32ui.WriteProfileVal("Debugger Windows\\" + self.title, "Visible", self.IsWindowVisible())
|
|
def CreateWindow(self, parent):
|
|
style = win32con.WS_CHILD | win32con.WS_VISIBLE | win32con.WS_BORDER | commctrl.TVS_HASLINES | commctrl.TVS_LINESATROOT | commctrl.TVS_HASBUTTONS
|
|
self._obj_.CreateWindow(style, self.GetDefRect(), parent, win32ui.IDC_LIST1)
|
|
self.HookMessage(self.OnKeyDown, win32con.WM_KEYDOWN)
|
|
self.HookMessage(self.OnKeyDown, win32con.WM_SYSKEYDOWN)
|
|
self.list.HierInit (parent, self)
|
|
self.listOK = 0 # delayed setup
|
|
#self.list.Setup()
|
|
|
|
def RespondDebuggerState(self, state):
|
|
assert self.debugger is not None, "Init not called"
|
|
if not self.listOK:
|
|
self.listOK = 1
|
|
self.list.Setup(self.debugger)
|
|
else:
|
|
self.list.Refresh()
|
|
|
|
def RespondDebuggerData(self):
|
|
try:
|
|
handle = self.GetChildItem(0)
|
|
except win32ui.error:
|
|
return # No items
|
|
while 1:
|
|
item = self.list.ItemFromHandle(handle)
|
|
col = self.list.GetBitmapColumn(item)
|
|
selCol = self.list.GetSelectedBitmapColumn(item)
|
|
if selCol is None: selCol = col
|
|
if self.list.GetItemImage(handle)!= (col, selCol):
|
|
self.list.SetItemImage(handle, col, selCol)
|
|
try:
|
|
handle = self.GetNextSiblingItem(handle)
|
|
except win32ui.error:
|
|
break
|
|
|
|
class DebuggerListViewWindow(DebuggerWindow):
|
|
def __init__(self):
|
|
DebuggerWindow.__init__(self, win32ui.CreateListCtrl())
|
|
def CreateWindow(self, parent):
|
|
list = self
|
|
style = win32con.WS_CHILD | win32con.WS_VISIBLE | win32con.WS_BORDER | commctrl.LVS_EDITLABELS | commctrl.LVS_REPORT
|
|
self._obj_.CreateWindow(style, self.GetDefRect(), parent, win32ui.IDC_LIST1)
|
|
self.HookMessage(self.OnKeyDown, win32con.WM_KEYDOWN)
|
|
self.HookMessage(self.OnKeyDown, win32con.WM_SYSKEYDOWN)
|
|
list = self
|
|
title, width = self.columns[0]
|
|
itemDetails = (commctrl.LVCFMT_LEFT, width, title, 0)
|
|
list.InsertColumn(0, itemDetails)
|
|
col = 1
|
|
for title, width in self.columns[1:]:
|
|
col = col + 1
|
|
itemDetails = (commctrl.LVCFMT_LEFT, width, title, 0)
|
|
list.InsertColumn(col, itemDetails)
|
|
parent.HookNotify(self.OnListEndLabelEdit, LVN_ENDLABELEDIT)
|
|
parent.HookNotify(self.OnItemRightClick, commctrl.NM_RCLICK)
|
|
parent.HookNotify(self.OnItemDoubleClick, commctrl.NM_DBLCLK)
|
|
|
|
def RespondDebuggerData(self):
|
|
pass
|
|
|
|
def RespondDebuggerState(self, state):
|
|
pass
|
|
|
|
def EditSelected(self):
|
|
try:
|
|
sel = self.GetNextItem(-1, commctrl.LVNI_SELECTED)
|
|
except win32ui.error:
|
|
return
|
|
self.EditLabel(sel)
|
|
|
|
def OnKeyDown(self, msg):
|
|
key = msg[2]
|
|
# If someone starts typing, they probably are trying to edit the text!
|
|
if chr(key) in string.ascii_uppercase:
|
|
self.EditSelected()
|
|
return 0
|
|
return DebuggerWindow.OnKeyDown(self, msg)
|
|
|
|
def OnItemDoubleClick(self, notify_data, extra):
|
|
self.EditSelected()
|
|
|
|
def OnItemRightClick(self, notify_data, extra):
|
|
# First select the item we right-clicked on.
|
|
pt = self.ScreenToClient(win32api.GetCursorPos())
|
|
flags, hItem, subitem = self.HitTest(pt)
|
|
if hItem==-1 or commctrl.TVHT_ONITEM & flags==0:
|
|
return None
|
|
self.SetItemState(hItem, commctrl.LVIS_SELECTED, commctrl.LVIS_SELECTED)
|
|
|
|
menu = win32ui.CreatePopupMenu()
|
|
menu.AppendMenu(win32con.MF_STRING|win32con.MF_ENABLED,1000, "Edit item")
|
|
menu.AppendMenu(win32con.MF_STRING|win32con.MF_ENABLED,1001, "Delete item")
|
|
dockbar = self.GetParent()
|
|
if dockbar.IsFloating():
|
|
hook_parent = win32ui.GetMainFrame()
|
|
else:
|
|
hook_parent = self.GetParentFrame()
|
|
hook_parent.HookCommand(self.OnEditItem, 1000)
|
|
hook_parent.HookCommand(self.OnDeleteItem, 1001)
|
|
menu.TrackPopupMenu(win32api.GetCursorPos()) # track at mouse position.
|
|
return None
|
|
|
|
def OnDeleteItem(self,command, code):
|
|
self.DeleteSelected()
|
|
def OnEditItem(self, command, code):
|
|
self.EditSelected()
|
|
|
|
class DebuggerBreakpointsWindow(DebuggerListViewWindow):
|
|
title = "Breakpoints"
|
|
columns = [ ("Condition", 70), ("Location", 1024)]
|
|
|
|
def SaveState(self):
|
|
items = []
|
|
for i in range(self.GetItemCount()):
|
|
items.append(self.GetItemText(i,0))
|
|
items.append(self.GetItemText(i,1))
|
|
win32ui.WriteProfileVal("Debugger Windows\\" + self.title, "BreakpointList", "\t".join(items))
|
|
win32ui.WriteProfileVal("Debugger Windows\\" + self.title, "Visible", self.IsWindowVisible())
|
|
return 1
|
|
|
|
def OnListEndLabelEdit(self, std, extra):
|
|
item = extra[0]
|
|
text = item[4]
|
|
if text is None: return
|
|
|
|
item_id = self.GetItem(item[0])[6]
|
|
|
|
from bdb import Breakpoint
|
|
for bplist in Breakpoint.bplist.values():
|
|
for bp in bplist:
|
|
if id(bp)==item_id:
|
|
if text.strip().lower()=="none":
|
|
text = None
|
|
bp.cond = text
|
|
break
|
|
self.RespondDebuggerData()
|
|
|
|
def DeleteSelected(self):
|
|
try:
|
|
num = self.GetNextItem(-1, commctrl.LVNI_SELECTED)
|
|
item_id = self.GetItem(num)[6]
|
|
from bdb import Breakpoint
|
|
for bplist in list(Breakpoint.bplist.values()):
|
|
for bp in bplist:
|
|
if id(bp)==item_id:
|
|
self.debugger.clear_break(bp.file, bp.line)
|
|
break
|
|
except win32ui.error:
|
|
win32api.MessageBeep()
|
|
self.RespondDebuggerData()
|
|
|
|
def RespondDebuggerData(self):
|
|
l = self
|
|
l.DeleteAllItems()
|
|
index = -1
|
|
from bdb import Breakpoint
|
|
for bplist in Breakpoint.bplist.values():
|
|
for bp in bplist:
|
|
baseName = os.path.split(bp.file)[1]
|
|
cond = bp.cond
|
|
item = index+1, 0, 0, 0, str(cond), 0, id(bp)
|
|
index = l.InsertItem(item)
|
|
l.SetItemText(index, 1, "%s: %s" % (baseName, bp.line))
|
|
|
|
class DebuggerWatchWindow(DebuggerListViewWindow):
|
|
title = "Watch"
|
|
columns = [ ("Expression", 70), ("Value", 1024)]
|
|
|
|
def CreateWindow(self, parent):
|
|
DebuggerListViewWindow.CreateWindow(self, parent)
|
|
items = win32ui.GetProfileVal("Debugger Windows\\" + self.title, "Items", "").split("\t")
|
|
index = -1
|
|
for item in items:
|
|
if item:
|
|
index = self.InsertItem(index+1, item)
|
|
self.InsertItem(index+1, "<New Item>")
|
|
|
|
def SaveState(self):
|
|
items = []
|
|
for i in range(self.GetItemCount()-1):
|
|
items.append(self.GetItemText(i,0))
|
|
win32ui.WriteProfileVal("Debugger Windows\\" + self.title, "Items", "\t".join(items))
|
|
win32ui.WriteProfileVal("Debugger Windows\\" + self.title, "Visible", self.IsWindowVisible())
|
|
return 1
|
|
|
|
def OnListEndLabelEdit(self, std, extra):
|
|
item = extra[0]
|
|
itemno = item[0]
|
|
text = item[4]
|
|
if text is None: return
|
|
self.SetItemText(itemno, 0, text)
|
|
if itemno == self.GetItemCount()-1:
|
|
self.InsertItem(itemno+1, "<New Item>")
|
|
self.RespondDebuggerState(self.debugger.debuggerState)
|
|
|
|
def DeleteSelected(self):
|
|
try:
|
|
num = self.GetNextItem(-1, commctrl.LVNI_SELECTED)
|
|
if num < self.GetItemCount()-1: # We cant delete the last
|
|
self.DeleteItem(num)
|
|
except win32ui.error:
|
|
win32api.MessageBeep()
|
|
|
|
def RespondDebuggerState(self, state):
|
|
globs = locs = None
|
|
if state==DBGSTATE_BREAK:
|
|
if self.debugger.curframe:
|
|
globs = self.debugger.curframe.f_globals
|
|
locs = self.debugger.curframe.f_locals
|
|
elif state==DBGSTATE_NOT_DEBUGGING:
|
|
import __main__
|
|
globs = locs = __main__.__dict__
|
|
for i in range(self.GetItemCount()-1):
|
|
text = self.GetItemText(i, 0)
|
|
if globs is None:
|
|
val = ""
|
|
else:
|
|
try:
|
|
val = repr( eval( text, globs, locs) )
|
|
except SyntaxError:
|
|
val = "Syntax Error"
|
|
except:
|
|
t, v, tb = sys.exc_info()
|
|
val = traceback.format_exception_only(t, v)[0].strip()
|
|
tb = None # prevent a cycle.
|
|
self.SetItemText(i, 1, val)
|
|
|
|
def CreateDebuggerDialog(parent, klass):
|
|
control = klass()
|
|
control.CreateWindow(parent)
|
|
return control
|
|
|
|
DebuggerDialogInfos = (
|
|
(0xe810, DebuggerStackWindow, None),
|
|
(0xe811, DebuggerBreakpointsWindow, (10, 10)),
|
|
(0xe812, DebuggerWatchWindow, None),
|
|
)
|
|
|
|
# Prepare all the "control bars" for this package.
|
|
# If control bars are not all loaded when the toolbar-state functions are
|
|
# called, things go horribly wrong.
|
|
def PrepareControlBars(frame):
|
|
style = win32con.WS_CHILD | afxres.CBRS_SIZE_DYNAMIC | afxres.CBRS_TOP | afxres.CBRS_TOOLTIPS | afxres.CBRS_FLYBY
|
|
tbd = win32ui.CreateToolBar (frame, style, win32ui.ID_VIEW_TOOLBAR_DBG)
|
|
tbd.ModifyStyle(0, commctrl.TBSTYLE_FLAT)
|
|
tbd.LoadToolBar(win32ui.IDR_DEBUGGER)
|
|
tbd.EnableDocking(afxres.CBRS_ALIGN_ANY)
|
|
tbd.SetWindowText("Debugger")
|
|
frame.DockControlBar(tbd)
|
|
|
|
# and the other windows.
|
|
for id, klass, float in DebuggerDialogInfos:
|
|
try:
|
|
frame.GetControlBar(id)
|
|
exists=1
|
|
except win32ui.error:
|
|
exists=0
|
|
if exists: continue
|
|
bar = pywin.docking.DockingBar.DockingBar()
|
|
style=win32con.WS_CHILD | afxres.CBRS_LEFT # don't create visible.
|
|
bar.CreateWindow(frame, CreateDebuggerDialog, klass.title, id, style, childCreatorArgs=(klass,))
|
|
bar.SetBarStyle( bar.GetBarStyle()|afxres.CBRS_TOOLTIPS|afxres.CBRS_FLYBY|afxres.CBRS_SIZE_DYNAMIC)
|
|
bar.EnableDocking(afxres.CBRS_ALIGN_ANY)
|
|
if float is None:
|
|
frame.DockControlBar(bar)
|
|
else:
|
|
frame.FloatControlBar(bar, float, afxres.CBRS_ALIGN_ANY)
|
|
|
|
## frame.ShowControlBar(bar, 0, 1)
|
|
|
|
|
|
SKIP_NONE=0
|
|
SKIP_STEP=1
|
|
SKIP_RUN=2
|
|
|
|
debugger_parent=pdb.Pdb
|
|
class Debugger(debugger_parent):
|
|
def __init__(self):
|
|
self.inited = 0
|
|
self.skipBotFrame = SKIP_NONE
|
|
self.userbotframe = None
|
|
self.frameShutdown = 0
|
|
self.pumping = 0
|
|
self.debuggerState = DBGSTATE_NOT_DEBUGGING # Assume so, anyway.
|
|
self.shownLineCurrent = None # The last filename I highlighted.
|
|
self.shownLineCallstack = None # The last filename I highlighted.
|
|
self.last_cmd_debugged = ""
|
|
self.abortClosed = 0
|
|
self.isInitialBreakpoint = 0
|
|
debugger_parent.__init__(self)
|
|
|
|
# See if any break-points have been set in the editor
|
|
for doc in editor.editorTemplate.GetDocumentList():
|
|
lineNo = -1
|
|
while 1:
|
|
lineNo = doc.MarkerGetNext(lineNo+1, MARKER_BREAKPOINT)
|
|
if lineNo <= 0: break
|
|
self.set_break(doc.GetPathName(), lineNo)
|
|
|
|
self.reset()
|
|
self.inForcedGUI = win32ui.GetApp().IsInproc()
|
|
self.options = LoadDebuggerOptions()
|
|
self.bAtException = self.bAtPostMortem = 0
|
|
|
|
def __del__(self):
|
|
self.close()
|
|
def close(self, frameShutdown = 0):
|
|
# abortClose indicates if we have total shutdown
|
|
# (ie, main window is dieing)
|
|
if self.pumping:
|
|
# Can stop pump here, as it only posts a message, and
|
|
# returns immediately.
|
|
if not self.StopDebuggerPump(): # User cancelled close.
|
|
return 0
|
|
# NOTE - from this point on the close can not be
|
|
# stopped - the WM_QUIT message is already in the queue.
|
|
self.frameShutdown = frameShutdown
|
|
if not self.inited: return 1
|
|
self.inited = 0
|
|
|
|
SetInteractiveContext(None, None)
|
|
|
|
frame = win32ui.GetMainFrame()
|
|
# Hide the debuger toolbars (as they wont normally form part of the main toolbar state.
|
|
for id, klass, float in DebuggerDialogInfos:
|
|
try:
|
|
tb = frame.GetControlBar(id)
|
|
if tb.dialog is not None: # We may never have actually been shown.
|
|
tb.dialog.SaveState()
|
|
frame.ShowControlBar(tb, 0, 1)
|
|
except win32ui.error:
|
|
pass
|
|
|
|
self._UnshowCurrentLine()
|
|
self.set_quit()
|
|
return 1
|
|
|
|
def StopDebuggerPump(self):
|
|
assert self.pumping, "Can't stop the debugger pump if Im not pumping!"
|
|
# After stopping a pump, I may never return.
|
|
if self.GUIAboutToFinishInteract():
|
|
self.pumping = 0
|
|
win32ui.StopDebuggerPump() # Posts a message, so we do return.
|
|
return 1
|
|
return 0
|
|
|
|
def get_option(self, option):
|
|
"""Public interface into debugger options
|
|
"""
|
|
try:
|
|
return self.options[option]
|
|
except KeyError:
|
|
raise error("Option %s is not a valid option" % option)
|
|
|
|
def prep_run(self, cmd):
|
|
pass
|
|
def done_run(self, cmd=None):
|
|
self.RespondDebuggerState(DBGSTATE_NOT_DEBUGGING)
|
|
self.close()
|
|
def canonic(self, fname):
|
|
return os.path.abspath(fname).lower()
|
|
def reset(self):
|
|
debugger_parent.reset(self)
|
|
self.userbotframe = None
|
|
self.UpdateAllLineStates()
|
|
self._UnshowCurrentLine()
|
|
|
|
|
|
def setup(self, f, t):
|
|
debugger_parent.setup(self, f, t)
|
|
self.bAtException = t is not None
|
|
|
|
def set_break(self, filename, lineno, temporary=0, cond = None):
|
|
filename = self.canonic(filename)
|
|
self.SetLineState(filename, lineno, LINESTATE_BREAKPOINT)
|
|
return debugger_parent.set_break(self, filename, lineno, temporary, cond)
|
|
|
|
def clear_break(self, filename, lineno):
|
|
filename = self.canonic(filename)
|
|
self.ResetLineState(filename, lineno, LINESTATE_BREAKPOINT)
|
|
return debugger_parent.clear_break(self, filename, lineno)
|
|
|
|
def cmdloop(self):
|
|
if self.frameShutdown: return # App in the process of closing - never break in!
|
|
self.GUIAboutToBreak()
|
|
|
|
def print_stack_entry(self, frame):
|
|
# We dont want a stack printed - our GUI is better :-)
|
|
pass
|
|
|
|
def user_return(self, frame, return_value):
|
|
# Same as parent, just no "print"
|
|
# This function is called when a return trap is set here
|
|
frame.f_locals['__return__'] = return_value
|
|
self.interaction(frame, None)
|
|
|
|
def user_call(self, frame, args):
|
|
# base class has an annoying 'print' that adds no value to us...
|
|
if self.stop_here(frame):
|
|
self.interaction(frame, None)
|
|
|
|
def user_exception(self, frame, exc_info):
|
|
# This function is called if an exception occurs,
|
|
# but only if we are to stop at or just below this level
|
|
(exc_type, exc_value, exc_traceback) = exc_info
|
|
if self.get_option(OPT_STOP_EXCEPTIONS):
|
|
frame.f_locals['__exception__'] = exc_type, exc_value
|
|
print("Unhandled exception while debugging...")
|
|
# on both py2k and py3k, we may be called with exc_value
|
|
# being the args to the exception, or it may already be
|
|
# instantiated (IOW, PyErr_Normalize() hasn't been
|
|
# called on the args). In py2k this is fine, but in
|
|
# py3k, traceback.print_exception fails. So on py3k
|
|
# we instantiate an exception instance to print.
|
|
if sys.version_info > (3,) and not isinstance(exc_value, BaseException):
|
|
# they are args - may be a single item or already a tuple
|
|
if not isinstance(exc_value, tuple):
|
|
exc_value = (exc_value,)
|
|
exc_value = exc_type(*exc_value)
|
|
|
|
traceback.print_exception(exc_type, exc_value, exc_traceback)
|
|
self.interaction(frame, exc_traceback)
|
|
|
|
def user_line(self, frame):
|
|
if frame.f_lineno==0: return
|
|
debugger_parent.user_line(self, frame)
|
|
|
|
def stop_here(self, frame):
|
|
if self.isInitialBreakpoint:
|
|
self.isInitialBreakpoint = 0
|
|
self.set_continue()
|
|
return 0
|
|
if frame is self.botframe and self.skipBotFrame == SKIP_RUN:
|
|
self.set_continue()
|
|
return 0
|
|
if frame is self.botframe and self.skipBotFrame == SKIP_STEP:
|
|
self.set_step()
|
|
return 0
|
|
return debugger_parent.stop_here(self, frame)
|
|
|
|
def run(self, cmd,globals=None, locals=None, start_stepping = 1):
|
|
if not isinstance(cmd, (str, types.CodeType)):
|
|
raise TypeError("Only strings can be run")
|
|
self.last_cmd_debugged = cmd
|
|
if start_stepping:
|
|
self.isInitialBreakpoint = 0
|
|
else:
|
|
self.isInitialBreakpoint = 1
|
|
try:
|
|
if globals is None:
|
|
import __main__
|
|
globals = __main__.__dict__
|
|
if locals is None:
|
|
locals = globals
|
|
self.reset()
|
|
self.prep_run(cmd)
|
|
sys.settrace(self.trace_dispatch)
|
|
if type(cmd) != types.CodeType:
|
|
cmd = cmd+'\n'
|
|
try:
|
|
try:
|
|
if start_stepping: self.skipBotFrame = SKIP_STEP
|
|
else: self.skipBotFrame = SKIP_RUN
|
|
exec(cmd, globals, locals)
|
|
except bdb.BdbQuit:
|
|
pass
|
|
finally:
|
|
self.skipBotFrame = SKIP_NONE
|
|
self.quitting = 1
|
|
sys.settrace(None)
|
|
|
|
finally:
|
|
self.done_run(cmd)
|
|
|
|
def runeval(self, expr, globals=None, locals=None):
|
|
self.prep_run(expr)
|
|
try:
|
|
debugger_parent.runeval(self, expr, globals, locals)
|
|
finally:
|
|
self.done_run(expr)
|
|
|
|
def runexec(self, what, globs=None, locs=None):
|
|
self.reset()
|
|
sys.settrace(self.trace_dispatch)
|
|
try:
|
|
try:
|
|
exec(what, globs, locs)
|
|
except bdb.BdbQuit:
|
|
pass
|
|
finally:
|
|
self.quitting = 1
|
|
sys.settrace(None)
|
|
|
|
def do_set_step(self):
|
|
if self.GUIAboutToRun():
|
|
self.set_step()
|
|
|
|
def do_set_next(self):
|
|
if self.GUIAboutToRun():
|
|
self.set_next(self.curframe)
|
|
|
|
def do_set_return(self):
|
|
if self.GUIAboutToRun():
|
|
self.set_return(self.curframe)
|
|
|
|
def do_set_continue(self):
|
|
if self.GUIAboutToRun():
|
|
self.set_continue()
|
|
|
|
def set_quit(self):
|
|
ok = 1
|
|
if self.pumping:
|
|
ok = self.StopDebuggerPump()
|
|
if ok:
|
|
debugger_parent.set_quit(self)
|
|
|
|
def _dump_frame_(self, frame,name=None):
|
|
if name is None: name = ""
|
|
if frame:
|
|
if frame.f_code and frame.f_code.co_filename:
|
|
fname = os.path.split(frame.f_code.co_filename)[1]
|
|
else:
|
|
fname = "??"
|
|
print(repr(name), fname, frame.f_lineno, frame)
|
|
else:
|
|
print(repr(name), "None")
|
|
|
|
def set_trace(self):
|
|
# Start debugging from _2_ levels up!
|
|
try:
|
|
1 + ''
|
|
except:
|
|
frame = sys.exc_info()[2].tb_frame.f_back.f_back
|
|
self.reset()
|
|
self.userbotframe = None
|
|
while frame:
|
|
# scriptutils.py creates a local variable with name
|
|
# '_debugger_stop_frame_', and we dont go past it
|
|
# (everything above this is Pythonwin framework code)
|
|
if "_debugger_stop_frame_" in frame.f_locals:
|
|
self.userbotframe = frame
|
|
break
|
|
|
|
frame.f_trace = self.trace_dispatch
|
|
self.botframe = frame
|
|
frame = frame.f_back
|
|
self.set_step()
|
|
sys.settrace(self.trace_dispatch)
|
|
|
|
def set_cur_frame(self, frame):
|
|
# Sets the "current" frame - ie, the frame with focus. This is the
|
|
# frame on which "step out" etc actions are taken.
|
|
# This may or may not be the top of the stack.
|
|
assert frame is not None, "You must pass a valid frame"
|
|
self.curframe = frame
|
|
for f, index in self.stack:
|
|
if f is frame:
|
|
self.curindex = index
|
|
break
|
|
else:
|
|
assert 0, "Can't find the frame in the stack."
|
|
SetInteractiveContext(frame.f_globals, frame.f_locals)
|
|
self.GUIRespondDebuggerData()
|
|
self.ShowCurrentLine()
|
|
|
|
def IsBreak(self):
|
|
return self.debuggerState == DBGSTATE_BREAK
|
|
|
|
def IsDebugging(self):
|
|
return self.debuggerState != DBGSTATE_NOT_DEBUGGING
|
|
|
|
def RespondDebuggerState(self, state):
|
|
if state == self.debuggerState: return
|
|
if state==DBGSTATE_NOT_DEBUGGING: # Debugger exists, but not doing anything
|
|
title = ""
|
|
elif state==DBGSTATE_RUNNING: # Code is running under the debugger.
|
|
title = " - running"
|
|
elif state==DBGSTATE_BREAK: # We are at a breakpoint or stepping or whatever.
|
|
if self.bAtException:
|
|
if self.bAtPostMortem:
|
|
title = " - post mortem exception"
|
|
else:
|
|
title = " - exception"
|
|
else:
|
|
title = " - break"
|
|
else:
|
|
raise error("Invalid debugger state passed!")
|
|
win32ui.GetMainFrame().SetWindowText(win32ui.LoadString(win32ui.IDR_MAINFRAME) + title)
|
|
if self.debuggerState == DBGSTATE_QUITTING and state != DBGSTATE_NOT_DEBUGGING:
|
|
print("Ignoring state change cos Im trying to stop!", state)
|
|
return
|
|
self.debuggerState = state
|
|
try:
|
|
frame = win32ui.GetMainFrame()
|
|
except win32ui.error:
|
|
frame = None
|
|
if frame is not None:
|
|
for id, klass, float in DebuggerDialogInfos:
|
|
cb = win32ui.GetMainFrame().GetControlBar(id).dialog
|
|
cb.RespondDebuggerState(state)
|
|
# Tell each open editor window about the state transition
|
|
for doc in editor.editorTemplate.GetDocumentList():
|
|
doc.OnDebuggerStateChange(state)
|
|
self.ShowCurrentLine()
|
|
|
|
#
|
|
# GUI debugger interface.
|
|
#
|
|
def GUICheckInit(self):
|
|
if self.inited: return
|
|
self.inited = 1
|
|
frame = win32ui.GetMainFrame()
|
|
|
|
# Ensure the debugger windows are attached to the debugger.
|
|
for id, klass, float in DebuggerDialogInfos:
|
|
w = frame.GetControlBar(id)
|
|
w.dialog.Init(self)
|
|
# Show toolbar if it was visible during last debug session
|
|
# This would be better done using a CDockState, but that class is not wrapped yet
|
|
if win32ui.GetProfileVal("Debugger Windows\\" + w.dialog.title, "Visible", 0):
|
|
frame.ShowControlBar(w, 1, 1)
|
|
|
|
# ALWAYS show debugging toolbar, regardless of saved state
|
|
tb = frame.GetControlBar(win32ui.ID_VIEW_TOOLBAR_DBG)
|
|
frame.ShowControlBar(tb, 1, 1)
|
|
self.GUIRespondDebuggerData()
|
|
|
|
# frame.RecalcLayout()
|
|
|
|
def GetDebuggerBar(self, barName):
|
|
frame = win32ui.GetMainFrame()
|
|
for id, klass, float in DebuggerDialogInfos:
|
|
if klass.title == barName:
|
|
return frame.GetControlBar(id)
|
|
assert 0, "Can't find a bar of that name!"
|
|
|
|
def GUIRespondDebuggerData(self):
|
|
if not self.inited: # GUI not inited - no toolbars etc.
|
|
return
|
|
|
|
for id, klass, float in DebuggerDialogInfos:
|
|
cb = win32ui.GetMainFrame().GetControlBar(id).dialog
|
|
cb.RespondDebuggerData()
|
|
|
|
def GUIAboutToRun(self):
|
|
if not self.StopDebuggerPump():
|
|
return 0
|
|
self._UnshowCurrentLine()
|
|
self.RespondDebuggerState(DBGSTATE_RUNNING)
|
|
SetInteractiveContext(None, None)
|
|
return 1
|
|
|
|
def GUIAboutToBreak(self):
|
|
"Called as the GUI debugger is about to get context, and take control of the running program."
|
|
self.GUICheckInit()
|
|
self.RespondDebuggerState(DBGSTATE_BREAK)
|
|
self.GUIAboutToInteract()
|
|
if self.pumping:
|
|
print("!!! Already pumping - outa here")
|
|
return
|
|
self.pumping = 1
|
|
win32ui.StartDebuggerPump() # NOTE - This will NOT return until the user is finished interacting
|
|
assert not self.pumping, "Should not be pumping once the pump has finished"
|
|
if self.frameShutdown: # User shut down app while debugging
|
|
win32ui.GetMainFrame().PostMessage(win32con.WM_CLOSE)
|
|
|
|
def GUIAboutToInteract(self):
|
|
"Called as the GUI is about to perform any interaction with the user"
|
|
frame = win32ui.GetMainFrame()
|
|
# Remember the enabled state of our main frame
|
|
# may be disabled primarily if a modal dialog is displayed.
|
|
# Only get at enabled via GetWindowLong.
|
|
self.bFrameEnabled = frame.IsWindowEnabled()
|
|
self.oldForeground = None
|
|
fw = win32ui.GetForegroundWindow()
|
|
if fw is not frame:
|
|
self.oldForeground = fw
|
|
# fw.EnableWindow(0) Leave enabled for now?
|
|
self.oldFrameEnableState = frame.IsWindowEnabled()
|
|
frame.EnableWindow(1)
|
|
if self.inForcedGUI and not frame.IsWindowVisible():
|
|
frame.ShowWindow(win32con.SW_SHOW)
|
|
frame.UpdateWindow()
|
|
if self.curframe:
|
|
SetInteractiveContext(self.curframe.f_globals, self.curframe.f_locals)
|
|
else:
|
|
SetInteractiveContext(None, None)
|
|
self.GUIRespondDebuggerData()
|
|
|
|
def GUIAboutToFinishInteract(self):
|
|
"""Called as the GUI is about to finish any interaction with the user
|
|
Returns non zero if we are allowed to stop interacting"""
|
|
if self.oldForeground is not None:
|
|
try:
|
|
win32ui.GetMainFrame().EnableWindow(self.oldFrameEnableState)
|
|
self.oldForeground.EnableWindow(1)
|
|
except win32ui.error:
|
|
# old window may be dead.
|
|
pass
|
|
# self.oldForeground.SetForegroundWindow() - fails??
|
|
if not self.inForcedGUI:
|
|
return 1 # Never a problem, and nothing else to do.
|
|
# If we are running a forced GUI, we may never get an opportunity
|
|
# to interact again. Therefore we perform a "SaveAll", to makesure that
|
|
# any documents are saved before leaving.
|
|
for template in win32ui.GetApp().GetDocTemplateList():
|
|
for doc in template.GetDocumentList():
|
|
if not doc.SaveModified():
|
|
return 0
|
|
# All documents saved - now hide the app and debugger.
|
|
if self.get_option(OPT_HIDE):
|
|
frame = win32ui.GetMainFrame()
|
|
frame.ShowWindow(win32con.SW_HIDE)
|
|
return 1
|
|
|
|
#
|
|
# Pythonwin interface - all stuff to do with showing source files,
|
|
# changing line states etc.
|
|
#
|
|
def ShowLineState(self, fileName, lineNo, lineState):
|
|
# Set the state of a line, open if not already
|
|
self.ShowLineNo(fileName, lineNo)
|
|
self.SetLineState(fileName, lineNo, lineState)
|
|
|
|
def SetLineState(self, fileName, lineNo, lineState):
|
|
# Set the state of a line if the document is open.
|
|
doc = editor.editorTemplate.FindOpenDocument(fileName)
|
|
if doc is not None:
|
|
marker = _LineStateToMarker(lineState)
|
|
if not doc.MarkerCheck(lineNo, marker):
|
|
doc.MarkerAdd(lineNo, marker)
|
|
|
|
def ResetLineState(self, fileName, lineNo, lineState):
|
|
# Set the state of a line if the document is open.
|
|
doc = editor.editorTemplate.FindOpenDocument(fileName)
|
|
if doc is not None:
|
|
marker = _LineStateToMarker(lineState)
|
|
doc.MarkerDelete(lineNo, marker)
|
|
|
|
def UpdateDocumentLineStates(self, doc):
|
|
# Show all lines in their special status color. If the doc is open
|
|
# all line states are reset.
|
|
doc.MarkerDeleteAll( MARKER_BREAKPOINT )
|
|
doc.MarkerDeleteAll( MARKER_CURRENT )
|
|
fname = self.canonic(doc.GetPathName())
|
|
# Now loop over all break-points
|
|
for line in self.breaks.get(fname, []):
|
|
doc.MarkerAdd(line, MARKER_BREAKPOINT)
|
|
# And the current line if in this document.
|
|
if self.shownLineCurrent and fname == self.shownLineCurrent[0]:
|
|
lineNo = self.shownLineCurrent[1]
|
|
if not doc.MarkerCheck(lineNo, MARKER_CURRENT):
|
|
doc.MarkerAdd(lineNo, MARKER_CURRENT)
|
|
# if self.shownLineCallstack and fname == self.shownLineCallstack[0]:
|
|
# doc.MarkerAdd(self.shownLineCallstack[1], MARKER_CURRENT)
|
|
|
|
def UpdateAllLineStates(self):
|
|
for doc in editor.editorTemplate.GetDocumentList():
|
|
self.UpdateDocumentLineStates(doc)
|
|
|
|
def ShowCurrentLine(self):
|
|
# Show the current line. Only ever 1 current line - undoes last current
|
|
# The "Current Line" is self.curframe.
|
|
# The "Callstack Line" is the top of the stack.
|
|
# If current == callstack, only show as current.
|
|
self._UnshowCurrentLine() # un-highlight the old one.
|
|
if self.curframe:
|
|
fileName = self.canonic(self.curframe.f_code.co_filename)
|
|
lineNo = self.curframe.f_lineno
|
|
self.shownLineCurrent = fileName, lineNo
|
|
self.ShowLineState(fileName, lineNo, LINESTATE_CURRENT)
|
|
|
|
def _UnshowCurrentLine(self):
|
|
"Unshow the current line, and forget it"
|
|
if self.shownLineCurrent is not None:
|
|
fname, lineno = self.shownLineCurrent
|
|
self.ResetLineState(fname, lineno, LINESTATE_CURRENT)
|
|
self.shownLineCurrent = None
|
|
|
|
def ShowLineNo( self, filename, lineno ):
|
|
wasOpen = editor.editorTemplate.FindOpenDocument(filename) is not None
|
|
if os.path.isfile(filename) and scriptutils.JumpToDocument(filename, lineno):
|
|
if not wasOpen:
|
|
doc = editor.editorTemplate.FindOpenDocument(filename)
|
|
if doc is not None:
|
|
self.UpdateDocumentLineStates(doc)
|
|
return 1
|
|
return 0
|
|
return 1
|
|
else:
|
|
# Can't find the source file - linecache may have it?
|
|
import linecache
|
|
line = linecache.getline(filename, lineno)
|
|
print("%s(%d): %s" % (os.path.basename(filename), lineno, line[:-1].expandtabs(4)))
|
|
return 0
|