file=None, line=None):

if file is None:

file = warning_stream

try:

file.write(warnings.formatwarning(message, category, filename,

lineno, line=line))

except IOError:

"""Format warnings the IDLE way"""

s = "\nWarning (from warnings module):\n"

s += ' File \"%s\", line %s\n' % (filename, lineno)

if line is None:

line = linecache.getline(filename, lineno)

line = line.strip()

if line:

s += " %s\n" % line

s += "%s: %s\n>>> " % (category.__name__, message)

orig_checkcache=linecache.checkcache):

"""Extend linecache.checkcache to preserve the <pyshell#...> entries

cache = linecache.cache

save = {}

for key in list(cache):

if key[:1] + key[-1:] == '<>':

save[key] = cache.pop(key)

orig_checkcache(filename)

"Regular text edit window in IDLE, supports breakpoints"

def __init__(self, *args):

self.breakpoints = []

EditorWindow.__init__(self, *args)

self.text.bind("<<set-breakpoint-here>>", self.set_breakpoint_here)

self.text.bind("<<clear-breakpoint-here>>", self.clear_breakpoint_here)

self.text.bind("<<open-python-shell>>", self.flist.open_shell)

self.breakpointPath = os.path.join(idleConf.GetUserCfgDir(),

'breakpoints.lst')

# whenever a file is changed, restore breakpoints

if self.io.filename: self.restore_file_breaks()

def filename_changed_hook(old_hook=self.io.filename_change_hook,

self=self):

self.restore_file_breaks()

old_hook()

self.io.set_filename_change_hook(filename_changed_hook)

rmenu_specs = [

("Cut", "<<cut>>", "rmenu_check_cut"),

("Copy", "<<copy>>", "rmenu_check_copy"),

("Paste", "<<paste>>", "rmenu_check_paste"),

("Set Breakpoint", "<<set-breakpoint-here>>", None),

("Clear Breakpoint", "<<clear-breakpoint-here>>", None)

]

def set_breakpoint(self, lineno):

text = self.text

filename = self.io.filename

text.tag_add("BREAK", "%d.0" % lineno, "%d.0" % (lineno+1))

try:

i = self.breakpoints.index(lineno)

except ValueError: # only add if missing, i.e. do once

self.breakpoints.append(lineno)

try: # update the subprocess debugger

debug = self.flist.pyshell.interp.debugger

debug.set_breakpoint_here(filename, lineno)

except: # but debugger may not be active right now....

pass

def set_breakpoint_here(self, event=None):

text = self.text

filename = self.io.filename

if not filename:

text.bell()

return

lineno = int(float(text.index("insert")))

self.set_breakpoint(lineno)

def clear_breakpoint_here(self, event=None):

text = self.text

filename = self.io.filename

if not filename:

text.bell()

return

lineno = int(float(text.index("insert")))

try:

self.breakpoints.remove(lineno)

except:

pass

text.tag_remove("BREAK", "insert linestart",\

"insert lineend +1char")

try:

debug = self.flist.pyshell.interp.debugger

debug.clear_breakpoint_here(filename, lineno)

except:

pass

def clear_file_breaks(self):

if self.breakpoints:

text = self.text

filename = self.io.filename

if not filename:

text.bell()

return

self.breakpoints = []

text.tag_remove("BREAK", "1.0", END)

try:

debug = self.flist.pyshell.interp.debugger

debug.clear_file_breaks(filename)

except:

pass

def store_file_breaks(self):

"Save breakpoints when file is saved"

# XXX 13 Dec 2002 KBK Currently the file must be saved before it can

# be run. The breaks are saved at that time. If we introduce

# a temporary file save feature the save breaks functionality

# needs to be re-verified, since the breaks at the time the

# temp file is created may differ from the breaks at the last

# permanent save of the file. Currently, a break introduced

# after a save will be effective, but not persistent.

# This is necessary to keep the saved breaks synched with the

# saved file.

#

# Breakpoints are set as tagged ranges in the text. Certain

# kinds of edits cause these ranges to be deleted: Inserting

# or deleting a line just before a breakpoint, and certain

# deletions prior to a breakpoint. These issues need to be

# investigated and understood. It's not clear if they are

# Tk issues or IDLE issues, or whether they can actually

# be fixed. Since a modified file has to be saved before it is

# run, and since self.breakpoints (from which the subprocess

# debugger is loaded) is updated during the save, the visible

# breaks stay synched with the subprocess even if one of these

# unexpected breakpoint deletions occurs.

breaks = self.breakpoints

filename = self.io.filename

try:

with open(self.breakpointPath,"r") as old_file:

lines = old_file.readlines()

except IOError:

lines = []

try:

with open(self.breakpointPath,"w") as new_file:

for line in lines:

if not line.startswith(filename + '='):

new_file.write(line)

self.update_breakpoints()

breaks = self.breakpoints

if breaks:

new_file.write(filename + '=' + str(breaks) + '\n')

except IOError as err:

if not getattr(self.root, "breakpoint_error_displayed", False):

self.root.breakpoint_error_displayed = True

tkMessageBox.showerror(title='IDLE Error',

message='Unable to update breakpoint list:\n%s'

% str(err),

parent=self.text)

def restore_file_breaks(self):

self.text.update() # this enables setting "BREAK" tags to be visible

filename = self.io.filename

if filename is None:

return

if os.path.isfile(self.breakpointPath):

lines = open(self.breakpointPath,"r").readlines()

for line in lines:

if line.startswith(filename + '='):

breakpoint_linenumbers = eval(line[len(filename)+1:])

for breakpoint_linenumber in breakpoint_linenumbers:

self.set_breakpoint(breakpoint_linenumber)

def update_breakpoints(self):

"Retrieves all the breakpoints in the current window"

text = self.text

ranges = text.tag_ranges("BREAK")

linenumber_list = self.ranges_to_linenumbers(ranges)

self.breakpoints = linenumber_list

def ranges_to_linenumbers(self, ranges):

lines = []

for index in range(0, len(ranges), 2):

lineno = int(float(ranges[index].string))

end = int(float(ranges[index+1].string))

while lineno < end:

lines.append(lineno)

lineno += 1

return lines

def _close(self):

"Extend base method - clear breaks when module is closed"

self.clear_file_breaks()

"Extend base class: IDLE supports a shell and breakpoints"

# override FileList's class variable, instances return PyShellEditorWindow

# instead of EditorWindow when new edit windows are created.

EditorWindow = PyShellEditorWindow

pyshell = None

def open_shell(self, event=None):

if self.pyshell:

self.pyshell.top.wakeup()

else:

self.pyshell = PyShell(self)

if self.pyshell:

if not self.pyshell.begin():

return None

"Extend base class: colorizer for the shell window itself"

def __init__(self):

ColorDelegator.__init__(self)

self.LoadTagDefs()

def recolorize_main(self):

self.tag_remove("TODO", "1.0", "iomark")

self.tag_add("SYNC", "1.0", "iomark")

ColorDelegator.recolorize_main(self)

def LoadTagDefs(self):

ColorDelegator.LoadTagDefs(self)

theme = idleConf.GetOption('main','Theme','name')

self.tagdefs.update({

"stdin": {'background':None,'foreground':None},

"stdout": idleConf.GetHighlight(theme, "stdout"),

"stderr": idleConf.GetHighlight(theme, "stderr"),

"console": idleConf.GetHighlight(theme, "console"),

})

def removecolors(self):

# Don't remove shell color tags before "iomark"

for tag in self.tagdefs:

"Extend base class: forbid insert/delete before the I/O mark"

def insert(self, index, chars, tags=None):

try:

if self.delegate.compare(index, "<", "iomark"):

self.delegate.bell()

return

except TclError:

pass

UndoDelegator.insert(self, index, chars, tags)

def delete(self, index1, index2=None):

try:

if self.delegate.compare(index1, "<", "iomark"):

self.delegate.bell()

return

except TclError:

pass

def handle_EOF(self):

"Override the base class - just re-raise EOFError"

def __init__(self, tkconsole):

self.tkconsole = tkconsole

locals = sys.modules['__main__'].__dict__

InteractiveInterpreter.__init__(self, locals=locals)

self.save_warnings_filters = None

self.restarting = False

self.subprocess_arglist = None

self.port = PORT

self.original_compiler_flags = self.compile.compiler.flags

rpcclt = None

rpcpid = None

def spawn_subprocess(self):

if self.subprocess_arglist is None:

self.subprocess_arglist = self.build_subprocess_arglist()

args = self.subprocess_arglist

self.rpcpid = os.spawnv(os.P_NOWAIT, sys.executable, args)

def build_subprocess_arglist(self):

assert (self.port!=0), (

"Socket should have been assigned a port number.")

w = ['-W' + s for s in sys.warnoptions]

if 1/2 > 0: # account for new division

w.append('-Qnew')

# Maybe IDLE is installed and is being accessed via sys.path,

# or maybe it's not installed and the idle.py script is being

# run from the IDLE source directory.

del_exitf = idleConf.GetOption('main', 'General', 'delete-exitfunc',

default=False, type='bool')

if __name__ == 'idlelib.PyShell':

command = "__import__('idlelib.run').run.main(%r)" % (del_exitf,)

else:

command = "__import__('run').main(%r)" % (del_exitf,)

if sys.platform[:3] == 'win' and ' ' in sys.executable:

# handle embedded space in path by quoting the argument

decorated_exec = '"%s"' % sys.executable

else:

decorated_exec = sys.executable

return [decorated_exec] + w + ["-c", command, str(self.port)]

def start_subprocess(self):

addr = (HOST, self.port)

# GUI makes several attempts to acquire socket, listens for connection

for i in range(3):

time.sleep(i)

try:

self.rpcclt = MyRPCClient(addr)

break

except socket.error, err:

pass

else:

self.display_port_binding_error()

return None

# if PORT was 0, system will assign an 'ephemeral' port. Find it out:

self.port = self.rpcclt.listening_sock.getsockname()[1]

# if PORT was not 0, probably working with a remote execution server

if PORT != 0:

# To allow reconnection within the 2MSL wait (cf. Stevens TCP

# V1, 18.6), set SO_REUSEADDR. Note that this can be problematic

# on Windows since the implementation allows two active sockets on

# the same address!

self.rpcclt.listening_sock.setsockopt(socket.SOL_SOCKET,

socket.SO_REUSEADDR, 1)

self.spawn_subprocess()

#time.sleep(20) # test to simulate GUI not accepting connection

# Accept the connection from the Python execution server

self.rpcclt.listening_sock.settimeout(10)

try:

self.rpcclt.accept()

except socket.timeout, err:

self.display_no_subprocess_error()

return None

self.rpcclt.register("console", self.tkconsole)

self.rpcclt.register("stdin", self.tkconsole.stdin)

self.rpcclt.register("stdout", self.tkconsole.stdout)

self.rpcclt.register("stderr", self.tkconsole.stderr)

self.rpcclt.register("flist", self.tkconsole.flist)

self.rpcclt.register("linecache", linecache)

self.rpcclt.register("interp", self)

self.transfer_path(with_cwd=True)

self.poll_subprocess()

return self.rpcclt

def restart_subprocess(self, with_cwd=False):

if self.restarting:

return self.rpcclt

self.restarting = True

# close only the subprocess debugger

debug = self.getdebugger()

if debug:

try:

# Only close subprocess debugger, don't unregister gui_adap!

RemoteDebugger.close_subprocess_debugger(self.rpcclt)

except:

pass

# Kill subprocess, spawn a new one, accept connection.

self.rpcclt.close()

self.unix_terminate()

console = self.tkconsole

was_executing = console.executing

console.executing = False

self.spawn_subprocess()

try:

self.rpcclt.accept()

except socket.timeout, err:

self.display_no_subprocess_error()

return None

self.transfer_path(with_cwd=with_cwd)

# annotate restart in shell window and mark it

console.text.delete("iomark", "end-1c")

if was_executing:

console.write('\n')

console.showprompt()

halfbar = ((int(console.width) - 16) // 2) * '='

console.write(halfbar + ' RESTART ' + halfbar)

console.text.mark_set("restart", "end-1c")

console.text.mark_gravity("restart", "left")

console.showprompt()

# restart subprocess debugger

if debug:

# Restarted debugger connects to current instance of debug GUI

gui = RemoteDebugger.restart_subprocess_debugger(self.rpcclt)

# reload remote debugger breakpoints for all PyShellEditWindows

debug.load_breakpoints()

self.compile.compiler.flags = self.original_compiler_flags

self.restarting = False

return self.rpcclt

def __request_interrupt(self):

self.rpcclt.remotecall("exec", "interrupt_the_server", (), {})

def interrupt_subprocess(self):

threading.Thread(target=self.__request_interrupt).start()

def kill_subprocess(self):

try:

self.rpcclt.close()

except AttributeError: # no socket

pass

self.unix_terminate()

self.tkconsole.executing = False

self.rpcclt = None

def unix_terminate(self):

"UNIX: make sure subprocess is terminated and collect status"

if hasattr(os, 'kill'):

try:

os.kill(self.rpcpid, SIGTERM)

except OSError:

# process already terminated:

return

else:

try:

os.waitpid(self.rpcpid, 0)

except OSError:

return

def transfer_path(self, with_cwd=False):

if with_cwd: # Issue 13506

path = [''] # include Current Working Directory

path.extend(sys.path)

else:

path = sys.path

self.runcommand("""if 1:

