python, hg: tow outside the environment.

they've served us well, and can ride off into the sunset.

1 files changed, 0 insertions, 327 deletions

diff --git a/sys/lib/python/idlelib/run.py b/sys/lib/python/idlelib/run.py
deleted file mode 100644
index ae810c4ec..000000000
--- a/sys/lib/python/idlelib/run.py
+++ /dev/null
@@ -1,327 +0,0 @@
-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:
-        del sys.exitfunc
-    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)