--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/python-2.5.2/win32/Lib/idlelib/run.py Fri Apr 03 17:19:34 2009 +0100
@@ -0,0 +1,330 @@
+import sys
+import os
+import linecache
+import time
+import socket
+import traceback
+import thread
+import threading
+import Queue
+
+import CallTips
+import AutoComplete
+
+import RemoteDebugger
+import RemoteObjectBrowser
+import StackViewer
+import rpc
+
+import __main__
+
+LOCALHOST = '127.0.0.1'
+
+try:
+ import warnings
+except ImportError:
+ pass
+else:
+ def idle_formatwarning_subproc(message, category, filename, lineno):
+ """Format warnings the IDLE way"""
+ s = "\nWarning (from warnings module):\n"
+ s += ' File \"%s\", line %s\n' % (filename, lineno)
+ line = linecache.getline(filename, lineno).strip()
+ if line:
+ s += " %s\n" % line
+ s += "%s: %s\n" % (category.__name__, message)
+ return s
+ warnings.formatwarning = idle_formatwarning_subproc
+
+# Thread shared globals: Establish a queue between a subthread (which handles
+# the socket) and the main thread (which runs user code), plus global
+# completion and exit flags:
+
+exit_now = False
+quitting = False
+
+def main(del_exitfunc=False):
+ """Start the Python execution server in a subprocess
+
+ In the Python subprocess, RPCServer is instantiated with handlerclass
+ MyHandler, which inherits register/unregister methods from RPCHandler via
+ the mix-in class SocketIO.
+
+ When the RPCServer 'server' is instantiated, the TCPServer initialization
+ creates an instance of run.MyHandler and calls its handle() method.
+ handle() instantiates a run.Executive object, passing it a reference to the
+ MyHandler object. That reference is saved as attribute rpchandler of the
+ Executive instance. The Executive methods have access to the reference and
+ can pass it on to entities that they command
+ (e.g. RemoteDebugger.Debugger.start_debugger()). The latter, in turn, can
+ call MyHandler(SocketIO) register/unregister methods via the reference to
+ register and unregister themselves.
+
+ """
+ global exit_now
+ global quitting
+ global no_exitfunc
+ no_exitfunc = del_exitfunc
+ port = 8833
+ #time.sleep(15) # test subprocess not responding
+ if sys.argv[1:]:
+ port = int(sys.argv[1])
+ sys.argv[:] = [""]
+ sockthread = threading.Thread(target=manage_socket,
+ name='SockThread',
+ args=((LOCALHOST, port),))
+ sockthread.setDaemon(True)
+ sockthread.start()
+ while 1:
+ try:
+ if exit_now:
+ try:
+ exit()
+ except KeyboardInterrupt:
+ # exiting but got an extra KBI? Try again!
+ continue
+ try:
+ seq, request = rpc.request_queue.get(block=True, timeout=0.05)
+ except Queue.Empty:
+ continue
+ method, args, kwargs = request
+ ret = method(*args, **kwargs)
+ rpc.response_queue.put((seq, ret))
+ except KeyboardInterrupt:
+ if quitting:
+ exit_now = True
+ continue
+ except SystemExit:
+ raise
+ except:
+ type, value, tb = sys.exc_info()
+ try:
+ print_exception()
+ rpc.response_queue.put((seq, None))
+ except:
+ # Link didn't work, print same exception to __stderr__
+ traceback.print_exception(type, value, tb, file=sys.__stderr__)
+ exit()
+ else:
+ continue
+
+def manage_socket(address):
+ for i in range(3):
+ time.sleep(i)
+ try:
+ server = MyRPCServer(address, MyHandler)
+ break
+ except socket.error, err:
+ print>>sys.__stderr__,"IDLE Subprocess: socket error: "\
+ + err[1] + ", retrying...."
+ else:
+ print>>sys.__stderr__, "IDLE Subprocess: Connection to "\
+ "IDLE GUI failed, exiting."
+ show_socket_error(err, address)
+ global exit_now
+ exit_now = True
+ return
+ server.handle_request() # A single request only
+
+def show_socket_error(err, address):
+ import Tkinter
+ import tkMessageBox
+ root = Tkinter.Tk()
+ root.withdraw()
+ if err[0] == 61: # connection refused
+ msg = "IDLE's subprocess can't connect to %s:%d. This may be due "\
+ "to your personal firewall configuration. It is safe to "\
+ "allow this internal connection because no data is visible on "\
+ "external ports." % address
+ tkMessageBox.showerror("IDLE Subprocess Error", msg, parent=root)
+ else:
+ tkMessageBox.showerror("IDLE Subprocess Error", "Socket Error: %s" % err[1])
+ root.destroy()
+
+def print_exception():
+ import linecache
+ linecache.checkcache()
+ flush_stdout()
+ efile = sys.stderr
+ typ, val, tb = excinfo = sys.exc_info()
+ sys.last_type, sys.last_value, sys.last_traceback = excinfo
+ tbe = traceback.extract_tb(tb)
+ print>>efile, '\nTraceback (most recent call last):'
+ exclude = ("run.py", "rpc.py", "threading.py", "Queue.py",
+ "RemoteDebugger.py", "bdb.py")
+ cleanup_traceback(tbe, exclude)
+ traceback.print_list(tbe, file=efile)
+ lines = traceback.format_exception_only(typ, val)
+ for line in lines:
+ print>>efile, line,
+
+def cleanup_traceback(tb, exclude):
+ "Remove excluded traces from beginning/end of tb; get cached lines"
+ orig_tb = tb[:]
+ while tb:
+ for rpcfile in exclude:
+ if tb[0][0].count(rpcfile):
+ break # found an exclude, break for: and delete tb[0]
+ else:
+ break # no excludes, have left RPC code, break while:
+ del tb[0]
+ while tb:
+ for rpcfile in exclude:
+ if tb[-1][0].count(rpcfile):
+ break
+ else:
+ break
+ del tb[-1]
+ if len(tb) == 0:
+ # exception was in IDLE internals, don't prune!
+ tb[:] = orig_tb[:]
+ print>>sys.stderr, "** IDLE Internal Exception: "
+ rpchandler = rpc.objecttable['exec'].rpchandler
+ for i in range(len(tb)):
+ fn, ln, nm, line = tb[i]
+ if nm == '?':
+ nm = "-toplevel-"
+ if not line and fn.startswith("<pyshell#"):
+ line = rpchandler.remotecall('linecache', 'getline',
+ (fn, ln), {})
+ tb[i] = fn, ln, nm, line
+
+def flush_stdout():
+ try:
+ if sys.stdout.softspace:
+ sys.stdout.softspace = 0
+ sys.stdout.write("\n")
+ except (AttributeError, EOFError):
+ pass
+
+def exit():
+ """Exit subprocess, possibly after first deleting sys.exitfunc
+
+ If config-main.cfg/.def 'General' 'delete-exitfunc' is True, then any
+ sys.exitfunc will be removed before exiting. (VPython support)
+
+ """
+ if no_exitfunc:
+ try:
+ del sys.exitfunc
+ except AttributeError:
+ pass
+ sys.exit(0)
+
+class MyRPCServer(rpc.RPCServer):
+
+ def handle_error(self, request, client_address):
+ """Override RPCServer method for IDLE
+
+ Interrupt the MainThread and exit server if link is dropped.
+
+ """
+ global quitting
+ try:
+ raise
+ except SystemExit:
+ raise
+ except EOFError:
+ global exit_now
+ exit_now = True
+ thread.interrupt_main()
+ except:
+ erf = sys.__stderr__
+ print>>erf, '\n' + '-'*40
+ print>>erf, 'Unhandled server exception!'
+ print>>erf, 'Thread: %s' % threading.currentThread().getName()
+ print>>erf, 'Client Address: ', client_address
+ print>>erf, 'Request: ', repr(request)
+ traceback.print_exc(file=erf)
+ print>>erf, '\n*** Unrecoverable, server exiting!'
+ print>>erf, '-'*40
+ quitting = True
+ thread.interrupt_main()
+
+
+class MyHandler(rpc.RPCHandler):
+
+ def handle(self):
+ """Override base method"""
+ executive = Executive(self)
+ self.register("exec", executive)
+ sys.stdin = self.console = self.get_remote_proxy("stdin")
+ sys.stdout = self.get_remote_proxy("stdout")
+ sys.stderr = self.get_remote_proxy("stderr")
+ import IOBinding
+ sys.stdin.encoding = sys.stdout.encoding = \
+ sys.stderr.encoding = IOBinding.encoding
+ self.interp = self.get_remote_proxy("interp")
+ rpc.RPCHandler.getresponse(self, myseq=None, wait=0.05)
+
+ def exithook(self):
+ "override SocketIO method - wait for MainThread to shut us down"
+ time.sleep(10)
+
+ def EOFhook(self):
+ "Override SocketIO method - terminate wait on callback and exit thread"
+ global quitting
+ quitting = True
+ thread.interrupt_main()
+
+ def decode_interrupthook(self):
+ "interrupt awakened thread"
+ global quitting
+ quitting = True
+ thread.interrupt_main()
+
+
+class Executive(object):
+
+ def __init__(self, rpchandler):
+ self.rpchandler = rpchandler
+ self.locals = __main__.__dict__
+ self.calltip = CallTips.CallTips()
+ self.autocomplete = AutoComplete.AutoComplete()
+
+ def runcode(self, code):
+ try:
+ self.usr_exc_info = None
+ exec code in self.locals
+ except:
+ self.usr_exc_info = sys.exc_info()
+ if quitting:
+ exit()
+ # even print a user code SystemExit exception, continue
+ print_exception()
+ jit = self.rpchandler.console.getvar("<<toggle-jit-stack-viewer>>")
+ if jit:
+ self.rpchandler.interp.open_remote_stack_viewer()
+ else:
+ flush_stdout()
+
+ def interrupt_the_server(self):
+ thread.interrupt_main()
+
+ def start_the_debugger(self, gui_adap_oid):
+ return RemoteDebugger.start_debugger(self.rpchandler, gui_adap_oid)
+
+ def stop_the_debugger(self, idb_adap_oid):
+ "Unregister the Idb Adapter. Link objects and Idb then subject to GC"
+ self.rpchandler.unregister(idb_adap_oid)
+
+ def get_the_calltip(self, name):
+ return self.calltip.fetch_tip(name)
+
+ def get_the_completion_list(self, what, mode):
+ return self.autocomplete.fetch_completions(what, mode)
+
+ def stackviewer(self, flist_oid=None):
+ if self.usr_exc_info:
+ typ, val, tb = self.usr_exc_info
+ else:
+ return None
+ flist = None
+ if flist_oid is not None:
+ flist = self.rpchandler.get_remote_proxy(flist_oid)
+ while tb and tb.tb_frame.f_globals["__name__"] in ["rpc", "run"]:
+ tb = tb.tb_next
+ sys.last_type = typ
+ sys.last_value = val
+ item = StackViewer.StackTreeItem(flist, tb)
+ return RemoteObjectBrowser.remote_object_tree_item(item)