Initial revision

Lib/bdb.py

+# A generic Python debugger base class.
+# This class takes care of details of the trace facility;
+# a derived class should implement user interaction.
+# There are two debuggers based upon this:
+# 'pdb', a text-oriented debugger not unlike dbx or gdb;
+# and 'wdb', a window-oriented debugger.
+# And of course... you can roll your own!
+
+import sys
+
+BdbQuit = 'bdb.BdbQuit' # Exception to give up completely
+
+
+class Bdb: # Basic Debugger
+	
+	def init(self):
+		self.breaks = {}
+		return self
+	
+	def reset(self):
+		self.botframe = None
+		self.stopframe = None
+		self.returnframe = None
+		self.quitting = 0
+	
+	def trace_dispatch(self, frame, event, arg):
+		if self.quitting:
+			return # None
+		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:', `event`
+		return self.trace_dispatch
+	
+	def dispatch_line(self, frame):
+		if self.stop_here(frame) or self.break_here(frame):
+			self.user_line(frame)
+			if self.quitting: raise BdbQuit
+		return self.trace_dispatch
+	
+	def dispatch_call(self, frame, arg):
+		frame.f_locals['__args__'] = arg
+		if self.botframe is None:
+			# First call of dispatch since reset()
+			self.botframe = frame
+			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 BdbQuit
+		return self.trace_dispatch
+	
+	def dispatch_return(self, frame, arg):
+		if self.stop_here(frame) or frame == self.returnframe:
+			self.user_return(frame, arg)
+			if self.quitting: raise BdbQuit
+	
+	def dispatch_exception(self, frame, arg):
+		if self.stop_here(frame):
+			self.user_exception(frame, arg)
+			if self.quitting: raise BdbQuit
+		return self.trace_dispatch
+	
+	# Normally derived classes don't override the following
+	# functions, but they may if they want to redefine the
+	# definition of stopping and breakpoints.
+	
+	def stop_here(self, frame):
+		if self.stopframe is None:
+			return 1
+		if frame is self.stopframe:
+			return 1
+		while frame is not None and frame is not self.stopframe:
+			if frame is self.botframe:
+				return 1
+			frame = frame.f_back
+		return 0
+	
+	def break_here(self, frame):
+		if not self.breaks.has_key(frame.f_code.co_filename):
+			return 0
+		if not frame.f_lineno in \
+				self.breaks[frame.f_code.co_filename]:
+			return 0
+		return 1
+	
+	def break_anywhere(self, frame):
+		return self.breaks.has_key(frame.f_code.co_filename)
+	
+	# Derived classes should override the user_* functions
+	# to gain control.
+	
+	def user_call(self, frame, argument_list):
+		# This function is called when there is the remote possibility
+		# that we ever need to stop in this function
+		pass
+	
+	def user_line(self, frame):
+		# This function is called when we stop or break at this line
+		pass
+	
+	def user_return(self, frame, return_value):
+		# This function is called when a return trap is set here
+		pass
+	
+	def user_exception(self, frame, (exc_type, exc_value, exc_traceback)):
+		# This function is called if an exception occurs,
+		# but only if we are to stop at or just below this level
+		pass
+	
+	# Derived classes and clients can call the following functions
+	# to affect the stepping state.
+	
+	def set_step(self):
+		# Stop after one line of code
+		self.stopframe = None
+		self.returnframe = None
+		self.quitting = 0
+	
+	def set_next(self, frame):
+		# Stop on the next line in or below the given frame
+		self.stopframe = frame
+		self.returnframe = None
+		self.quitting = 0
+	
+	def set_return(self, frame):
+		# Stop when returning from the given frame
+		self.stopframe = frame.f_back
+		self.returnframe = frame
+		self.quitting = 0
+	
+	def set_continue(self):
+		# Don't stop except at breakpoints or when finished
+		self.stopframe = self.botframe
+		self.returnframe = None
+		self.quitting = 0
+	
+	def set_quit(self):
+		self.stopframe = self.botframe
+		self.returnframe = None
+		self.quitting = 1
+		sys.trace = None
+		del sys.trace
+	
+	# Derived classes and clients can call the following functions
+	# to manipulate breakpoints.  These functions return an
+	# error message is something went wrong, None if all is well.
+	# Call self.get_*break*() to see the breakpoints.
+	
+	def set_break(self, filename, lineno):
+		import linecache # Import as late as possible
+		line = linecache.getline(filename, lineno)
+		if not line:
+			return 'That line does not exist!'
+		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)
+	
+	def clear_break(self, filename, lineno):
+		if not self.breaks.has_key(filename):
+			return 'There are no breakpoints in that file!'
+		if lineno not in self.breaks[filename]:
+			return 'There is no breakpoint there!'
+		self.breaks[filename].remove(lineno)
+		if not self.breaks[filename]:
+			del self.breaks[filename]
+	
+	def clear_all_file_breaks(self, filename):
+		if not self.breaks.has_key(filename):
+			return 'There are no breakpoints in that file!'
+		del self.breaks[filename]
+	
+	def clear_all_breaks(self, filename, lineno):
+		if not self.breaks:
+			return 'There are no breakpoints!'
+		self.breaks = {}
+	
+	def get_break(self, filename, lineno):
+		return self.breaks.has_key(filename) and \
+			lineno in self.breaks[filename]
+	
+	def get_file_breaks(self, filename):
+		if self.breaks.has_key(filename):
+			return self.breaks[filename]
+		else:
+			return []
+	
+	def get_all_breaks(self):
+		return self.breaks
+	
+	# Derived classes and clients can call the following function
+	# to get a data structure representing a stack trace.
+	
+	def get_stack(self, f, t):
+		stack = []
+		if t and t.tb_frame is f:
+			t = t.tb_next
+		while f is not None:
+			stack.append((f, f.f_lineno))
+			if f is self.botframe:
+				break
+			f = f.f_back
+		stack.reverse()
+		i = max(0, len(stack) - 1)
+		while t is not None:
+			stack.append((t.tb_frame, t.tb_lineno))
+			t = t.tb_next
+		return stack, i
+	
+	# The following two functions can be called by clients to use
+	# a debugger to debug a statement, given as a string.
+	
+	def run(self, cmd):
+		import __main__
+		dict = __main__.__dict__
+		self.runctx(cmd, dict, dict)
+	
+	def runctx(self, cmd, globals, locals):
+		self.reset()
+		sys.trace = self.trace_dispatch
+		try:
+			exec(cmd + '\n', globals, locals)
+		except BdbQuit:
+			pass
+		finally:
+			self.quitting = 1
+			sys.trace = None
+			del sys.trace
+		# XXX What to do if the command finishes normally?
+
+
+# -------------------- testing --------------------
+
+class Tdb(Bdb):
+	def user_call(self, frame, args):
+		import codehack
+		name = codehack.getcodename(frame.f_code)
+		if not name: name = '???'
+		print '+++ call', name, args
+	def user_line(self, frame):
+		import linecache, string, codehack
+		name = codehack.getcodename(frame.f_code)
+		if not name: name = '???'
+		fn = frame.f_code.co_filename
+		line = linecache.getline(fn, frame.f_lineno)
+		print '+++', fn, frame.f_lineno, name, ':', string.strip(line)
+	def user_return(self, frame, retval):
+		print '+++ return', retval
+	def user_exception(self, frame, exc_stuff):
+		print '+++ exception', exc_stuff
+		self.set_continue()
+
+def foo(n):
+	print 'foo(', n, ')'
+	x = bar(n*10)
+	print 'bar returned', x
+
+def bar(a):
+	print 'bar(', a, ')'
+	return a/2
+
+def test():
+	import linecache
+	linecache.checkcache()
+	t = Tdb().init()
+	t.run('import bdb; bdb.foo(10)')