\n""" % (path,))

active_seq = None

def poll_subprocess(self):

clt = self.rpcclt

if clt is None:

return

try:

response = clt.pollresponse(self.active_seq, wait=0.05)

except (EOFError, IOError, KeyboardInterrupt):

# lost connection or subprocess terminated itself, restart

# [the KBI is from rpc.SocketIO.handle_EOF()]

if self.tkconsole.closing:

return

response = None

self.restart_subprocess()

if response:

self.tkconsole.resetoutput()

self.active_seq = None

how, what = response

console = self.tkconsole.console

if how == "OK":

if what is not None:

print >>console, repr(what)

elif how == "EXCEPTION":

if self.tkconsole.getvar("<<toggle-jit-stack-viewer>>"):

self.remote_stack_viewer()

elif how == "ERROR":

errmsg = "PyShell.ModifiedInterpreter: Subprocess ERROR:\n"

print >>sys.__stderr__, errmsg, what

print >>console, errmsg, what

# we received a response to the currently active seq number:

try:

self.tkconsole.endexecuting()

except AttributeError: # shell may have closed

pass

# Reschedule myself

if not self.tkconsole.closing:

self.tkconsole.text.after(self.tkconsole.pollinterval,

self.poll_subprocess)

debugger = None

def setdebugger(self, debugger):

self.debugger = debugger

def getdebugger(self):

return self.debugger

def open_remote_stack_viewer(self):

"""Initiate the remote stack viewer from a separate thread.

