#! /usr/bin/env pythonimport os
import sys
import string
import getopt
import re
import socket
import time
import traceback
import types
import warnings
import linecache
from code import InteractiveInterpreter
from Tkinter import*import tkMessageBox
from EditorWindow import EditorWindow, fixwordbreaks
from FileList import FileList
from ColorDelegator import ColorDelegator
from UndoDelegator import UndoDelegator
from OutputWindow import OutputWindow
from configHandler import idleConf
import idlever
import os.path
import rpc
import RemoteDebugger
IDENTCHARS = string.ascii_letters + string.digits +"_"# XX hardwire this for now, remove later KBK 09Jun02
use_subprocess =1# Set to 1 to spawn subprocess for command execution# Change warnings module to write to sys.__stderr__try:import warnings
exceptImportError:passelse:defidle_showwarning(message, category, filename, lineno):file= sys.__stderr__
file.write(warnings.formatwarning(message, category, filename, lineno))
warnings.showwarning = idle_showwarning
deflinecache_checkcache():"""Extend linecache.checkcache to preserve the <pyshell#...> entries Rather than repeating the linecache code, patch it by saving the pyshell# entries, call linecache.checkcache(), and then restore the saved entries. """
orig_checkcache=linecache.checkcache
cache = linecache.cache
save = {}for filename in cache.keys():if filename[:1] + filename[-1:] =='<>':
save[filename] = cache[filename]orig_checkcache()
cache.update(save)
linecache.checkcache = linecache_checkcache
classPyShellEditorWindow(EditorWindow):"Regular text edit window when a shell is present"# XXX KBK 19Oct02 Breakpoints are currently removed if module is# changed or closed. Future plans include saving breakpoints in a# project file and possibly preserving breakpoints by changing their# line numbers as a module is modified.def__init__(self, *args):
self.breakpoints = []apply(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 breakpointsif self.io.filename: self.restore_file_breaks()deffilename_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 = [("Set Breakpoint","<<set-breakpoint-here>>"),("Clear Breakpoint","<<clear-breakpoint-here>>")]defset_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)exceptValueError:# 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....passdefset_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)defclear_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:passdefclear_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:passdefstore_file_breaks(self):if not self.breakpoints:return
filename=self.io.filename
try:
lines=open(self.breakpointPath,"r").readlines()exceptIOError:
lines=[]
new_file=open(self.breakpointPath,"w")for line in lines:if not line.startswith(filename+"="):
new_file.write(line)
new_file.write(filename+"="+`self.get_current_breaks()`+"\n")
new_file.close()defrestore_file_breaks(self):
self.text.update()# this enables setting "BREAK" tags to be visible
filename=self.io.filename
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)defget_current_breaks(self):## retrieves all the breakpoints in the current window#
text = self.text
lines = text.tag_ranges("BREAK")
result = [int(float((lines[i])))for i inrange(0,len(lines),2)]return result
defsaved_change_hook(self):"Extend base method - clear breaks if module is modified"if not self.get_saved():
self.clear_file_breaks()
EditorWindow.saved_change_hook(self)def_close(self):"Extend base method - clear breaks when module is closed"
self.store_file_breaks()
self.clear_file_breaks()
EditorWindow._close(self)classPyShellFileList(FileList):"Extend base class: file list when a shell is present"
EditorWindow = PyShellEditorWindow
pyshell =Nonedefopen_shell(self, event=None):if self.pyshell:
self.pyshell.wakeup()else:
self.pyshell =PyShell(self)
self.pyshell.begin()return self.pyshell
classModifiedColorDelegator(ColorDelegator):"Extend base class: colorizer for the shell window itself"def__init__(self):
ColorDelegator.__init__(self)
self.LoadTagDefs()defrecolorize_main(self):
self.tag_remove("TODO","1.0","iomark")
self.tag_add("SYNC","1.0","iomark")
ColorDelegator.recolorize_main(self)defLoadTagDefs(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"),"ERROR": idleConf.GetHighlight(theme,"error"),None: idleConf.GetHighlight(theme,"normal"),})classModifiedUndoDelegator(UndoDelegator):"Extend base class: forbid insert/delete before the I/O mark"definsert(self, index, chars, tags=None):try:if self.delegate.compare(index,"<","iomark"):
self.delegate.bell()returnexcept TclError:pass
UndoDelegator.insert(self, index, chars, tags)defdelete(self, index1, index2=None):try:if self.delegate.compare(index1,"<","iomark"):
self.delegate.bell()returnexcept TclError:pass
UndoDelegator.delete(self, index1, index2)classModifiedInterpreter(InteractiveInterpreter):def__init__(self, tkconsole):
self.tkconsole = tkconsole
locals= sys.modules['__main__'].__dict__
InteractiveInterpreter.__init__(self,locals=locals)
self.save_warnings_filters =None
port =8833
rpcclt =None
rpcpid =Nonedefspawn_subprocess(self):
w = ['-W'+ s for s in sys.warnoptions]
args = [self.find_executable()] + w \
+ ["-c","__import__('run').main()",str(self.port)]
self.rpcpid = os.spawnv(os.P_NOWAIT, args[0], args)deffind_executable(self):if sys.platform =='darwin'and sys.executable.count('.app'):# On Mac OS X, avoid calling sys.executable because it ignores# command-line options (sys.executable is an applet)## Instead, find the executable by looking relative to# sys.prefix.
executable = os.path.join(sys.prefix,'Resources','Python.app','Contents','MacOS','python')return executable
else:return sys.executable
defstart_subprocess(self):
addr = ("localhost", self.port)
self.spawn_subprocess()# Idle starts listening for connection on localhostfor i inrange(6):
time.sleep(i)try:
self.rpcclt = rpc.RPCClient(addr)breakexcept socket.error, err:if i <3:print>>sys.__stderr__,". ",else:print>>sys.__stderr__,"\nIdle socket error: "+ err[1]\
+", retrying..."else:display_port_binding_error()return# Accept the connection from the Python execution server
self.rpcclt.accept()
self.rpcclt.register("stdin", self.tkconsole)
self.rpcclt.register("stdout", self.tkconsole.stdout)
self.rpcclt.register("stderr", self.tkconsole.stderr)
self.rpcclt.register("flist", self.tkconsole.flist)
self.poll_subprocess()defrestart_subprocess(self):# close only the subprocess debugger
debug = self.getdebugger()if debug:
RemoteDebugger.close_subprocess_debugger(self.rpcclt)# kill subprocess, spawn a new one, accept connection
self.rpcclt.close()
self.spawn_subprocess()
self.rpcclt.accept()# restart remote debuggerif debug:
gui = RemoteDebugger.restart_subprocess_debugger(self.rpcclt)# reload remote debugger breakpoints for all PyShellEditWindows
debug.load_breakpoints()
active_seq =Nonedefpoll_subprocess(self):
clt = self.rpcclt
if clt is None:return
response = clt.pollresponse(self.active_seq)
self.tkconsole.text.after(50, self.poll_subprocess)if response:
self.tkconsole.resetoutput()
self.active_seq =None
how, what = response
file= self.tkconsole.console
if how =="OK":if what is not None:print>>file, `what`
elif how =="EXCEPTION":
mod, name, args, tb = what
print>>file,'Traceback (most recent call last):'while tb and tb[0][0]in("run.py","rpc.py"):del tb[0]while tb and tb[-1][0]in("run.py","rpc.py"):del tb[-1]for i inrange(len(tb)):
fn, ln, nm, line = tb[i]if not line and fn.startswith("<pyshell#"):
line = linecache.getline(fn, ln)
tb[i] = fn, ln, nm, line
traceback.print_list(tb,file=file)if mod and mod !="exceptions":
name = mod +"."+ name
print>>file, name +":"," ".join(map(str, args))if self.tkconsole.getvar("<<toggle-jit-stack-viewer>>"):
self.remote_stack_viewer()elif how =="ERROR":print>>sys.__stderr__,"Oops:", how, what
print>>file,"Oops:", how, what
self.tkconsole.endexecuting()defkill_subprocess(self):
clt = self.rpcclt
self.rpcclt =Noneif clt is not None:
clt.close()
debugger =Nonedefsetdebugger(self, debugger):
self.debugger = debugger
defgetdebugger(self):return self.debugger
defremote_stack_viewer(self):import RemoteObjectBrowser
oid = self.rpcclt.remotecall("exec","stackviewer", ("flist",), {})if oid is None:
self.tkconsole.root.bell()return
item = RemoteObjectBrowser.StubObjectTreeItem(self.rpcclt, oid)from TreeWidget import ScrolledCanvas, TreeNode
top =Toplevel(self.tkconsole.root)
sc =ScrolledCanvas(top, bg="white", 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 =0defexecsource(self, source):"Like runsource() but assumes complete exec source"
filename = self.stuffsource(source)
self.execfile(filename, source)defexecfile(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()
InteractiveInterpreter.showsyntaxerror(self, filename)else:
self.runcode(code)defrunsource(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)ifisinstance(source, types.UnicodeType):import IOBinding
try:
source = source.encode(IOBinding.encoding)exceptUnicodeError:
self.tkconsole.resetoutput()
self.write("Unsupported characters in input")returntry: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 =Nonedefstuffsource(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
defshowsyntaxerror(self, filename=None):"""Extend base class method: Add Colorizing Color the offending position instead of printing it and pointing at it with a caret. """
text = self.tkconsole.text
stuff = self.unpackerror()if not stuff:
self.tkconsole.resetoutput()
InteractiveInterpreter.showsyntaxerror(self, filename)return
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))defunpackerror(self):type, value, tb = sys.exc_info()
ok =typeisSyntaxErrorif ok:try:
msg, (dummy_filename, lineno, offset, line) = value
except:
ok =0if ok:return msg, lineno, offset, line
else:return Nonedefshowtraceback(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()defchecklinecache(self):
c = linecache.cache
for key in c.keys():if key[:1] + key[-1:] !="<>":del c[key]defdisplay_executing_dialog(self):
tkMessageBox.showerror("Already executing","The Python Shell window is already executing a command; ""please wait until it is finished.",
master=self.tkconsole.text)defruncommand(self, code):"Run the code without invoking the debugger"# The code better not raise an exception!if self.tkconsole.executing:display_executing_dialog()return0if self.rpcclt:
self.rpcclt.remotecall("exec","runcode", (code,), {})else:exec code in self.localsreturn1defruncode(self, code):"Override base class method"if self.tkconsole.executing:display_executing_dialog()return
self.checklinecache()if self.save_warnings_filters is not None:
warnings.filters[:] = self.save_warnings_filters
self.save_warnings_filters =None
debugger = self.debugger
if not debugger and self.rpcclt is not None:
self.tkconsole.beginexecuting()
self.active_seq = self.rpcclt.asynccall("exec","runcode",(code,), {})returntry:
self.tkconsole.beginexecuting()try:if debugger:
debugger.run(code, self.locals)else:exec code in self.localsexceptSystemExit:if tkMessageBox.askyesno("Exit?","Do you want to exit altogether?",
default="yes",
master=self.tkconsole.text):raiseelse:
self.showtraceback()except:
self.showtraceback()finally:
self.tkconsole.endexecuting()defwrite(self, s):"Override base class method"
self.tkconsole.console.write(s)classPyShell(OutputWindow):
shell_title ="Python Shell"# Override classes
ColorDelegator = ModifiedColorDelegator
UndoDelegator = ModifiedUndoDelegator
# Override menus: Run and Format not desired in shell; add Debug
menu_specs = [("file","_File"),("edit","_Edit"),("debug","_Debug"),("settings","_Settings"),("windows","_Windows"),("help","_Help"),]# New classesfrom IdleHistory import History
def__init__(self, flist=None):
self.interp =ModifiedInterpreter(self)if flist is None:
root =Tk()fixwordbreaks(root)
root.withdraw()
flist =PyShellFileList(root)#
OutputWindow.__init__(self, flist,None,None)#import __builtin__
__builtin__.quit = __builtin__.exit ="To exit, type Ctrl-D."#
self.config(usetabs=1, indentwidth=8, context_use_ps1=1)#
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("<<beginning-of-line>>", self.home_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("<<open-python-shell>>", self.flist.open_shell)
text.bind("<<toggle-jit-stack-viewer>>", self.toggle_jit_stack_viewer)#
self.save_stdout = sys.stdout
self.save_stderr = sys.stderr
self.save_stdin = sys.stdin
self.stdout =PseudoFile(self,"stdout")
self.stderr =PseudoFile(self,"stderr")
self.console =PseudoFile(self,"console")if not use_subprocess:
sys.stdout = self.stdout
sys.stderr = self.stderr
sys.stdin = self
#
self.history = self.History(self.text)#if use_subprocess:
self.interp.start_subprocess()
reading =0
executing =0
canceled =0
endoffile =0deftoggle_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()defset_debugger_indicator(self):
db = self.interp.getdebugger()
self.setvar("<<toggle-debugger>>",not not db)deftoggle_jit_stack_viewer( self, event=None):pass# All we need is the variabledefclose_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()defopen_debugger(self):# XXX KBK 13Jun02 An RPC client always exists now? Open remote# debugger and return...dike the rest of this fcn and combine# with open_remote_debugger?if self.interp.rpcclt:return self.open_remote_debugger()import Debugger
self.interp.setdebugger(Debugger.Debugger(self))
sys.ps1 ="[DEBUG ON]\n>>> "
self.showprompt()
self.set_debugger_indicator()defopen_remote_debugger(self):
gui = RemoteDebugger.start_remote_debugger(self.interp.rpcclt, self)
self.interp.setdebugger(gui)# Load all PyShellEditorWindow breakpoints:
gui.load_breakpoints()
sys.ps1 ="[DEBUG ON]\n>>> "
self.showprompt()
self.set_debugger_indicator()defbeginexecuting(self):"Helper for ModifiedInterpreter"
self.resetoutput()
self.executing =1##self._cancel_check = self.cancel_check##sys.settrace(self._cancel_check)defendexecuting(self):"Helper for ModifiedInterpreter"##sys.settrace(None)##self._cancel_check = None
self.executing =0
self.canceled =0
self.showprompt()defclose(self):"Extend EditorWindow.close()"if self.executing:# XXX Need to ask a question hereif not tkMessageBox.askokcancel("Kill?","The program is still running; do you want to kill it?",
default="ok",
master=self.text):return"cancel"
self.canceled =1if self.reading:
self.top.quit()return"cancel"return EditorWindow.close(self)def_close(self):"Extend EditorWindow._close(), shut down debugger and execution server"
self.close_debugger()
self.interp.kill_subprocess()# Restore std streams
sys.stdout = self.save_stdout
sys.stderr = self.save_stderr
sys.stdin = self.save_stdin
# Break cycles
self.interp =None
self.console =None
self.flist.pyshell =None
self.history =None
EditorWindow._close(self)defispythonsource(self, filename):"Override EditorWindow method: never remove the colorizer"return Truedefshort_title(self):return self.shell_title
COPYRIGHT = \
'Type "copyright", "credits" or "license" for more information.'defbegin(self):
self.resetoutput()
self.write("Python %s on %s\n%s\nGRPC IDLE Fork %s\n"%(sys.version, sys.platform, self.COPYRIGHT,
idlever.IDLE_VERSION))try:
sys.ps1
exceptAttributeError:
sys.ps1 =">>> "
self.showprompt()import Tkinter
Tkinter._default_root =Nonedefinteract(self):
self.begin()
self.top.mainloop()defreadline(self):
save = self.reading
try:
self.reading =1
self.top.mainloop()finally:
self.reading = save
line = self.text.get("iomark","end-1c")
self.resetoutput()if self.canceled:
self.canceled =0raiseKeyboardInterruptif self.endoffile:
self.endoffile =0return""return line
defisatty(self):return Truedefcancel_callback(self, event):try:if self.text.compare("sel.first","!=","sel.last"):return# Active selection -- always use default bindingexcept:passif not(self.executing or self.reading):
self.resetoutput()
self.write("KeyboardInterrupt\n")
self.showprompt()return"break"
self.endoffile =0if self.reading:
self.canceled =1
self.top.quit()elif(self.executing and self.interp.rpcclt and
self.interp.rpcpid andhasattr(os,"kill")):try:from signal import SIGINT
exceptImportError:
SIGINT =2
os.kill(self.interp.rpcpid, SIGINT)else:
self.canceled =1return"break"defeof_callback(self, event):if self.executing and not self.reading:return# Let the default binding (delete next char) take overif not(self.text.compare("iomark","==","insert")and
self.text.compare("insert","==","end-1c")):return# Let the default binding (delete next char) take overif not self.executing:
self.resetoutput()
self.close()else:
self.canceled =0
self.endoffile =1
self.top.quit()return"break"defhome_callback(self, event):if event.state !=0and event.keysym =="Home":return# <Modifier-Home>; fall back to class bindingif self.text.compare("iomark","<=","insert")and \
self.text.compare("insert linestart","<=","iomark"):
self.text.mark_set("insert","iomark")
self.text.tag_remove("sel","1.0","end")
self.text.see("insert")return"break"deflinefeed_callback(self, event):# Insert a linefeed without entering anything (still autoindented)if self.reading:
self.text.insert("insert","\n")
self.text.see("insert")else:
self.auto_indent(event)return"break"defenter_callback(self, event):if self.executing and not self.reading:return# Let the default binding (insert '\n') take over# If some text is selected, recall the selection# (but only if this before the I/O mark)try:
sel = self.text.get("sel.first","sel.last")if sel:if self.text.compare("sel.last","<=","iomark"):
self.recall(sel)return"break"except:pass# If we're strictly before the line containing iomark, recall# the current line, less a leading prompt, less leading or# trailing whitespaceif self.text.compare("insert","<","iomark linestart"):# Check if there's a relevant stdin range -- if so, use it
prev = self.text.tag_prevrange("stdin","insert")if prev and self.text.compare("insert","<", prev[1]):
self.recall(self.text.get(prev[0], prev[1]))return"break"
next = self.text.tag_nextrange("stdin","insert")if next and self.text.compare("insert lineend",">=", next[0]):
self.recall(self.text.get(next[0], next[1]))return"break"# No stdin mark -- just get the current line
self.recall(self.text.get("insert linestart","insert lineend"))return"break"# If we're in the current input and there's only whitespace# beyond the cursor, erase that whitespace first
s = self.text.get("insert","end-1c")if s and not s.strip():
self.text.delete("insert","end-1c")# If we're in the current input before its last line,# insert a newline right at the insert pointif self.text.compare("insert","<","end-1c linestart"):
self.auto_indent(event)return"break"# We're in the last line; append a newline and submit it
self.text.mark_set("insert","end-1c")if self.reading:
self.text.insert("insert","\n")
self.text.see("insert")else:
self.auto_indent(event)
self.text.tag_add("stdin","iomark","end-1c")
self.text.update_idletasks()if self.reading:
self.top.quit()# Break out of recursive mainloop() in raw_input()else:
self.runit()return"break"defrecall(self, s):if self.history:
self.history.recall(s)defrunit(self):
line = self.text.get("iomark","end-1c")# Strip off last newline and surrounding whitespace.# (To allow you to hit return twice to end a statement.)
i =len(line)while i >0and line[i-1]in"\t":
i = i-1if i >0and line[i-1] =="\n":
i = i-1while i >0and line[i-1]in"\t":
i = i-1
line = line[:i]
more = self.interp.runsource(line)defcancel_check(self, frame, what, args,
dooneevent=tkinter.dooneevent,
dontwait=tkinter.DONT_WAIT):# Hack -- use the debugger hooks to be able to handle events# and interrupt execution at any time.# This slows execution down quite a bit, so you may want to# disable this (by not calling settrace() in runcode() above)# for full-bore (uninterruptable) speed.# XXX This should become a user option.if self.canceled:returndooneevent(dontwait)if self.canceled:
self.canceled =0raiseKeyboardInterruptreturn self._cancel_check
defopen_stack_viewer(self, event=None):if self.interp.rpcclt:return self.interp.remote_stack_viewer()try:
sys.last_traceback
except:
tkMessageBox.showerror("No stack trace","There is no stack trace yet.\n""(sys.last_traceback is not defined)",
master=self.text)returnfrom StackViewer import StackBrowser
sv =StackBrowser(self.root, self.flist)defshowprompt(self):
self.resetoutput()try:
s =str(sys.ps1)except:
s =""
self.console.write(s)
self.text.mark_set("insert","end-1c")
self.set_line_and_column()
self.io.reset_undo()defresetoutput(self):
source = self.text.get("iomark","end-1c")if self.history:
self.history.history_store(source)if self.text.get("end-2c") !="\n":
self.text.insert("end-1c","\n")
self.text.mark_set("iomark","end-1c")
self.set_line_and_column()
sys.stdout.softspace =0defwrite(self, s, tags=()):
self.text.mark_gravity("iomark","right")
OutputWindow.write(self, s, tags,"iomark")
self.text.mark_gravity("iomark","left")if self.canceled:
self.canceled =0raiseKeyboardInterruptclass PseudoFile:def__init__(self, shell, tags):
self.shell = shell
self.tags = tags
self.softspace =0defwrite(self, s):
self.shell.write(s, self.tags)defwritelines(self, l):map(self.write, l)defflush(self):passdefisatty(self):return True
usage_msg ="""\usage: idle.py [-c command] [-d] [-i] [-r script] [-s] [-t title] [arg] ...idle file(s) (without options) edit the file(s)-c cmd run the command in a shell-d enable the debugger-e edit mode; arguments are files to be edited-i open an interactive shell-i file(s) open a shell and also an editor window for each file-r-s run $IDLESTARTUP or $PYTHONSTARTUP before anything else-t title set title of shell windowRemaining arguments are applied to the command (-c) or script (-r)."""defmain():
cmd =None
edit =0
debug =0
script =None
startup =0try:
opts, args = getopt.getopt(sys.argv[1:],"c:deir:st:")except getopt.error, msg:
sys.stderr.write("Error: %s\n"%str(msg))
sys.stderr.write(usage_msg)
sys.exit(2)for o, a in opts:if o =='-c':
cmd = a
if o =='-d':
debug =1if o =='-e':
edit =1if o =='-r':
script = a
if o =='-s':
startup =1if o =='-t':
PyShell.shell_title = a
if args and args[0] !="-": edit =1for i inrange(len(sys.path)):
sys.path[i] = os.path.abspath(sys.path[i])
pathx = []if edit:for filename in args:
pathx.append(os.path.dirname(filename))elif args and args[0] !="-":
pathx.append(os.path.dirname(args[0]))else:
pathx.append(os.curdir)fordirin pathx:dir= os.path.abspath(dir)if notdirin sys.path:
sys.path.insert(0,dir)global flist, root
root =Tk(className="Idle")fixwordbreaks(root)
root.withdraw()
flist =PyShellFileList(root)if edit:for filename in args:
flist.open(filename)if not args:
flist.new()else:if cmd:
sys.argv = ["-c"] + args
else:
sys.argv = args or[""]
shell =PyShell(flist)
interp = shell.interp
flist.pyshell = shell
if startup:
filename = os.environ.get("IDLESTARTUP")or \
os.environ.get("PYTHONSTARTUP")if filename and os.path.isfile(filename):
interp.execfile(filename)if debug:
shell.open_debugger()if cmd:
interp.execsource(cmd)elif script:if os.path.isfile(script):
interp.execfile(script)else:print"No script file: ", script
shell.begin()
root.mainloop()
root.destroy()defdisplay_port_binding_error():print"""\IDLE cannot run.IDLE needs to use a specific TCP/IP port (8833) in order to execute anddebug programs. IDLE is unable to bind to this port, and so cannotstart. Here are some possible causes of this problem: 1. TCP/IP networking is not installed or not working on this computer 2. Another program is running that uses this port 3. Personal firewall software is preventing IDLE from using this portIDLE makes and accepts connections only with this computer, and does notcommunicate over the internet in any way. Its use of port 8833 should not be a security risk on a single-user machine."""if __name__ =="__main__":main()