Lib/codehack.py

+# A subroutine for extracting a function name from a code object
+# (with cache)
+
+import sys
+from stat import *
+import string
+import os
+import linecache
+
+# Extract the function or class name from a code object.
+# This is a bit of a hack, since a code object doesn't contain
+# the name directly.  So what do we do:
+# - get the filename (which *is* in the code object)
+# - look in the code string to find the first SET_LINENO instruction
+#   (this must be the first instruction)
+# - get the line from the file
+# - if the line starts with 'class' or 'def' (after possible whitespace),
+#   extract the following identifier
+#
+# This breaks apart when the function was read from <stdin>
+# or constructed by exec(), when the file is not accessible,
+# and also when the file has been modified or when a line is
+# continued with a backslash before the function or class name.
+#
+# Because this is a pretty expensive hack, a cache is kept.
+
+SET_LINENO = 127 # The opcode (see "opcode.h" in the Python source)
+identchars = string.letters + string.digits + '_' # Identifier characters
+
+_namecache = {} # The cache
+
+def getcodename(co):
+	key = `co` # arbitrary but uniquely identifying string
+	if _namecache.has_key(key): return _namecache[key]
+	filename = co.co_filename
+	code = co.co_code
+	name = ''
+	if ord(code[0]) == SET_LINENO:
+		lineno = ord(code[1]) | ord(code[2]) << 8
+		line = linecache.getline(filename, lineno)
+		words = string.split(line)
+		if len(words) >= 2 and words[0] in ('def', 'class'):
+			name = words[1]
+			for i in range(len(name)):
+				if name[i] not in identchars:
+					name = name[:i]
+					break
+	_namecache[key] = name
+	return name
+
+# Use the above routine to find a function's name.
+
+def getfuncname(func):
+	return getcodename(func.func_code)

Lib/lib-old/codehack.py

+# A subroutine for extracting a function name from a code object
+# (with cache)
+
+import sys
+from stat import *
+import string
+import os
+import linecache
+
+# Extract the function or class name from a code object.
+# This is a bit of a hack, since a code object doesn't contain
+# the name directly.  So what do we do:
+# - get the filename (which *is* in the code object)
+# - look in the code string to find the first SET_LINENO instruction
+#   (this must be the first instruction)
+# - get the line from the file
+# - if the line starts with 'class' or 'def' (after possible whitespace),
+#   extract the following identifier
+#
+# This breaks apart when the function was read from <stdin>
+# or constructed by exec(), when the file is not accessible,
+# and also when the file has been modified or when a line is
+# continued with a backslash before the function or class name.
+#
+# Because this is a pretty expensive hack, a cache is kept.
+
+SET_LINENO = 127 # The opcode (see "opcode.h" in the Python source)
+identchars = string.letters + string.digits + '_' # Identifier characters
+
+_namecache = {} # The cache
+
+def getcodename(co):
+	key = `co` # arbitrary but uniquely identifying string
+	if _namecache.has_key(key): return _namecache[key]
+	filename = co.co_filename
+	code = co.co_code
+	name = ''
+	if ord(code[0]) == SET_LINENO:
+		lineno = ord(code[1]) | ord(code[2]) << 8
+		line = linecache.getline(filename, lineno)
+		words = string.split(line)
+		if len(words) >= 2 and words[0] in ('def', 'class'):
+			name = words[1]
+			for i in range(len(name)):
+				if name[i] not in identchars:
+					name = name[:i]
+					break
+	_namecache[key] = name
+	return name
+
+# Use the above routine to find a function's name.
+
+def getfuncname(func):
+	return getcodename(func.func_code)

Lib/lib-stdwin/basewin.py

+# basewin.py
+
+import stdwin
+import mainloop
+from stdwinevents import *
+
+class BaseWindow:
+	
+	def init(self, title):
+		self.win = stdwin.open(title)
+		self.win.dispatch = self.dispatch
+		mainloop.register(self.win)
+		return self
+	
+#	def reopen(self):
+#		title = self.win.gettitle()
+#		winpos = self.win.getwinpos()
+#		winsize = self.win.getwinsize()
+#		origin = self.win.getorigin()
+#		docsize = self.win.getdocsize()
+#		mainloop.unregister(self.win)
+#		del self.win.dispatch
+#		self.win.close()
+#		stdwin.setdefwinpos(winpos)
+#		stdwin.setdefwinsize(winsize)
+#		self.win = stdwin.open(title)
+#		stdwin.setdefwinpos(0, 0)
+#		stdwin.setdefwinsize(0, 0)
+#		self.win.setdocsize(docsize)
+#		self.win.setorigin(origin)
+#		self.win.dispatch = self.dispatch
+#		mainloop.register(self.win)
+	
+	def popup(self):
+		if self.win is not stdwin.getactive():
+			self.win.setactive()
+	
+	def close(self):
+		mainloop.unregister(self.win)
+		del self.win.dispatch
+		self.win.close()
+	
+	def dispatch(self, event):
+		type, win, detail = event
+		if type == WE_CHAR:
+			self.char(detail)
+		elif type == WE_COMMAND:
+			self.command(detail)
+		elif type == WE_MOUSE_DOWN:
+			self.mouse_down(detail)
+		elif type == WE_MOUSE_MOVE:
+			self.mouse_move(detail)
+		elif type == WE_MOUSE_UP:
+			self.mouse_up(detail)
+		elif type == WE_DRAW:
+			self.draw(detail)
+		elif type == WE_CLOSE:
+			self.close()
+	
+	def no_op(self, detail):
+		pass
+	char = command = mouse_down = mouse_move = mouse_up = draw = no_op
+	
+	def refreshall(self):
+		self.win.change((-10, 0), (10000, 30000))

Lib/lib-stdwin/srcwin.py