self.tkconsole.text.after(300, self.remote_stack_viewer)

return

def remote_stack_viewer(self):

from idlelib import RemoteObjectBrowser

oid = self.rpcclt.remotequeue("exec", "stackviewer", ("flist",), {})

if oid is None:

self.tkconsole.root.bell()

return

item = RemoteObjectBrowser.StubObjectTreeItem(self.rpcclt, oid)

from idlelib.TreeWidget import ScrolledCanvas, TreeNode

top = Toplevel(self.tkconsole.root)

theme = idleConf.GetOption('main','Theme','name')

background = idleConf.GetHighlight(theme, 'normal')['background']

sc = ScrolledCanvas(top, bg=background, highlightthickness=0)

sc.frame.pack(expand=1, fill="both")

node = TreeNode(sc.canvas, None, item)

node.expand()

# XXX Should GC the remote tree when closing the window

gid = 0

def execsource(self, source):

"Like runsource() but assumes complete exec source"

filename = self.stuffsource(source)

self.execfile(filename, source)

def execfile(self, filename, source=None):

"Execute an existing file"

if source is None:

source = open(filename, "r").read()

try:

code = compile(source, filename, "exec")

except (OverflowError, SyntaxError):

self.tkconsole.resetoutput()

tkerr = self.tkconsole.stderr