+# srcwin.py -- a source listing window
+
+import stdwin
+from stdwinevents import *
+import basewin
+
+WIDTH = 40
+MAXHEIGHT = 24
+
+class SourceWindow(basewin.BaseWindow):
+	
+	def init(self, filename):
+		self.filename = filename
+		#
+		f = open(self.filename, 'r') # raise exception if not found
+		self.contents = f.read()
+		f.seek(0)
+		self.linecount = len(f.readlines())
+		f.close()
+		#
+		self.lineheight = lh = stdwin.lineheight()
+		self.leftmargin = stdwin.textwidth('00000000')
+		self.rightmargin = 30000 # Infinity
+		self.bottom = lh * self.linecount
+		#
+		stdwin.setdefwinpos(0, 0)
+		width = WIDTH*stdwin.textwidth('0')
+		height = lh*min(MAXHEIGHT, self.linecount)
+		stdwin.setdefwinsize(width, height)
+		self = basewin.BaseWindow.init(self, filename)
+		#
+		self.win.setdocsize(0, self.bottom + lh)
+		self.initeditor()
+		return self
+	
+	def initeditor(self):
+		r = (self.leftmargin, 0), (self.rightmargin, self.bottom)
+		self.editor = self.win.textcreate(r)
+		self.editor.settext(self.contents)
+	
+	def closeeditor(self):
+		self.editor.close()
+	
+	def reopen(self):
+		self.closeeditor()
+		basewin.BaseWindow.reopen(self)
+		self.initeditor()
+	
+	def close(self):
+		self.closeeditor()
+		basewin.BaseWindow.close(self)
+	
+	# Override this method to format line numbers differently
+	def getmark(self, lineno):
+		return `lineno`
+	
+	def dispatch(self, event):
+		if event[0] == WE_NULL: return # Dummy tested by mainloop
+		if event[0] == WE_DRAW or not self.editor.event(event):
+			basewin.BaseWindow.dispatch(self, event)
+	
+	def draw(self, detail):
+		dummy = self.editor.draw(detail)
+		# Draw line numbers
+		(left, top), (right, bottom) = detail
+		topline = top/self.lineheight
+		botline = bottom/self.lineheight + 1
+		botline = min(self.linecount, botline)
+		d = self.win.begindrawing()
+		try:
+			h, v = 0, self.lineheight * topline
+			for lineno in range(topline+1, botline+1):
+				d.text((h, v), self.getmark(lineno))
+				v = v + self.lineheight
+		finally:
+			d.close()
+	
+	def changemark(self, lineno):
+		left = 0
+		top = (lineno-1) * self.lineheight
+		right = self.leftmargin
+		bottom = lineno * self.lineheight
+		d = self.win.begindrawing()
+		try:
+			d.erase((left, top), (right, bottom))
+			d.text((left, top), self.getmark(lineno))
+		finally:
+			d.close()
+
+	def showline(self, lineno):
+		left = 0
+		top = (lineno-1) * self.lineheight
+		right = self.leftmargin
+		bottom = lineno * self.lineheight
+		self.win.show((left, top), (right, bottom))
+
+
+TESTFILE = 'srcwin.py'
+
+def test():
+	import mainloop
+	sw = SourceWindow().init(TESTFILE)
+	mainloop.mainloop()

Lib/lib-stdwin/wdb.py

+# wdb.py -- a window-based Python debugger
+
+import stdwin
+from stdwinevents import *
+import sys
+import basewin
+import bdb
+import repr
+
+WIDTH = 40
+HEIGHT = 8
+
+WdbDone = 'wdb.WdbDone' # Exception to continue execution
+
+
+class Wdb(bdb.Bdb, basewin.BaseWindow): # Window debugger
+	
+	def init(self):
+		self.sourcewindows = {}
+		self.framewindows = {}
+		self = bdb.Bdb.init(self)
+		width = WIDTH*stdwin.textwidth('0')
+		height = HEIGHT*stdwin.lineheight()
+		stdwin.setdefwinsize(width, height)
+		self = basewin.BaseWindow.init(self, '--Stack--')
+		self.closed = 0
+		return self
+	
+	def reset(self):
+		if self.closed: raise RuntimeError, 'already closed'
+		bdb.Bdb.reset(self)
+		self.forget()
+	
+	def forget(self):
+		self.lineno = None
+		self.stack = []
+		self.curindex = 0
+		self.curframe = None
+		for fn in self.sourcewindows.keys():
+			self.sourcewindows[fn].resetlineno()
+	
+	def setup(self, f, t):
+		self.forget()
+		self.stack, self.curindex = self.get_stack(f, t)
+		self.curframe = self.stack[self.curindex][0]
+		# Build a list of current frames
+		cfl = []
+		for f, i in self.stack: cfl.append(f)
+		# Remove deactivated frame windows
+		for name in self.framewindows.keys():
+			fw = self.framewindows[name]
+			if fw.frame not in cfl: fw.close()
+			else: fw.refreshframe()
+		# Refresh the stack window
+		self.refreshstack()
+	
+	# Override Bdb methods (except user_call, for now)
+	
+	def user_line(self, frame):
+		# This function is called when we stop or break at this line
+		self.interaction(frame, None)
+	
+	def user_return(self, frame, return_value):
+		# This function is called when a return trap is set here
+		frame.f_locals['__return__'] = return_value
+		self.settitle('--Return--')
+		self.interaction(frame, None)
+		self.settitle('--Stack--')
+	
+	def user_exception(self, frame, (exc_type, exc_value, exc_traceback)):
+		# This function is called if an exception occurs,
+		# but only if we are to stop at or just below this level
+		frame.f_locals['__exception__'] = exc_type, exc_value
+		self.settitle(exc_type + ': ' + repr.repr(exc_value))
+		self.interaction(frame, exc_traceback)
+		self.settitle('--Stack--')
+	
+	# Change the title
+	
+	def settitle(self, title):
+		self.savetitle = self.win.gettitle()
+		self.win.settitle(title)
+	
+	# General interaction function
+	
+	def interaction(self, frame, traceback):
+		import mainloop
+		self.popup()
+		self.setup(frame, traceback)
+		try:
+			mainloop.mainloop()
+		except WdbDone:
+			pass
+		self.forget()
+	
+	# Functions whose name is do_X for some character X
+	# are callable directly from the keyboard.
+	
+	def do_up(self):
+		if self.curindex == 0:
+			stdwin.fleep()
+		else:
+			self.curindex = self.curindex - 1
+			self.curframe = self.stack[self.curindex][0]
+			self.refreshstack()
+	do_u = do_up
+	
+	def do_down(self):
+		if self.curindex + 1 == len(self.stack):
+			stdwin.fleep()
+		else:
+			self.curindex = self.curindex + 1
+			self.curframe = self.stack[self.curindex][0]
+			self.refreshstack()
+	do_d = do_down
+	
+	def do_step(self):
+		self.set_step()
+		raise WdbDone
+	do_s = do_step
+	
+	def do_next(self):
+		self.set_next(self.curframe)
+		raise WdbDone
+	do_n = do_next
+	
+	def do_return(self):
+		self.set_return(self.curframe)
+		raise WdbDone
+	do_r = do_return
+	
+	def do_continue(self):
+		self.set_continue()
+		raise WdbDone
+	do_c = do_cont = do_continue
+	
+	def do_quit(self):
+		self.close()
+		raise WdbDone
+	do_q = do_quit
+	
+	def do_list(self):
+		fn = self.curframe.f_code.co_filename
+		if not self.sourcewindows.has_key(fn):
+			import wdbsrcwin
+			try:
+				self.sourcewindows[fn] = \
+					wdbsrcwin.DebuggerSourceWindow(). \
+					init(self, fn)
+			except IOError:
+				stdwin.fleep()
+				return
+		w = self.sourcewindows[fn]
+		lineno = self.stack[self.curindex][1]
+		w.setlineno(lineno)
+		w.popup()
+	do_l = do_list
+	
+	def do_frame(self):
+		name = 'locals' + `self.curframe`[16:-1]
+		if self.framewindows.has_key(name):
+			self.framewindows[name].popup()
+		else:
+			import wdbframewin
+			self.framewindows[name] = \
+				wdbframewin.FrameWindow().init(self, \
+					self.curframe, \
+					self.curframe.f_locals, name)
+	do_f = do_frame
+	
+	def do_globalframe(self):
+		name = 'globals' + `self.curframe`[16:-1]
+		if self.framewindows.has_key(name):
+			self.framewindows[name].popup()
+		else:
+			import wdbframewin
+			self.framewindows[name] = \
+				wdbframewin.FrameWindow().init(self, \
+					self.curframe, \
+					self.curframe.f_globals, name)
+	do_g = do_globalframe
+	
+	# Link between the debugger and the window
+	
+	def refreshstack(self):
+		height = stdwin.lineheight() * (1 + len(self.stack))
+		self.win.setdocsize((0, height))
+		self.refreshall() # XXX be more subtle later
+		# Also pass the information on to the source windows
+		filename = self.curframe.f_code.co_filename
+		lineno = self.curframe.f_lineno
+		for fn in self.sourcewindows.keys():
+			w = self.sourcewindows[fn]
+			if fn == filename:
+				w.setlineno(lineno)
+			else:
+				w.resetlineno()
+	
+	# The remaining methods override BaseWindow methods
+	
+	def close(self):
+		if not self.closed:
+			basewin.BaseWindow.close(self)
+		self.closed = 1
+		for key in self.sourcewindows.keys():
+			self.sourcewindows[key].close()
+		for key in self.framewindows.keys():
+			self.framewindows[key].close()
+		self.set_quit()
+	
+	def char(self, detail):
+		try:
+			func = eval('self.do_' + detail)
+		except (AttributeError, SyntaxError):
+			stdwin.fleep()
+			return
+		func()
+	
+	def command(self, detail):
+		if detail == WC_UP:
+			self.do_up()
+		elif detail == WC_DOWN:
+			self.do_down()
+	
+	def mouse_down(self, detail):
+		(h, v), clicks, button, mask = detail
+		i = v / stdwin.lineheight()
+		if 0 <= i < len(self.stack):
+			if i != self.curindex:
+				self.curindex = i
+				self.curframe = self.stack[self.curindex][0]
+				self.refreshstack()
+			elif clicks == 2:
+				self.do_frame()
+		else:
+			stdwin.fleep()
+	
+	def draw(self, detail):
+		import linecache, codehack, string
+		d = self.win.begindrawing()
+		try:
+			h, v = 0, 0
+			for f, lineno in self.stack:
+				fn = f.f_code.co_filename
+				if f is self.curframe:
+					s = '> '
+				else:
+					s = '  '
+				s = s + fn + '(' + `lineno` + ')'
+				s = s + codehack.getcodename(f.f_code)
+				if f.f_locals.has_key('__args__'):
+					args = f.f_locals['__args__']
+					if args is not None:
+						s = s + repr.repr(args)
+				if f.f_locals.has_key('__return__'):
+					rv = f.f_locals['__return__']
+					s = s + '->'
+					s = s + repr.repr(rv)
+				line = linecache.getline(fn, lineno)
+				if line: s = s + ': ' + string.strip(line)
+				d.text((h, v), s)
+				v = v + d.lineheight()
+		finally:
+			d.close()
+
+
+def run(statement):
+	x = Wdb().init()
+	try: x.run(statement)
+	finally: x.close()
+
+def runctx(statement, globals, locals):
+	x = Wdb().init()
+	try: x.runctx(statement, globals, locals)
+	finally: x.close()
+
+TESTCMD = 'import x; x.main()'
+
+def test():
+	import linecache
+	linecache.checkcache()
+	run(TESTCMD)

Lib/lib-stdwin/wdbframewin.py

+# wdb.py -- a window-based Python debugger
+
+import stdwin
+from stdwinevents import *
+import basewin
+import sys
+
+WIDTH = 40
+MAXHEIGHT = 16
+
+class FrameWindow(basewin.BaseWindow):
+
+	def init(self, debugger, frame, dict, name):
+		self.debugger = debugger
+		self.frame = frame # Not used except for identity tests
+		self.dict = dict
+		self.name = name
+		nl = max(4, len(self.dict))
+		nl = min(nl, MAXHEIGHT)
+		width = WIDTH*stdwin.textwidth('0')
+		height = nl*stdwin.lineheight()
+		stdwin.setdefwinsize(width, height)
+		self = basewin.BaseWindow.init(self, '--Frame ' + name + '--')
+		self.initeditor()
+		self.displaylist = ['>>>', '', '-'*WIDTH]
+		self.refreshframe()
+		return self
+	
+	def initeditor(self):
+		r = (stdwin.textwidth('>>> '), 0), (30000, stdwin.lineheight())
+		self.editor = self.win.textcreate(r)
+	
+	def closeeditor(self):
+		self.editor.close()
+	
+	def dispatch(self, event):
+		type, win, detail = event
+		if type == WE_NULL: return # Dummy tested by mainloop
+		if type in (WE_DRAW, WE_COMMAND) \
+				or not self.editor.event(event):
+			basewin.BaseWindow.dispatch(self, event)
+	
+	def close(self):
+		del self.debugger.framewindows[self.name]
+		del self.debugger, self.dict
+		self.closeeditor()
+		basewin.BaseWindow.close(self)
+	
+	def command(self, detail):
+		if detail == WC_RETURN:
+			self.re_eval()
+		else:
+			dummy = self.editor.event(WE_COMMAND, \
+						self.win, detail)
+	
+	def re_eval(self):
+		import string, repr
+		expr = string.strip(self.editor.gettext())
+		if expr == '':
+			output = ''
+		else:
+			globals = self.frame.f_globals
+			locals = self.frame.f_locals
+			try:
+				value = eval(expr, globals, locals)
+				output = repr.repr(value)
+			except:
+				output = sys.exc_type + ': ' + `sys.exc_value`
+		self.displaylist[1] = output
+		lh = stdwin.lineheight()
+		r = (-10, 0), (30000, 2*lh)
+		self.win.change(r)
+		self.editor.setfocus(0, len(expr))
+	
+	def draw(self, detail):
+		(left, top), (right, bottom) = detail
+		dummy = self.editor.draw(detail)
+		d = self.win.begindrawing()
+		try:
+			lh = d.lineheight()
+			h, v = 0, 0
+			for line in self.displaylist:
+				if v+lh > top and v < bottom:
+					d.text((h, v), line)
+				v = v + lh
+		finally:
+			d.close()
+	
+	def refreshframe(self):
+		import repr
+		del self.displaylist[3:]
+		self.re_eval()
+		names = self.dict.keys()
+		for key, label in ('__args__', 'Args: '), \
+				  ('__return__', 'Return: '):
+			if self.dict.has_key(key):
+				names.remove(key)
+				value = self.dict[key]
+				label = label + repr.repr(value)
+			self.displaylist.append(label)
+		names.sort()
+		for name in names:
+			value = self.dict[name]
+			line = name + ' = ' + repr.repr(value)
+			self.displaylist.append(line)
+		self.win.setdocsize(0, \
+			stdwin.lineheight() * len(self.displaylist))
+		self.refreshall() # XXX Be more subtle later