print>>tkerr, '*** Error in script or command!\n'

print>>tkerr, 'Traceback (most recent call last):'

InteractiveInterpreter.showsyntaxerror(self, filename)

self.tkconsole.showprompt()

else:

self.runcode(code)

def runsource(self, source):

"Extend base class method: Stuff the source in the line cache first"

filename = self.stuffsource(source)

self.more = 0

self.save_warnings_filters = warnings.filters[:]

warnings.filterwarnings(action="error", category=SyntaxWarning)

if isinstance(source, types.UnicodeType):

from idlelib import IOBinding

try:

source = source.encode(IOBinding.encoding)

except UnicodeError:

self.tkconsole.resetoutput()

self.write("Unsupported characters in input\n")

return

try:

# InteractiveInterpreter.runsource() calls its runcode() method,

# which is overridden (see below)

return InteractiveInterpreter.runsource(self, source, filename)

finally:

if self.save_warnings_filters is not None:

warnings.filters[:] = self.save_warnings_filters

self.save_warnings_filters = None

def stuffsource(self, source):

"Stuff source in the filename cache"

filename = "<pyshell#%d>" % self.gid

self.gid = self.gid + 1

lines = source.split("\n")

linecache.cache[filename] = len(source)+1, 0, lines, filename

return filename

def prepend_syspath(self, filename):