Lib/lib-stdwin/wdbsrcwin.py

+# wdbsrcwin.py -- source window for wdb
+
+import stdwin
+from stdwinevents import *
+import srcwin
+
+
+class DebuggerSourceWindow(srcwin.SourceWindow):
+	
+	def init(self, debugger, filename):
+		self.debugger = debugger
+		self.curlineno = 0
+		self.focus = 0
+		return srcwin.SourceWindow.init(self, filename)
+	
+	def close(self):
+		del self.debugger.sourcewindows[self.filename]
+		del self.debugger
+		srcwin.SourceWindow.close(self)
+	
+	def dispatch(self, event):
+		type, win, detail = event
+		if type == WE_CHAR:
+			self.char(detail)
+		elif type == WE_COMMAND:
+			self.command(detail)
+		elif type == WE_MOUSE_DOWN:
+			self.mouse_down(detail)
+		else:
+			srcwin.SourceWindow.dispatch(self, event)
+	
+	def char(self, detail):
+		self.debugger.char(detail)
+	
+	def command(self, detail):
+		self.debugger.command(detail)
+	
+	def mouse_down(self, detail):
+		(h, v), clicks, button, mask = detail
+		if h >= self.leftmargin:
+			srcwin.SourceWindow.dispatch(self, \
+				(WE_MOUSE_DOWN, self.win, detail))
+			return
+		lineno = v/self.lineheight + 1
+		if 1 <= lineno <= self.linecount:
+			if self.debugger.get_break(self.filename, lineno):
+				f = self.debugger.clear_break
+			else:
+				f = self.debugger.set_break
+			err = f(self.filename, lineno)
+			if err: stdwin.message(err)
+			else: self.changemark(lineno)
+		else:
+			stdwin.fleep()
+	
+	def getmark(self, lineno):
+		s = `lineno`
+		if lineno == self.focus:
+			s = '[' + s + ']'
+		else:
+			s = ' ' + s + ' '
+		if lineno == self.curlineno:
+			s = s + '->'
+		else:
+			s = s + '  '
+		br = self.debugger.breaks
+		if br.has_key(self.filename) and lineno in br[self.filename]:
+			s = s + 'B'
+		else:
+			s = s + ' '
+		return s
+	
+	def setlineno(self, newlineno):
+		if newlineno != self.curlineno:
+			oldlineno = self.curlineno
+			self.curlineno = newlineno
+			self.changemark(oldlineno)
+			self.changemark(newlineno)
+		if newlineno != 0:
+			self.showline(newlineno)
+	
+	def resetlineno(self):
+		self.setlineno(0)
+	
+	def setfocus(self, newfocus):
+		if newfocus != self.focus:
+			oldfocus = self.focus
+			self.focus = newfocus
+			self.changemark(oldfocus)
+			self.changemark(newfocus)
+		if newfocus != 0:
+			self.showline(newfocus)
+	
+	def resetfocus(self):
+		self.setfocus(0)
+
+# XXX Should get rid of focus stuff again

Lib/repr.py

+# Redo the `...` (representation) but with limits on most sizes.
+
+import string
+
+class Repr:
+	def init(self):
+		self.maxlevel = 6
+		self.maxtuple = 6
+		self.maxlist = 6
+		self.maxdict = 4
+		self.maxstring = 30
+		self.maxlong = 40
+		self.maxother = 20
+		return self
+	def repr(self, x):
+		return self.repr1(x, self.maxlevel)
+	def repr1(self, x, level):
+		typename = `type(x)`[7:-2] # "<type '......'>"
+		if ' ' in typename:
+			parts = string.split(typename)
+			typename = string.joinfields(parts, '_')
+		try:
+			f = eval('self.repr_' + typename)
+		except AttributeError:
+			s = `x`
+			if len(s) > self.maxother:
+				i = max(0, (self.maxother-3)/2)
+				j = max(0, self.maxother-3-i)
+				s = s[:i] + '...' + s[len(s)-j:]
+			return s
+		return f(x, level)
+	def repr_tuple(self, x, level):
+		n = len(x)
+		if n == 0: return '()'
+		if level <= 0: return '(...)'
+		s = ''
+		for i in range(min(n, self.maxtuple)):
+			if s: s = s + ', '
+			s = s + self.repr1(x[i], level-1)
+		if n > self.maxtuple: s = s + ', ...'
+		elif n == 1: s = s + ','
+		return '(' + s + ')'
+	def repr_list(self, x, level):
+		n = len(x)
+		if n == 0: return '[]'
+		if level <= 0: return '[...]'
+		s = ''
+		for i in range(min(n, self.maxlist)):
+			if s: s = s + ', '
+			s = s + self.repr1(x[i], level-1)
+		if n > self.maxlist: s = s + ', ...'
+		return '[' + s + ']'
+	def repr_dictionary(self, x, level):
+		n = len(x)
+		if n == 0: return '{}'
+		if level <= 0: return '{...}'
+		s = ''
+		keys = x.keys()
+		keys.sort()
+		for i in range(min(n, self.maxdict)):
+			if s: s = s + ', '
+			key = keys[i]
+			s = s + self.repr1(key, level-1)
+			s = s + ': ' + self.repr1(x[key], level-1)
+		if n > self.maxlist: s = s + ', ...'
+		return '{' + s + '}'
+	def repr_string(self, x, level):
+		s = `x[:self.maxstring]`
+		if len(s) > self.maxstring:
+			i = max(0, (self.maxstring-3)/2)
+			j = max(0, self.maxstring-3-i)
+			s = s[:i] + '...' + s[len(s)-j:]
+		return s
+	def repr_long_int(self, x, level):
+		s = `x` # XXX Hope this isn't too slow...
+		if len(s) > self.maxlong:
+			i = max(0, (self.maxlong-3)/2)
+			j = max(0, self.maxlong-3-i)
+			s = s[:i] + '...' + s[len(s)-j:]
+		return s
+
+aRepr = Repr().init()
+repr = aRepr.repr

Lib/stdwin/basewin.py

+# basewin.py
+
+import stdwin
+import mainloop
+from stdwinevents import *
+
+class BaseWindow:
+	
+	def init(self, title):
+		self.win = stdwin.open(title)
+		self.win.dispatch = self.dispatch
+		mainloop.register(self.win)
+		return self
+	
+#	def reopen(self):
+#		title = self.win.gettitle()
+#		winpos = self.win.getwinpos()
+#		winsize = self.win.getwinsize()
+#		origin = self.win.getorigin()
+#		docsize = self.win.getdocsize()
+#		mainloop.unregister(self.win)
+#		del self.win.dispatch
+#		self.win.close()
+#		stdwin.setdefwinpos(winpos)
+#		stdwin.setdefwinsize(winsize)
+#		self.win = stdwin.open(title)
+#		stdwin.setdefwinpos(0, 0)
+#		stdwin.setdefwinsize(0, 0)
+#		self.win.setdocsize(docsize)
+#		self.win.setorigin(origin)
+#		self.win.dispatch = self.dispatch
+#		mainloop.register(self.win)
+	
+	def popup(self):
+		if self.win is not stdwin.getactive():
+			self.win.setactive()
+	
+	def close(self):
+		mainloop.unregister(self.win)
+		del self.win.dispatch
+		self.win.close()
+	
+	def dispatch(self, event):
+		type, win, detail = event
+		if type == WE_CHAR:
+			self.char(detail)
+		elif type == WE_COMMAND:
+			self.command(detail)
+		elif type == WE_MOUSE_DOWN:
+			self.mouse_down(detail)
+		elif type == WE_MOUSE_MOVE:
+			self.mouse_move(detail)
+		elif type == WE_MOUSE_UP:
+			self.mouse_up(detail)
+		elif type == WE_DRAW:
+			self.draw(detail)
+		elif type == WE_CLOSE:
+			self.close()
+	
+	def no_op(self, detail):
+		pass
+	char = command = mouse_down = mouse_move = mouse_up = draw = no_op
+	
+	def refreshall(self):
+		self.win.change((-10, 0), (10000, 30000))

Lib/stdwin/srcwin.py

+# srcwin.py -- a source listing window
+
+import stdwin
+from stdwinevents import *
+import basewin
+
+WIDTH = 40
+MAXHEIGHT = 24
+
+class SourceWindow(basewin.BaseWindow):
+	
+	def init(self, filename):
+		self.filename = filename
+		#
+		f = open(self.filename, 'r') # raise exception if not found
+		self.contents = f.read()
+		f.seek(0)
+		self.linecount = len(f.readlines())
+		f.close()
+		#
+		self.lineheight = lh = stdwin.lineheight()
+		self.leftmargin = stdwin.textwidth('00000000')
+		self.rightmargin = 30000 # Infinity
+		self.bottom = lh * self.linecount
+		#
+		stdwin.setdefwinpos(0, 0)
+		width = WIDTH*stdwin.textwidth('0')
+		height = lh*min(MAXHEIGHT, self.linecount)
+		stdwin.setdefwinsize(width, height)
+		self = basewin.BaseWindow.init(self, filename)
+		#
+		self.win.setdocsize(0, self.bottom + lh)
+		self.initeditor()
+		return self
+	
+	def initeditor(self):
+		r = (self.leftmargin, 0), (self.rightmargin, self.bottom)
+		self.editor = self.win.textcreate(r)
+		self.editor.settext(self.contents)
+	
+	def closeeditor(self):
+		self.editor.close()
+	
+	def reopen(self):
+		self.closeeditor()
+		basewin.BaseWindow.reopen(self)
+		self.initeditor()
+	
+	def close(self):
+		self.closeeditor()
+		basewin.BaseWindow.close(self)
+	
+	# Override this method to format line numbers differently
+	def getmark(self, lineno):
+		return `lineno`
+	
+	def dispatch(self, event):
+		if event[0] == WE_NULL: return # Dummy tested by mainloop
+		if event[0] == WE_DRAW or not self.editor.event(event):
+			basewin.BaseWindow.dispatch(self, event)
+	
+	def draw(self, detail):
+		dummy = self.editor.draw(detail)
+		# Draw line numbers
+		(left, top), (right, bottom) = detail
+		topline = top/self.lineheight
+		botline = bottom/self.lineheight + 1
+		botline = min(self.linecount, botline)
+		d = self.win.begindrawing()
+		try:
+			h, v = 0, self.lineheight * topline
+			for lineno in range(topline+1, botline+1):
+				d.text((h, v), self.getmark(lineno))
+				v = v + self.lineheight
+		finally:
+			d.close()
+	
+	def changemark(self, lineno):
+		left = 0
+		top = (lineno-1) * self.lineheight
+		right = self.leftmargin
+		bottom = lineno * self.lineheight
+		d = self.win.begindrawing()
+		try:
+			d.erase((left, top), (right, bottom))
+			d.text((left, top), self.getmark(lineno))
+		finally:
+			d.close()
+
+	def showline(self, lineno):
+		left = 0
+		top = (lineno-1) * self.lineheight
+		right = self.leftmargin
+		bottom = lineno * self.lineheight
+		self.win.show((left, top), (right, bottom))
+
+
+TESTFILE = 'srcwin.py'
+
+def test():
+	import mainloop
+	sw = SourceWindow().init(TESTFILE)
+	mainloop.mainloop()

Lib/stdwin/wdb.py