"Prepend sys.path with file's directory if not already included"

self.runcommand("""if 1:

\n""" % (filename,))

def showsyntaxerror(self, filename=None):

"""Extend base class method: Add Colorizing

text = self.tkconsole.text

stuff = self.unpackerror()

if stuff:

msg, lineno, offset, line = stuff

if lineno == 1:

pos = "iomark + %d chars" % (offset-1)

else:

pos = "iomark linestart + %d lines + %d chars" % \

(lineno-1, offset-1)

text.tag_add("ERROR", pos)

text.see(pos)

char = text.get(pos)

if char and char in IDENTCHARS:

text.tag_add("ERROR", pos + " wordstart", pos)

self.tkconsole.resetoutput()

self.write("SyntaxError: %s\n" % str(msg))

else:

self.tkconsole.resetoutput()

InteractiveInterpreter.showsyntaxerror(self, filename)

self.tkconsole.showprompt()

def unpackerror(self):

type, value, tb = sys.exc_info()

ok = type is SyntaxError

if ok:

try:

msg, (dummy_filename, lineno, offset, line) = value

if not offset:

offset = 0

except:

ok = 0

if ok:

return msg, lineno, offset, line

else:

return None

def showtraceback(self):

"Extend base class method to reset output properly"

self.tkconsole.resetoutput()

self.checklinecache()

InteractiveInterpreter.showtraceback(self)

if self.tkconsole.getvar("<<toggle-jit-stack-viewer>>"):

self.tkconsole.open_stack_viewer()

def checklinecache(self):

c = linecache.cache

for key in c.keys():

if key[:1] + key[-1:] != "<>":

del c[key]

def runcommand(self, code):

"Run the code without invoking the debugger"

# The code better not raise an exception!

if self.tkconsole.executing:

self.display_executing_dialog()

return 0

if self.rpcclt:

self.rpcclt.remotequeue("exec", "runcode", (code,), {})

else:

exec code in self.locals

return 1

def runcode(self, code):

"Override base class method"

if self.tkconsole.executing:

self.interp.restart_subprocess()

self.checklinecache()

if self.save_warnings_filters is not None:

warnings.filters[:] = self.save_warnings_filters

self.save_warnings_filters = None

debugger = self.debugger

try:

self.tkconsole.beginexecuting()

if not debugger and self.rpcclt is not None:

self.active_seq = self.rpcclt.asyncqueue("exec", "runcode",

(code,), {})

elif debugger:

debugger.run(code, self.locals)

else:

exec code in self.locals

except SystemExit:

if not self.tkconsole.closing:

if tkMessageBox.askyesno(

"Exit?",

"Do you want to exit altogether?",

default="yes",

master=self.tkconsole.text):

raise

else:

self.showtraceback()

else:

raise

except:

if use_subprocess:

print >>self.tkconsole.stderr, \

"IDLE internal error in runcode()"

self.showtraceback()

self.tkconsole.endexecuting()

else:

if self.tkconsole.canceled:

self.tkconsole.canceled = False

print >>self.tkconsole.stderr, "KeyboardInterrupt"

else:

self.showtraceback()

finally:

if not use_subprocess:

try:

self.tkconsole.endexecuting()

except AttributeError: # shell may have closed

pass

def write(self, s):

"Override base class method"

self.tkconsole.stderr.write(s)

def display_port_binding_error(self):

tkMessageBox.showerror(

"Port Binding Error",

"IDLE can't bind to a TCP/IP port, which is necessary to "

"communicate with its Python execution server. This might be "

"because no networking is installed on this computer. "

"Run IDLE with the -n command line switch to start without a "

"subprocess and refer to Help/IDLE Help 'Running without a "

"subprocess' for further details.",

master=self.tkconsole.text)

def display_no_subprocess_error(self):

tkMessageBox.showerror(

"Subprocess Startup Error",

"IDLE's subprocess didn't make connection. Either IDLE can't "

"start a subprocess or personal firewall software is blocking "

"the connection.",

master=self.tkconsole.text)

def display_executing_dialog(self):

tkMessageBox.showerror(

"Already executing",

"The Python Shell window is already executing a command; "

"please wait until it is finished.",

shell_title = "Python Shell"

# Override classes

ColorDelegator = ModifiedColorDelegator

UndoDelegator = ModifiedUndoDelegator

# Override menus

menu_specs = [

("file", "_File"),

("edit", "_Edit"),

("debug", "_Debug"),

("options", "_Options"),

("windows", "_Windows"),

("help", "_Help"),

]

if macosxSupport.runningAsOSXApp():

del menu_specs[-3]

menu_specs[-2] = ("windows", "_Window")

# New classes

from idlelib.IdleHistory import History

def __init__(self, flist=None):

if use_subprocess:

ms = self.menu_specs

if ms[2][0] != "shell":

ms.insert(2, ("shell", "She_ll"))

self.interp = ModifiedInterpreter(self)

if flist is None:

root = Tk()

fixwordbreaks(root)

root.withdraw()

flist = PyShellFileList(root)

#

OutputWindow.__init__(self, flist, None, None)

#

self.usetabs = True

# indentwidth must be 8 when using tabs. See note in EditorWindow:

self.indentwidth = 8

self.context_use_ps1 = True

#

text = self.text

text.configure(wrap="char")

text.bind("<<newline-and-indent>>", self.enter_callback)

text.bind("<<plain-newline-and-indent>>", self.linefeed_callback)

text.bind("<<interrupt-execution>>", self.cancel_callback)

text.bind("<<end-of-file>>", self.eof_callback)

text.bind("<<open-stack-viewer>>", self.open_stack_viewer)

text.bind("<<toggle-debugger>>", self.toggle_debugger)

text.bind("<<toggle-jit-stack-viewer>>", self.toggle_jit_stack_viewer)

if use_subprocess:

text.bind("<<view-restart>>", self.view_restart_mark)

text.bind("<<restart-shell>>", self.restart_shell)

#

self.save_stdout = sys.stdout

self.save_stderr = sys.stderr

self.save_stdin = sys.stdin

from idlelib import IOBinding

self.stdin = PseudoInputFile(self, "stdin", IOBinding.encoding)

self.stdout = PseudoOutputFile(self, "stdout", IOBinding.encoding)

self.stderr = PseudoOutputFile(self, "stderr", IOBinding.encoding)

self.console = PseudoOutputFile(self, "console", IOBinding.encoding)

if not use_subprocess:

sys.stdout = self.stdout

sys.stderr = self.stderr

sys.stdin = self.stdin

#

self.history = self.History(self.text)

#

self.pollinterval = 50 # millisec

def get_standard_extension_names(self):

return idleConf.GetExtensions(shell_only=True)

reading = False

executing = False

canceled = False

endoffile = False

closing = False

def set_warning_stream(self, stream):

global warning_stream

warning_stream = stream

def get_warning_stream(self):

return warning_stream

def toggle_debugger(self, event=None):

if self.executing:

tkMessageBox.showerror("Don't debug now",

"You can only toggle the debugger when idle",

master=self.text)

self.set_debugger_indicator()

return "break"

else:

db = self.interp.getdebugger()

if db:

self.close_debugger()

else:

self.open_debugger()

def set_debugger_indicator(self):

db = self.interp.getdebugger()

self.setvar("<<toggle-debugger>>", not not db)

def toggle_jit_stack_viewer(self, event=None):

pass # All we need is the variable

def close_debugger(self):

db = self.interp.getdebugger()

if db:

self.interp.setdebugger(None)

db.close()

if self.interp.rpcclt:

RemoteDebugger.close_remote_debugger(self.interp.rpcclt)

self.resetoutput()

self.console.write("[DEBUG OFF]\n")

sys.ps1 = ">>> "

self.showprompt()

self.set_debugger_indicator()

def open_debugger(self):

if self.interp.rpcclt:

dbg_gui = RemoteDebugger.start_remote_debugger(self.interp.rpcclt,

self)

else:

dbg_gui = Debugger.Debugger(self)

self.interp.setdebugger(dbg_gui)

dbg_gui.load_breakpoints()

sys.ps1 = "[DEBUG ON]\n>>> "

self.showprompt()

self.set_debugger_indicator()

def beginexecuting(self):

"Helper for ModifiedInterpreter"

self.resetoutput()

self.executing = 1

def endexecuting(self):

"Helper for ModifiedInterpreter"

self.executing = 0

self.canceled = 0

self.showprompt()

def close(self):

"Extend EditorWindow.close()"

if self.executing:

response = tkMessageBox.askokcancel(

"Kill?",

"The program is still running!\n Do you want to kill it?",

default="ok",

parent=self.text)

if response is False:

return "cancel"

if self.reading:

self.top.quit()

self.canceled = True

self.closing = True

# Wait for poll_subprocess() rescheduling to stop

self.text.after(2 * self.pollinterval, self.close2)

def close2(self):

return EditorWindow.close(self)

def _close(self):

"Extend EditorWindow._close(), shut down debugger and execution server"

self.close_debugger()

if use_subprocess:

self.interp.kill_subprocess()

# Restore std streams

sys.stdout = self.save_stdout

sys.stderr = self.save_stderr

sys.stdin = self.save_stdin

# Break cycles