+# wdb.py -- a window-based Python debugger
+
+import stdwin
+from stdwinevents import *
+import sys
+import basewin
+import bdb
+import repr
+
+WIDTH = 40
+HEIGHT = 8
+
+WdbDone = 'wdb.WdbDone' # Exception to continue execution
+
+
+class Wdb(bdb.Bdb, basewin.BaseWindow): # Window debugger
+	
+	def init(self):
+		self.sourcewindows = {}
+		self.framewindows = {}
+		self = bdb.Bdb.init(self)
+		width = WIDTH*stdwin.textwidth('0')
+		height = HEIGHT*stdwin.lineheight()
+		stdwin.setdefwinsize(width, height)
+		self = basewin.BaseWindow.init(self, '--Stack--')
+		self.closed = 0
+		return self
+	
+	def reset(self):
+		if self.closed: raise RuntimeError, 'already closed'
+		bdb.Bdb.reset(self)
+		self.forget()
+	
+	def forget(self):
+		self.lineno = None
+		self.stack = []
+		self.curindex = 0
+		self.curframe = None
+		for fn in self.sourcewindows.keys():
+			self.sourcewindows[fn].resetlineno()
+	
+	def setup(self, f, t):
+		self.forget()
+		self.stack, self.curindex = self.get_stack(f, t)
+		self.curframe = self.stack[self.curindex][0]
+		# Build a list of current frames
+		cfl = []
+		for f, i in self.stack: cfl.append(f)
+		# Remove deactivated frame windows
+		for name in self.framewindows.keys():
+			fw = self.framewindows[name]
+			if fw.frame not in cfl: fw.close()
+			else: fw.refreshframe()
+		# Refresh the stack window
+		self.refreshstack()
+	
+	# Override Bdb methods (except user_call, for now)
+	
+	def user_line(self, frame):
+		# This function is called when we stop or break at this line
+		self.interaction(frame, None)
+	
+	def user_return(self, frame, return_value):
+		# This function is called when a return trap is set here
+		frame.f_locals['__return__'] = return_value
+		self.settitle('--Return--')
+		self.interaction(frame, None)
+		self.settitle('--Stack--')
+	
+	def user_exception(self, frame, (exc_type, exc_value, exc_traceback)):
+		# This function is called if an exception occurs,
+		# but only if we are to stop at or just below this level
+		frame.f_locals['__exception__'] = exc_type, exc_value
+		self.settitle(exc_type + ': ' + repr.repr(exc_value))
+		self.interaction(frame, exc_traceback)
+		self.settitle('--Stack--')
+	
+	# Change the title
+	
+	def settitle(self, title):
+		self.savetitle = self.win.gettitle()
+		self.win.settitle(title)
+	
+	# General interaction function
+	
+	def interaction(self, frame, traceback):
+		import mainloop
+		self.popup()
+		self.setup(frame, traceback)
+		try:
+			mainloop.mainloop()
+		except WdbDone:
+			pass
+		self.forget()
+	
+	# Functions whose name is do_X for some character X
+	# are callable directly from the keyboard.
+	
+	def do_up(self):
+		if self.curindex == 0:
+			stdwin.fleep()
+		else:
+			self.curindex = self.curindex - 1
+			self.curframe = self.stack[self.curindex][0]
+			self.refreshstack()
+	do_u = do_up
+	
+	def do_down(self):
+		if self.curindex + 1 == len(self.stack):
+			stdwin.fleep()
+		else:
+			self.curindex = self.curindex + 1
+			self.curframe = self.stack[self.curindex][0]
+			self.refreshstack()
+	do_d = do_down
+	
+	def do_step(self):
+		self.set_step()
+		raise WdbDone
+	do_s = do_step
+	
+	def do_next(self):
+		self.set_next(self.curframe)
+		raise WdbDone
+	do_n = do_next
+	
+	def do_return(self):
+		self.set_return(self.curframe)
+		raise WdbDone
+	do_r = do_return
+	
+	def do_continue(self):
+		self.set_continue()
+		raise WdbDone
+	do_c = do_cont = do_continue
+	
+	def do_quit(self):
+		self.close()
+		raise WdbDone
+	do_q = do_quit
+	
+	def do_list(self):
+		fn = self.curframe.f_code.co_filename
+		if not self.sourcewindows.has_key(fn):
+			import wdbsrcwin
+			try:
+				self.sourcewindows[fn] = \
+					wdbsrcwin.DebuggerSourceWindow(). \
+					init(self, fn)
+			except IOError:
+				stdwin.fleep()
+				return
+		w = self.sourcewindows[fn]
+		lineno = self.stack[self.curindex][1]
+		w.setlineno(lineno)
+		w.popup()
+	do_l = do_list
+	
+	def do_frame(self):
+		name = 'locals' + `self.curframe`[16:-1]
+		if self.framewindows.has_key(name):
+			self.framewindows[name].popup()
+		else:
+			import wdbframewin
+			self.framewindows[name] = \
+				wdbframewin.FrameWindow().init(self, \
+					self.curframe, \
+					self.curframe.f_locals, name)
+	do_f = do_frame
+	
+	def do_globalframe(self):
+		name = 'globals' + `self.curframe`[16:-1]
+		if self.framewindows.has_key(name):
+			self.framewindows[name].popup()
+		else:
+			import wdbframewin
+			self.framewindows[name] = \
+				wdbframewin.FrameWindow().init(self, \
+					self.curframe, \
+					self.curframe.f_globals, name)
+	do_g = do_globalframe
+	
+	# Link between the debugger and the window
+	
+	def refreshstack(self):
+		height = stdwin.lineheight() * (1 + len(self.stack))
+		self.win.setdocsize((0, height))
+		self.refreshall() # XXX be more subtle later
+		# Also pass the information on to the source windows
+		filename = self.curframe.f_code.co_filename
+		lineno = self.curframe.f_lineno
+		for fn in self.sourcewindows.keys():
+			w = self.sourcewindows[fn]
+			if fn == filename:
+				w.setlineno(lineno)
+			else:
+				w.resetlineno()
+	
+	# The remaining methods override BaseWindow methods
+	
+	def close(self):
+		if not self.closed:
+			basewin.BaseWindow.close(self)
+		self.closed = 1
+		for key in self.sourcewindows.keys():
+			self.sourcewindows[key].close()
+		for key in self.framewindows.keys():
+			self.framewindows[key].close()
+		self.set_quit()
+	
+	def char(self, detail):
+		try:
+			func = eval('self.do_' + detail)
+		except (AttributeError, SyntaxError):
+			stdwin.fleep()
+			return
+		func()
+	
+	def command(self, detail):
+		if detail == WC_UP:
+			self.do_up()
+		elif detail == WC_DOWN:
+			self.do_down()
+	
+	def mouse_down(self, detail):
+		(h, v), clicks, button, mask = detail
+		i = v / stdwin.lineheight()
+		if 0 <= i < len(self.stack):
+			if i != self.curindex:
+				self.curindex = i
+				self.curframe = self.stack[self.curindex][0]
+				self.refreshstack()
+			elif clicks == 2:
+				self.do_frame()
+		else:
+			stdwin.fleep()
+	
+	def draw(self, detail):
+		import linecache, codehack, string
+		d = self.win.begindrawing()
+		try:
+			h, v = 0, 0
+			for f, lineno in self.stack:
+				fn = f.f_code.co_filename
+				if f is self.curframe:
+					s = '> '
+				else:
+					s = '  '
+				s = s + fn + '(' + `lineno` + ')'
+				s = s + codehack.getcodename(f.f_code)
+				if f.f_locals.has_key('__args__'):
+					args = f.f_locals['__args__']
+					if args is not None:
+						s = s + repr.repr(args)
+				if f.f_locals.has_key('__return__'):
+					rv = f.f_locals['__return__']
+					s = s + '->'
+					s = s + repr.repr(rv)
+				line = linecache.getline(fn, lineno)
+				if line: s = s + ': ' + string.strip(line)
+				d.text((h, v), s)
+				v = v + d.lineheight()
+		finally:
+			d.close()
+
+
+def run(statement):
+	x = Wdb().init()
+	try: x.run(statement)
+	finally: x.close()
+
+def runctx(statement, globals, locals):
+	x = Wdb().init()
+	try: x.runctx(statement, globals, locals)
+	finally: x.close()
+
+TESTCMD = 'import x; x.main()'
+
+def test():
+	import linecache
+	linecache.checkcache()
+	run(TESTCMD)

Lib/stdwin/wdbframewin.py

+# wdb.py -- a window-based Python debugger
+
+import stdwin
+from stdwinevents import *
+import basewin
+import sys
+
+WIDTH = 40
+MAXHEIGHT = 16
+
+class FrameWindow(basewin.BaseWindow):
+
+	def init(self, debugger, frame, dict, name):
+		self.debugger = debugger
+		self.frame = frame # Not used except for identity tests
+		self.dict = dict
+		self.name = name
+		nl = max(4, len(self.dict))
+		nl = min(nl, MAXHEIGHT)
+		width = WIDTH*stdwin.textwidth('0')
+		height = nl*stdwin.lineheight()
+		stdwin.setdefwinsize(width, height)
+		self = basewin.BaseWindow.init(self, '--Frame ' + name + '--')
+		self.initeditor()
+		self.displaylist = ['>>>', '', '-'*WIDTH]
+		self.refreshframe()
+		return self
+	
+	def initeditor(self):
+		r = (stdwin.textwidth('>>> '), 0), (30000, stdwin.lineheight())
+		self.editor = self.win.textcreate(r)
+	
+	def closeeditor(self):
+		self.editor.close()
+	
+	def dispatch(self, event):
+		type, win, detail = event
+		if type == WE_NULL: return # Dummy tested by mainloop
+		if type in (WE_DRAW, WE_COMMAND) \
+				or not self.editor.event(event):
+			basewin.BaseWindow.dispatch(self, event)
+	
+	def close(self):
+		del self.debugger.framewindows[self.name]
+		del self.debugger, self.dict
+		self.closeeditor()
+		basewin.BaseWindow.close(self)
+	
+	def command(self, detail):
+		if detail == WC_RETURN:
+			self.re_eval()
+		else:
+			dummy = self.editor.event(WE_COMMAND, \
+						self.win, detail)
+	
+	def re_eval(self):
+		import string, repr
+		expr = string.strip(self.editor.gettext())
+		if expr == '':
+			output = ''
+		else:
+			globals = self.frame.f_globals
+			locals = self.frame.f_locals
+			try:
+				value = eval(expr, globals, locals)
+				output = repr.repr(value)
+			except:
+				output = sys.exc_type + ': ' + `sys.exc_value`
+		self.displaylist[1] = output
+		lh = stdwin.lineheight()
+		r = (-10, 0), (30000, 2*lh)
+		self.win.change(r)
+		self.editor.setfocus(0, len(expr))
+	
+	def draw(self, detail):
+		(left, top), (right, bottom) = detail
+		dummy = self.editor.draw(detail)
+		d = self.win.begindrawing()
+		try:
+			lh = d.lineheight()
+			h, v = 0, 0
+			for line in self.displaylist:
+				if v+lh > top and v < bottom:
+					d.text((h, v), line)
+				v = v + lh
+		finally:
+			d.close()
+	
+	def refreshframe(self):
+		import repr
+		del self.displaylist[3:]
+		self.re_eval()
+		names = self.dict.keys()
+		for key, label in ('__args__', 'Args: '), \
+				  ('__return__', 'Return: '):
+			if self.dict.has_key(key):
+				names.remove(key)
+				value = self.dict[key]
+				label = label + repr.repr(value)
+			self.displaylist.append(label)
+		names.sort()
+		for name in names:
+			value = self.dict[name]
+			line = name + ' = ' + repr.repr(value)
+			self.displaylist.append(line)
+		self.win.setdocsize(0, \
+			stdwin.lineheight() * len(self.displaylist))
+		self.refreshall() # XXX Be more subtle later

Lib/stdwin/wdbsrcwin.py

+# wdbsrcwin.py -- source window for wdb
+
+import stdwin
+from stdwinevents import *
+import srcwin
+
+
+class DebuggerSourceWindow(srcwin.SourceWindow):
+	
+	def init(self, debugger, filename):
+		self.debugger = debugger
+		self.curlineno = 0
+		self.focus = 0
+		return srcwin.SourceWindow.init(self, filename)
+	
+	def close(self):
+		del self.debugger.sourcewindows[self.filename]
+		del self.debugger
+		srcwin.SourceWindow.close(self)
+	
+	def dispatch(self, event):
+		type, win, detail = event
+		if type == WE_CHAR:
+			self.char(detail)
+		elif type == WE_COMMAND:
+			self.command(detail)
+		elif type == WE_MOUSE_DOWN:
+			self.mouse_down(detail)
+		else:
+			srcwin.SourceWindow.dispatch(self, event)
+	
+	def char(self, detail):
+		self.debugger.char(detail)
+	
+	def command(self, detail):
+		self.debugger.command(detail)
+	
+	def mouse_down(self, detail):
+		(h, v), clicks, button, mask = detail
+		if h >= self.leftmargin:
+			srcwin.SourceWindow.dispatch(self, \
+				(WE_MOUSE_DOWN, self.win, detail))
+			return
+		lineno = v/self.lineheight + 1
+		if 1 <= lineno <= self.linecount:
+			if self.debugger.get_break(self.filename, lineno):
+				f = self.debugger.clear_break
+			else:
+				f = self.debugger.set_break
+			err = f(self.filename, lineno)
+			if err: stdwin.message(err)
+			else: self.changemark(lineno)
+		else:
+			stdwin.fleep()
+	
+	def getmark(self, lineno):
+		s = `lineno`
+		if lineno == self.focus:
+			s = '[' + s + ']'
+		else:
+			s = ' ' + s + ' '
+		if lineno == self.curlineno:
+			s = s + '->'
+		else:
+			s = s + '  '
+		br = self.debugger.breaks
+		if br.has_key(self.filename) and lineno in br[self.filename]:
+			s = s + 'B'
+		else:
+			s = s + ' '
+		return s
+	
+	def setlineno(self, newlineno):
+		if newlineno != self.curlineno:
+			oldlineno = self.curlineno
+			self.curlineno = newlineno
+			self.changemark(oldlineno)
+			self.changemark(newlineno)
+		if newlineno != 0:
+			self.showline(newlineno)
+	
+	def resetlineno(self):
+		self.setlineno(0)
+	
+	def setfocus(self, newfocus):
+		if newfocus != self.focus:
+			oldfocus = self.focus
+			self.focus = newfocus
+			self.changemark(oldfocus)
+			self.changemark(newfocus)
+		if newfocus != 0:
+			self.showline(newfocus)
+	
+	def resetfocus(self):
+		self.setfocus(0)
+
+# XXX Should get rid of focus stuff again