Terry Jan Reedy | 81bb97d | 2019-05-24 21:59:53 -0400 | [diff] [blame] | 1 | """ idlelib.run |
| 2 | |
| 3 | Simplified, pyshell.ModifiedInterpreter spawns a subprocess with |
| 4 | f'''{sys.executable} -c "__import__('idlelib.run').run.main()"''' |
| 5 | '.run' is needed because __import__ returns idlelib, not idlelib.run. |
| 6 | """ |
Miss Islington (bot) | d4af553 | 2019-07-06 05:54:17 -0700 | [diff] [blame] | 7 | import functools |
Terry Jan Reedy | 6cf0e13 | 2016-07-15 02:43:03 -0400 | [diff] [blame] | 8 | import io |
Kurt B. Kaiser | 49a5fe1 | 2004-07-04 01:25:56 +0000 | [diff] [blame] | 9 | import linecache |
Terry Jan Reedy | 6cf0e13 | 2016-07-15 02:43:03 -0400 | [diff] [blame] | 10 | import queue |
| 11 | import sys |
Miss Islington (bot) | d4af553 | 2019-07-06 05:54:17 -0700 | [diff] [blame] | 12 | import textwrap |
Terry Jan Reedy | 6cf0e13 | 2016-07-15 02:43:03 -0400 | [diff] [blame] | 13 | import time |
| 14 | import traceback |
Terry Jan Reedy | bfbaa6b | 2016-08-31 00:50:55 -0400 | [diff] [blame] | 15 | import _thread as thread |
| 16 | import threading |
| 17 | import warnings |
Kurt B. Kaiser | 5afa1df | 2002-10-10 08:25:24 +0000 | [diff] [blame] | 18 | |
Terry Jan Reedy | bfbaa6b | 2016-08-31 00:50:55 -0400 | [diff] [blame] | 19 | from idlelib import autocomplete # AutoComplete, fetch_encodings |
Terry Jan Reedy | 06e2029 | 2018-06-19 23:00:35 -0400 | [diff] [blame] | 20 | from idlelib import calltip # Calltip |
Terry Jan Reedy | bfbaa6b | 2016-08-31 00:50:55 -0400 | [diff] [blame] | 21 | from idlelib import debugger_r # start_debugger |
| 22 | from idlelib import debugobj_r # remote_object_tree_item |
| 23 | from idlelib import iomenu # encoding |
| 24 | from idlelib import rpc # multiple objects |
| 25 | from idlelib import stackviewer # StackTreeItem |
Kurt B. Kaiser | 5afa1df | 2002-10-10 08:25:24 +0000 | [diff] [blame] | 26 | import __main__ |
| 27 | |
Terry Jan Reedy | 81bb97d | 2019-05-24 21:59:53 -0400 | [diff] [blame] | 28 | import tkinter # Use tcl and, if startup fails, messagebox. |
| 29 | if not hasattr(sys.modules['idlelib.run'], 'firstrun'): |
| 30 | # Undo modifications of tkinter by idlelib imports; see bpo-25507. |
| 31 | for mod in ('simpledialog', 'messagebox', 'font', |
| 32 | 'dialog', 'filedialog', 'commondialog', |
| 33 | 'ttk'): |
| 34 | delattr(tkinter, mod) |
| 35 | del sys.modules['tkinter.' + mod] |
| 36 | # Avoid AttributeError if run again; see bpo-37038. |
| 37 | sys.modules['idlelib.run'].firstrun = False |
Terry Jan Reedy | ff1d5ab | 2016-07-16 18:26:32 -0400 | [diff] [blame] | 38 | |
Kurt B. Kaiser | 24d7e0c | 2003-06-05 23:51:29 +0000 | [diff] [blame] | 39 | LOCALHOST = '127.0.0.1' |
| 40 | |
Kurt B. Kaiser | 49a5fe1 | 2004-07-04 01:25:56 +0000 | [diff] [blame] | 41 | |
Terry Jan Reedy | 6cf0e13 | 2016-07-15 02:43:03 -0400 | [diff] [blame] | 42 | def idle_formatwarning(message, category, filename, lineno, line=None): |
| 43 | """Format warnings the IDLE way.""" |
| 44 | |
| 45 | s = "\nWarning (from warnings module):\n" |
| 46 | s += ' File \"%s\", line %s\n' % (filename, lineno) |
| 47 | if line is None: |
| 48 | line = linecache.getline(filename, lineno) |
| 49 | line = line.strip() |
| 50 | if line: |
| 51 | s += " %s\n" % line |
| 52 | s += "%s: %s\n" % (category.__name__, message) |
| 53 | return s |
| 54 | |
Terry Jan Reedy | 95a3f11 | 2013-06-28 23:50:12 -0400 | [diff] [blame] | 55 | def idle_showwarning_subproc( |
| 56 | message, category, filename, lineno, file=None, line=None): |
| 57 | """Show Idle-format warning after replacing warnings.showwarning. |
Andrew Svetlov | a2251aa | 2012-03-13 18:36:13 -0700 | [diff] [blame] | 58 | |
Terry Jan Reedy | 95a3f11 | 2013-06-28 23:50:12 -0400 | [diff] [blame] | 59 | The only difference is the formatter called. |
| 60 | """ |
| 61 | if file is None: |
| 62 | file = sys.stderr |
| 63 | try: |
Terry Jan Reedy | 6cf0e13 | 2016-07-15 02:43:03 -0400 | [diff] [blame] | 64 | file.write(idle_formatwarning( |
Terry Jan Reedy | 95a3f11 | 2013-06-28 23:50:12 -0400 | [diff] [blame] | 65 | message, category, filename, lineno, line)) |
Serhiy Storchaka | 55fe1ae | 2017-04-16 10:46:38 +0300 | [diff] [blame] | 66 | except OSError: |
Terry Jan Reedy | 95a3f11 | 2013-06-28 23:50:12 -0400 | [diff] [blame] | 67 | pass # the file (probably stderr) is invalid - this warning gets lost. |
| 68 | |
| 69 | _warnings_showwarning = None |
| 70 | |
| 71 | def capture_warnings(capture): |
| 72 | "Replace warning.showwarning with idle_showwarning_subproc, or reverse." |
| 73 | |
| 74 | global _warnings_showwarning |
| 75 | if capture: |
| 76 | if _warnings_showwarning is None: |
| 77 | _warnings_showwarning = warnings.showwarning |
| 78 | warnings.showwarning = idle_showwarning_subproc |
| 79 | else: |
| 80 | if _warnings_showwarning is not None: |
| 81 | warnings.showwarning = _warnings_showwarning |
| 82 | _warnings_showwarning = None |
| 83 | |
| 84 | capture_warnings(True) |
Andrew Svetlov | 753445a | 2012-03-26 21:56:44 +0300 | [diff] [blame] | 85 | tcl = tkinter.Tcl() |
| 86 | |
Andrew Svetlov | 753445a | 2012-03-26 21:56:44 +0300 | [diff] [blame] | 87 | def handle_tk_events(tcl=tcl): |
Andrew Svetlov | a2251aa | 2012-03-13 18:36:13 -0700 | [diff] [blame] | 88 | """Process any tk events that are ready to be dispatched if tkinter |
| 89 | has been imported, a tcl interpreter has been created and tk has been |
| 90 | loaded.""" |
Andrew Svetlov | 753445a | 2012-03-26 21:56:44 +0300 | [diff] [blame] | 91 | tcl.eval("update") |
Andrew Svetlov | a2251aa | 2012-03-13 18:36:13 -0700 | [diff] [blame] | 92 | |
Kurt B. Kaiser | 11c53e2 | 2003-03-22 19:40:19 +0000 | [diff] [blame] | 93 | # Thread shared globals: Establish a queue between a subthread (which handles |
| 94 | # the socket) and the main thread (which runs user code), plus global |
Guido van Rossum | 8ce8a78 | 2007-11-01 19:42:39 +0000 | [diff] [blame] | 95 | # completion, exit and interruptable (the main thread) flags: |
Kurt B. Kaiser | 11c53e2 | 2003-03-22 19:40:19 +0000 | [diff] [blame] | 96 | |
Kurt B. Kaiser | 67fd0ea | 2003-05-24 20:59:15 +0000 | [diff] [blame] | 97 | exit_now = False |
| 98 | quitting = False |
Guido van Rossum | 8ce8a78 | 2007-11-01 19:42:39 +0000 | [diff] [blame] | 99 | interruptable = False |
Kurt B. Kaiser | 11c53e2 | 2003-03-22 19:40:19 +0000 | [diff] [blame] | 100 | |
Kurt B. Kaiser | 62df044 | 2003-05-28 01:47:46 +0000 | [diff] [blame] | 101 | def main(del_exitfunc=False): |
Kurt B. Kaiser | b417936 | 2002-07-26 00:06:42 +0000 | [diff] [blame] | 102 | """Start the Python execution server in a subprocess |
| 103 | |
Kurt B. Kaiser | 5afa1df | 2002-10-10 08:25:24 +0000 | [diff] [blame] | 104 | In the Python subprocess, RPCServer is instantiated with handlerclass |
| 105 | MyHandler, which inherits register/unregister methods from RPCHandler via |
| 106 | the mix-in class SocketIO. |
Kurt B. Kaiser | b417936 | 2002-07-26 00:06:42 +0000 | [diff] [blame] | 107 | |
Kurt B. Kaiser | 11c53e2 | 2003-03-22 19:40:19 +0000 | [diff] [blame] | 108 | When the RPCServer 'server' is instantiated, the TCPServer initialization |
Kurt B. Kaiser | 5afa1df | 2002-10-10 08:25:24 +0000 | [diff] [blame] | 109 | creates an instance of run.MyHandler and calls its handle() method. |
| 110 | handle() instantiates a run.Executive object, passing it a reference to the |
| 111 | MyHandler object. That reference is saved as attribute rpchandler of the |
| 112 | Executive instance. The Executive methods have access to the reference and |
| 113 | can pass it on to entities that they command |
Terry Jan Reedy | 6fa5bdc | 2016-05-28 13:22:31 -0400 | [diff] [blame] | 114 | (e.g. debugger_r.Debugger.start_debugger()). The latter, in turn, can |
Kurt B. Kaiser | 5afa1df | 2002-10-10 08:25:24 +0000 | [diff] [blame] | 115 | call MyHandler(SocketIO) register/unregister methods via the reference to |
| 116 | register and unregister themselves. |
Kurt B. Kaiser | b417936 | 2002-07-26 00:06:42 +0000 | [diff] [blame] | 117 | |
| 118 | """ |
Kurt B. Kaiser | 67fd0ea | 2003-05-24 20:59:15 +0000 | [diff] [blame] | 119 | global exit_now |
| 120 | global quitting |
Kurt B. Kaiser | 62df044 | 2003-05-28 01:47:46 +0000 | [diff] [blame] | 121 | global no_exitfunc |
| 122 | no_exitfunc = del_exitfunc |
Kurt B. Kaiser | af3eb87 | 2004-01-21 18:54:30 +0000 | [diff] [blame] | 123 | #time.sleep(15) # test subprocess not responding |
Kurt B. Kaiser | e67842a | 2009-04-04 20:13:23 +0000 | [diff] [blame] | 124 | try: |
| 125 | assert(len(sys.argv) > 1) |
| 126 | port = int(sys.argv[-1]) |
| 127 | except: |
Kurt B. Kaiser | 8fc98c3 | 2009-04-04 20:20:29 +0000 | [diff] [blame] | 128 | print("IDLE Subprocess: no IP port passed in sys.argv.", |
| 129 | file=sys.__stderr__) |
Kurt B. Kaiser | e67842a | 2009-04-04 20:13:23 +0000 | [diff] [blame] | 130 | return |
Terry Jan Reedy | 95a3f11 | 2013-06-28 23:50:12 -0400 | [diff] [blame] | 131 | |
| 132 | capture_warnings(True) |
Chui Tey | 5d2af63 | 2002-05-26 13:36:41 +0000 | [diff] [blame] | 133 | sys.argv[:] = [""] |
Kurt B. Kaiser | 11c53e2 | 2003-03-22 19:40:19 +0000 | [diff] [blame] | 134 | sockthread = threading.Thread(target=manage_socket, |
| 135 | name='SockThread', |
Kurt B. Kaiser | 24d7e0c | 2003-06-05 23:51:29 +0000 | [diff] [blame] | 136 | args=((LOCALHOST, port),)) |
Benjamin Peterson | 71088cc | 2008-09-19 21:49:37 +0000 | [diff] [blame] | 137 | sockthread.daemon = True |
Kurt B. Kaiser | 11c53e2 | 2003-03-22 19:40:19 +0000 | [diff] [blame] | 138 | sockthread.start() |
| 139 | while 1: |
| 140 | try: |
Kurt B. Kaiser | 67fd0ea | 2003-05-24 20:59:15 +0000 | [diff] [blame] | 141 | if exit_now: |
| 142 | try: |
Kurt B. Kaiser | 62df044 | 2003-05-28 01:47:46 +0000 | [diff] [blame] | 143 | exit() |
Kurt B. Kaiser | 67fd0ea | 2003-05-24 20:59:15 +0000 | [diff] [blame] | 144 | except KeyboardInterrupt: |
| 145 | # exiting but got an extra KBI? Try again! |
| 146 | continue |
Kurt B. Kaiser | a00050f | 2003-05-08 20:26:55 +0000 | [diff] [blame] | 147 | try: |
Terry Jan Reedy | 1e2fcac | 2017-12-04 16:16:18 -0500 | [diff] [blame] | 148 | request = rpc.request_queue.get(block=True, timeout=0.05) |
Alexandre Vassalotti | f260e44 | 2008-05-11 19:59:59 +0000 | [diff] [blame] | 149 | except queue.Empty: |
Terry Jan Reedy | 1e2fcac | 2017-12-04 16:16:18 -0500 | [diff] [blame] | 150 | request = None |
| 151 | # Issue 32207: calling handle_tk_events here adds spurious |
| 152 | # queue.Empty traceback to event handling exceptions. |
| 153 | if request: |
| 154 | seq, (method, args, kwargs) = request |
| 155 | ret = method(*args, **kwargs) |
| 156 | rpc.response_queue.put((seq, ret)) |
| 157 | else: |
Andrew Svetlov | a2251aa | 2012-03-13 18:36:13 -0700 | [diff] [blame] | 158 | handle_tk_events() |
Kurt B. Kaiser | aa6b856 | 2003-05-14 18:15:40 +0000 | [diff] [blame] | 159 | except KeyboardInterrupt: |
Kurt B. Kaiser | 67fd0ea | 2003-05-24 20:59:15 +0000 | [diff] [blame] | 160 | if quitting: |
| 161 | exit_now = True |
Kurt B. Kaiser | aa6b856 | 2003-05-14 18:15:40 +0000 | [diff] [blame] | 162 | continue |
Kurt B. Kaiser | a2792be | 2003-05-17 21:04:10 +0000 | [diff] [blame] | 163 | except SystemExit: |
Terry Jan Reedy | 95a3f11 | 2013-06-28 23:50:12 -0400 | [diff] [blame] | 164 | capture_warnings(False) |
Kurt B. Kaiser | a2792be | 2003-05-17 21:04:10 +0000 | [diff] [blame] | 165 | raise |
Kurt B. Kaiser | 9ec454e | 2003-05-12 02:33:47 +0000 | [diff] [blame] | 166 | except: |
Kurt B. Kaiser | 67fd0ea | 2003-05-24 20:59:15 +0000 | [diff] [blame] | 167 | type, value, tb = sys.exc_info() |
Kurt B. Kaiser | a2792be | 2003-05-17 21:04:10 +0000 | [diff] [blame] | 168 | try: |
| 169 | print_exception() |
| 170 | rpc.response_queue.put((seq, None)) |
| 171 | except: |
Kurt B. Kaiser | 67fd0ea | 2003-05-24 20:59:15 +0000 | [diff] [blame] | 172 | # Link didn't work, print same exception to __stderr__ |
| 173 | traceback.print_exception(type, value, tb, file=sys.__stderr__) |
Kurt B. Kaiser | 62df044 | 2003-05-28 01:47:46 +0000 | [diff] [blame] | 174 | exit() |
Kurt B. Kaiser | 67fd0ea | 2003-05-24 20:59:15 +0000 | [diff] [blame] | 175 | else: |
| 176 | continue |
Kurt B. Kaiser | 11c53e2 | 2003-03-22 19:40:19 +0000 | [diff] [blame] | 177 | |
| 178 | def manage_socket(address): |
Kurt B. Kaiser | af3eb87 | 2004-01-21 18:54:30 +0000 | [diff] [blame] | 179 | for i in range(3): |
Kurt B. Kaiser | b417936 | 2002-07-26 00:06:42 +0000 | [diff] [blame] | 180 | time.sleep(i) |
| 181 | try: |
Kurt B. Kaiser | a00050f | 2003-05-08 20:26:55 +0000 | [diff] [blame] | 182 | server = MyRPCServer(address, MyHandler) |
Kurt B. Kaiser | b417936 | 2002-07-26 00:06:42 +0000 | [diff] [blame] | 183 | break |
Andrew Svetlov | 0832af6 | 2012-12-18 23:10:48 +0200 | [diff] [blame] | 184 | except OSError as err: |
| 185 | print("IDLE Subprocess: OSError: " + err.args[1] + |
Georg Brandl | 6464d47 | 2007-10-22 16:16:13 +0000 | [diff] [blame] | 186 | ", retrying....", file=sys.__stderr__) |
Amaury Forgeot d'Arc | efae8c4 | 2008-11-21 23:08:09 +0000 | [diff] [blame] | 187 | socket_error = err |
Kurt B. Kaiser | b417936 | 2002-07-26 00:06:42 +0000 | [diff] [blame] | 188 | else: |
Amaury Forgeot d'Arc | efae8c4 | 2008-11-21 23:08:09 +0000 | [diff] [blame] | 189 | print("IDLE Subprocess: Connection to " |
| 190 | "IDLE GUI failed, exiting.", file=sys.__stderr__) |
| 191 | show_socket_error(socket_error, address) |
Kurt B. Kaiser | 67fd0ea | 2003-05-24 20:59:15 +0000 | [diff] [blame] | 192 | global exit_now |
| 193 | exit_now = True |
Kurt B. Kaiser | a00050f | 2003-05-08 20:26:55 +0000 | [diff] [blame] | 194 | return |
Kurt B. Kaiser | 11c53e2 | 2003-03-22 19:40:19 +0000 | [diff] [blame] | 195 | server.handle_request() # A single request only |
| 196 | |
Kurt B. Kaiser | af3eb87 | 2004-01-21 18:54:30 +0000 | [diff] [blame] | 197 | def show_socket_error(err, address): |
terryjreedy | 188aedf | 2017-06-13 21:32:16 -0400 | [diff] [blame] | 198 | "Display socket error from manage_socket." |
Georg Brandl | 14fc427 | 2008-05-17 18:39:55 +0000 | [diff] [blame] | 199 | import tkinter |
terryjreedy | 188aedf | 2017-06-13 21:32:16 -0400 | [diff] [blame] | 200 | from tkinter.messagebox import showerror |
Georg Brandl | 14fc427 | 2008-05-17 18:39:55 +0000 | [diff] [blame] | 201 | root = tkinter.Tk() |
Serhiy Storchaka | a96c96f | 2017-09-21 11:20:06 +0300 | [diff] [blame] | 202 | fix_scaling(root) |
Kurt B. Kaiser | af3eb87 | 2004-01-21 18:54:30 +0000 | [diff] [blame] | 203 | root.withdraw() |
Miss Islington (bot) | 02f7f74 | 2019-06-17 14:51:08 -0700 | [diff] [blame] | 204 | showerror( |
| 205 | "Subprocess Connection Error", |
| 206 | f"IDLE's subprocess can't connect to {address[0]}:{address[1]}.\n" |
| 207 | f"Fatal OSError #{err.errno}: {err.strerror}.\n" |
| 208 | "See the 'Startup failure' section of the IDLE doc, online at\n" |
| 209 | "https://docs.python.org/3/library/idle.html#startup-failure", |
| 210 | parent=root) |
Kurt B. Kaiser | af3eb87 | 2004-01-21 18:54:30 +0000 | [diff] [blame] | 211 | root.destroy() |
| 212 | |
Kurt B. Kaiser | 9ec454e | 2003-05-12 02:33:47 +0000 | [diff] [blame] | 213 | def print_exception(): |
Kurt B. Kaiser | e9802a3 | 2004-01-02 04:04:04 +0000 | [diff] [blame] | 214 | import linecache |
| 215 | linecache.checkcache() |
Kurt B. Kaiser | 9ec454e | 2003-05-12 02:33:47 +0000 | [diff] [blame] | 216 | flush_stdout() |
| 217 | efile = sys.stderr |
Kurt B. Kaiser | 924f616 | 2003-11-19 04:52:32 +0000 | [diff] [blame] | 218 | typ, val, tb = excinfo = sys.exc_info() |
| 219 | sys.last_type, sys.last_value, sys.last_traceback = excinfo |
Serhiy Storchaka | 78470b4 | 2013-01-09 12:21:57 +0200 | [diff] [blame] | 220 | seen = set() |
| 221 | |
| 222 | def print_exc(typ, exc, tb): |
Zane Bitter | de86073 | 2017-10-17 17:29:39 -0400 | [diff] [blame] | 223 | seen.add(id(exc)) |
Serhiy Storchaka | 78470b4 | 2013-01-09 12:21:57 +0200 | [diff] [blame] | 224 | context = exc.__context__ |
| 225 | cause = exc.__cause__ |
Zane Bitter | de86073 | 2017-10-17 17:29:39 -0400 | [diff] [blame] | 226 | if cause is not None and id(cause) not in seen: |
Serhiy Storchaka | 78470b4 | 2013-01-09 12:21:57 +0200 | [diff] [blame] | 227 | print_exc(type(cause), cause, cause.__traceback__) |
| 228 | print("\nThe above exception was the direct cause " |
| 229 | "of the following exception:\n", file=efile) |
Serhiy Storchaka | 7131749 | 2013-01-09 12:24:48 +0200 | [diff] [blame] | 230 | elif (context is not None and |
| 231 | not exc.__suppress_context__ and |
Zane Bitter | de86073 | 2017-10-17 17:29:39 -0400 | [diff] [blame] | 232 | id(context) not in seen): |
Serhiy Storchaka | 78470b4 | 2013-01-09 12:21:57 +0200 | [diff] [blame] | 233 | print_exc(type(context), context, context.__traceback__) |
| 234 | print("\nDuring handling of the above exception, " |
| 235 | "another exception occurred:\n", file=efile) |
| 236 | if tb: |
| 237 | tbe = traceback.extract_tb(tb) |
| 238 | print('Traceback (most recent call last):', file=efile) |
| 239 | exclude = ("run.py", "rpc.py", "threading.py", "queue.py", |
Terry Jan Reedy | 6fa5bdc | 2016-05-28 13:22:31 -0400 | [diff] [blame] | 240 | "debugger_r.py", "bdb.py") |
Serhiy Storchaka | 78470b4 | 2013-01-09 12:21:57 +0200 | [diff] [blame] | 241 | cleanup_traceback(tbe, exclude) |
| 242 | traceback.print_list(tbe, file=efile) |
| 243 | lines = traceback.format_exception_only(typ, exc) |
| 244 | for line in lines: |
| 245 | print(line, end='', file=efile) |
| 246 | |
| 247 | print_exc(typ, val, tb) |
Kurt B. Kaiser | 9ec454e | 2003-05-12 02:33:47 +0000 | [diff] [blame] | 248 | |
| 249 | def cleanup_traceback(tb, exclude): |
| 250 | "Remove excluded traces from beginning/end of tb; get cached lines" |
| 251 | orig_tb = tb[:] |
| 252 | while tb: |
| 253 | for rpcfile in exclude: |
| 254 | if tb[0][0].count(rpcfile): |
| 255 | break # found an exclude, break for: and delete tb[0] |
| 256 | else: |
| 257 | break # no excludes, have left RPC code, break while: |
| 258 | del tb[0] |
| 259 | while tb: |
| 260 | for rpcfile in exclude: |
| 261 | if tb[-1][0].count(rpcfile): |
| 262 | break |
| 263 | else: |
| 264 | break |
| 265 | del tb[-1] |
| 266 | if len(tb) == 0: |
| 267 | # exception was in IDLE internals, don't prune! |
| 268 | tb[:] = orig_tb[:] |
Guido van Rossum | be19ed7 | 2007-02-09 05:37:30 +0000 | [diff] [blame] | 269 | print("** IDLE Internal Exception: ", file=sys.stderr) |
Kurt B. Kaiser | 9ec454e | 2003-05-12 02:33:47 +0000 | [diff] [blame] | 270 | rpchandler = rpc.objecttable['exec'].rpchandler |
| 271 | for i in range(len(tb)): |
| 272 | fn, ln, nm, line = tb[i] |
| 273 | if nm == '?': |
| 274 | nm = "-toplevel-" |
| 275 | if not line and fn.startswith("<pyshell#"): |
| 276 | line = rpchandler.remotecall('linecache', 'getline', |
| 277 | (fn, ln), {}) |
| 278 | tb[i] = fn, ln, nm, line |
| 279 | |
| 280 | def flush_stdout(): |
Guido van Rossum | 79139b2 | 2007-02-09 23:20:19 +0000 | [diff] [blame] | 281 | """XXX How to do this now?""" |
Kurt B. Kaiser | 9ec454e | 2003-05-12 02:33:47 +0000 | [diff] [blame] | 282 | |
Kurt B. Kaiser | 62df044 | 2003-05-28 01:47:46 +0000 | [diff] [blame] | 283 | def exit(): |
Guido van Rossum | c76a250 | 2007-08-09 14:26:58 +0000 | [diff] [blame] | 284 | """Exit subprocess, possibly after first clearing exit functions. |
Kurt B. Kaiser | 62df044 | 2003-05-28 01:47:46 +0000 | [diff] [blame] | 285 | |
| 286 | If config-main.cfg/.def 'General' 'delete-exitfunc' is True, then any |
Guido van Rossum | c76a250 | 2007-08-09 14:26:58 +0000 | [diff] [blame] | 287 | functions registered with atexit will be removed before exiting. |
| 288 | (VPython support) |
Kurt B. Kaiser | 62df044 | 2003-05-28 01:47:46 +0000 | [diff] [blame] | 289 | |
| 290 | """ |
| 291 | if no_exitfunc: |
Guido van Rossum | c76a250 | 2007-08-09 14:26:58 +0000 | [diff] [blame] | 292 | import atexit |
| 293 | atexit._clear() |
Terry Jan Reedy | 95a3f11 | 2013-06-28 23:50:12 -0400 | [diff] [blame] | 294 | capture_warnings(False) |
Kurt B. Kaiser | 62df044 | 2003-05-28 01:47:46 +0000 | [diff] [blame] | 295 | sys.exit(0) |
Chui Tey | 5d2af63 | 2002-05-26 13:36:41 +0000 | [diff] [blame] | 296 | |
Terry Jan Reedy | bfbaa6b | 2016-08-31 00:50:55 -0400 | [diff] [blame] | 297 | |
Serhiy Storchaka | a96c96f | 2017-09-21 11:20:06 +0300 | [diff] [blame] | 298 | def fix_scaling(root): |
| 299 | """Scale fonts on HiDPI displays.""" |
| 300 | import tkinter.font |
| 301 | scaling = float(root.tk.call('tk', 'scaling')) |
| 302 | if scaling > 1.4: |
| 303 | for name in tkinter.font.names(root): |
| 304 | font = tkinter.font.Font(root=root, name=name, exists=True) |
| 305 | size = int(font['size']) |
| 306 | if size < 0: |
| 307 | font['size'] = round(-0.75*size) |
| 308 | |
| 309 | |
Miss Islington (bot) | b82188d | 2019-07-09 11:59:19 -0700 | [diff] [blame] | 310 | def fixdoc(fun, text): |
| 311 | tem = (fun.__doc__ + '\n\n') if fun.__doc__ is not None else '' |
| 312 | fun.__doc__ = tem + textwrap.fill(textwrap.dedent(text)) |
| 313 | |
Miss Islington (bot) | d4af553 | 2019-07-06 05:54:17 -0700 | [diff] [blame] | 314 | RECURSIONLIMIT_DELTA = 30 |
Miss Islington (bot) | b82188d | 2019-07-09 11:59:19 -0700 | [diff] [blame] | 315 | |
Miss Islington (bot) | d4af553 | 2019-07-06 05:54:17 -0700 | [diff] [blame] | 316 | def install_recursionlimit_wrappers(): |
| 317 | """Install wrappers to always add 30 to the recursion limit.""" |
| 318 | # see: bpo-26806 |
| 319 | |
| 320 | @functools.wraps(sys.setrecursionlimit) |
| 321 | def setrecursionlimit(*args, **kwargs): |
| 322 | # mimic the original sys.setrecursionlimit()'s input handling |
| 323 | if kwargs: |
| 324 | raise TypeError( |
| 325 | "setrecursionlimit() takes no keyword arguments") |
| 326 | try: |
| 327 | limit, = args |
| 328 | except ValueError: |
| 329 | raise TypeError(f"setrecursionlimit() takes exactly one " |
| 330 | f"argument ({len(args)} given)") |
| 331 | if not limit > 0: |
| 332 | raise ValueError( |
| 333 | "recursion limit must be greater or equal than 1") |
| 334 | |
| 335 | return setrecursionlimit.__wrapped__(limit + RECURSIONLIMIT_DELTA) |
| 336 | |
Miss Islington (bot) | b82188d | 2019-07-09 11:59:19 -0700 | [diff] [blame] | 337 | fixdoc(setrecursionlimit, f"""\ |
| 338 | This IDLE wrapper adds {RECURSIONLIMIT_DELTA} to prevent possible |
| 339 | uninterruptible loops.""") |
Miss Islington (bot) | d4af553 | 2019-07-06 05:54:17 -0700 | [diff] [blame] | 340 | |
| 341 | @functools.wraps(sys.getrecursionlimit) |
| 342 | def getrecursionlimit(): |
| 343 | return getrecursionlimit.__wrapped__() - RECURSIONLIMIT_DELTA |
| 344 | |
Miss Islington (bot) | b82188d | 2019-07-09 11:59:19 -0700 | [diff] [blame] | 345 | fixdoc(getrecursionlimit, f"""\ |
| 346 | This IDLE wrapper subtracts {RECURSIONLIMIT_DELTA} to compensate |
| 347 | for the {RECURSIONLIMIT_DELTA} IDLE adds when setting the limit.""") |
Miss Islington (bot) | d4af553 | 2019-07-06 05:54:17 -0700 | [diff] [blame] | 348 | |
| 349 | # add the delta to the default recursion limit, to compensate |
| 350 | sys.setrecursionlimit(sys.getrecursionlimit() + RECURSIONLIMIT_DELTA) |
| 351 | |
| 352 | sys.setrecursionlimit = setrecursionlimit |
| 353 | sys.getrecursionlimit = getrecursionlimit |
| 354 | |
| 355 | |
| 356 | def uninstall_recursionlimit_wrappers(): |
| 357 | """Uninstall the recursion limit wrappers from the sys module. |
| 358 | |
| 359 | IDLE only uses this for tests. Users can import run and call |
| 360 | this to remove the wrapping. |
| 361 | """ |
| 362 | if ( |
| 363 | getattr(sys.setrecursionlimit, '__wrapped__', None) and |
| 364 | getattr(sys.getrecursionlimit, '__wrapped__', None) |
| 365 | ): |
| 366 | sys.setrecursionlimit = sys.setrecursionlimit.__wrapped__ |
| 367 | sys.getrecursionlimit = sys.getrecursionlimit.__wrapped__ |
| 368 | sys.setrecursionlimit(sys.getrecursionlimit() - RECURSIONLIMIT_DELTA) |
| 369 | |
| 370 | |
Kurt B. Kaiser | a00050f | 2003-05-08 20:26:55 +0000 | [diff] [blame] | 371 | class MyRPCServer(rpc.RPCServer): |
| 372 | |
| 373 | def handle_error(self, request, client_address): |
| 374 | """Override RPCServer method for IDLE |
| 375 | |
| 376 | Interrupt the MainThread and exit server if link is dropped. |
| 377 | |
| 378 | """ |
Kurt B. Kaiser | e953511 | 2004-11-19 15:46:49 +0000 | [diff] [blame] | 379 | global quitting |
Kurt B. Kaiser | a00050f | 2003-05-08 20:26:55 +0000 | [diff] [blame] | 380 | try: |
| 381 | raise |
| 382 | except SystemExit: |
| 383 | raise |
| 384 | except EOFError: |
Kurt B. Kaiser | 67fd0ea | 2003-05-24 20:59:15 +0000 | [diff] [blame] | 385 | global exit_now |
| 386 | exit_now = True |
Kurt B. Kaiser | 93e8e54 | 2003-06-13 22:03:43 +0000 | [diff] [blame] | 387 | thread.interrupt_main() |
Kurt B. Kaiser | a00050f | 2003-05-08 20:26:55 +0000 | [diff] [blame] | 388 | except: |
| 389 | erf = sys.__stderr__ |
Guido van Rossum | be19ed7 | 2007-02-09 05:37:30 +0000 | [diff] [blame] | 390 | print('\n' + '-'*40, file=erf) |
| 391 | print('Unhandled server exception!', file=erf) |
Amaury Forgeot d'Arc | bed1710 | 2008-11-29 01:48:47 +0000 | [diff] [blame] | 392 | print('Thread: %s' % threading.current_thread().name, file=erf) |
Guido van Rossum | be19ed7 | 2007-02-09 05:37:30 +0000 | [diff] [blame] | 393 | print('Client Address: ', client_address, file=erf) |
| 394 | print('Request: ', repr(request), file=erf) |
Kurt B. Kaiser | a00050f | 2003-05-08 20:26:55 +0000 | [diff] [blame] | 395 | traceback.print_exc(file=erf) |
Guido van Rossum | be19ed7 | 2007-02-09 05:37:30 +0000 | [diff] [blame] | 396 | print('\n*** Unrecoverable, server exiting!', file=erf) |
| 397 | print('-'*40, file=erf) |
Kurt B. Kaiser | e953511 | 2004-11-19 15:46:49 +0000 | [diff] [blame] | 398 | quitting = True |
| 399 | thread.interrupt_main() |
Kurt B. Kaiser | a00050f | 2003-05-08 20:26:55 +0000 | [diff] [blame] | 400 | |
Terry Jan Reedy | 6cf0e13 | 2016-07-15 02:43:03 -0400 | [diff] [blame] | 401 | |
| 402 | # Pseudofiles for shell-remote communication (also used in pyshell) |
| 403 | |
Miss Islington (bot) | a1f4500 | 2019-10-08 04:51:16 -0700 | [diff] [blame] | 404 | class StdioFile(io.TextIOBase): |
Terry Jan Reedy | 6cf0e13 | 2016-07-15 02:43:03 -0400 | [diff] [blame] | 405 | |
Miss Islington (bot) | a1f4500 | 2019-10-08 04:51:16 -0700 | [diff] [blame] | 406 | def __init__(self, shell, tags, encoding='utf-8', errors='strict'): |
Terry Jan Reedy | 6cf0e13 | 2016-07-15 02:43:03 -0400 | [diff] [blame] | 407 | self.shell = shell |
| 408 | self.tags = tags |
| 409 | self._encoding = encoding |
Miss Islington (bot) | a1f4500 | 2019-10-08 04:51:16 -0700 | [diff] [blame] | 410 | self._errors = errors |
Terry Jan Reedy | 6cf0e13 | 2016-07-15 02:43:03 -0400 | [diff] [blame] | 411 | |
| 412 | @property |
| 413 | def encoding(self): |
| 414 | return self._encoding |
| 415 | |
| 416 | @property |
Miss Islington (bot) | a1f4500 | 2019-10-08 04:51:16 -0700 | [diff] [blame] | 417 | def errors(self): |
| 418 | return self._errors |
| 419 | |
| 420 | @property |
Terry Jan Reedy | 6cf0e13 | 2016-07-15 02:43:03 -0400 | [diff] [blame] | 421 | def name(self): |
| 422 | return '<%s>' % self.tags |
| 423 | |
| 424 | def isatty(self): |
| 425 | return True |
| 426 | |
| 427 | |
Miss Islington (bot) | a1f4500 | 2019-10-08 04:51:16 -0700 | [diff] [blame] | 428 | class StdOutputFile(StdioFile): |
Terry Jan Reedy | 6cf0e13 | 2016-07-15 02:43:03 -0400 | [diff] [blame] | 429 | |
| 430 | def writable(self): |
| 431 | return True |
| 432 | |
| 433 | def write(self, s): |
| 434 | if self.closed: |
| 435 | raise ValueError("write to closed file") |
Miss Islington (bot) | a1f4500 | 2019-10-08 04:51:16 -0700 | [diff] [blame] | 436 | s = str.encode(s, self.encoding, self.errors).decode(self.encoding, self.errors) |
Terry Jan Reedy | 6cf0e13 | 2016-07-15 02:43:03 -0400 | [diff] [blame] | 437 | return self.shell.write(s, self.tags) |
| 438 | |
| 439 | |
Miss Islington (bot) | a1f4500 | 2019-10-08 04:51:16 -0700 | [diff] [blame] | 440 | class StdInputFile(StdioFile): |
| 441 | _line_buffer = '' |
Terry Jan Reedy | 6cf0e13 | 2016-07-15 02:43:03 -0400 | [diff] [blame] | 442 | |
| 443 | def readable(self): |
| 444 | return True |
| 445 | |
| 446 | def read(self, size=-1): |
| 447 | if self.closed: |
| 448 | raise ValueError("read from closed file") |
| 449 | if size is None: |
| 450 | size = -1 |
| 451 | elif not isinstance(size, int): |
| 452 | raise TypeError('must be int, not ' + type(size).__name__) |
| 453 | result = self._line_buffer |
| 454 | self._line_buffer = '' |
| 455 | if size < 0: |
| 456 | while True: |
| 457 | line = self.shell.readline() |
| 458 | if not line: break |
| 459 | result += line |
| 460 | else: |
| 461 | while len(result) < size: |
| 462 | line = self.shell.readline() |
| 463 | if not line: break |
| 464 | result += line |
| 465 | self._line_buffer = result[size:] |
| 466 | result = result[:size] |
| 467 | return result |
| 468 | |
| 469 | def readline(self, size=-1): |
| 470 | if self.closed: |
| 471 | raise ValueError("read from closed file") |
| 472 | if size is None: |
| 473 | size = -1 |
| 474 | elif not isinstance(size, int): |
| 475 | raise TypeError('must be int, not ' + type(size).__name__) |
| 476 | line = self._line_buffer or self.shell.readline() |
| 477 | if size < 0: |
| 478 | size = len(line) |
| 479 | eol = line.find('\n', 0, size) |
| 480 | if eol >= 0: |
| 481 | size = eol + 1 |
| 482 | self._line_buffer = line[size:] |
| 483 | return line[:size] |
| 484 | |
| 485 | def close(self): |
| 486 | self.shell.close() |
| 487 | |
| 488 | |
Chui Tey | 5d2af63 | 2002-05-26 13:36:41 +0000 | [diff] [blame] | 489 | class MyHandler(rpc.RPCHandler): |
| 490 | |
| 491 | def handle(self): |
Kurt B. Kaiser | 11c53e2 | 2003-03-22 19:40:19 +0000 | [diff] [blame] | 492 | """Override base method""" |
Chui Tey | 5d2af63 | 2002-05-26 13:36:41 +0000 | [diff] [blame] | 493 | executive = Executive(self) |
| 494 | self.register("exec", executive) |
Serhiy Storchaka | 39e70a4 | 2013-01-25 15:30:58 +0200 | [diff] [blame] | 495 | self.console = self.get_remote_proxy("console") |
Miss Islington (bot) | a1f4500 | 2019-10-08 04:51:16 -0700 | [diff] [blame] | 496 | sys.stdin = StdInputFile(self.console, "stdin", |
| 497 | iomenu.encoding, iomenu.errors) |
| 498 | sys.stdout = StdOutputFile(self.console, "stdout", |
| 499 | iomenu.encoding, iomenu.errors) |
| 500 | sys.stderr = StdOutputFile(self.console, "stderr", |
| 501 | iomenu.encoding, "backslashreplace") |
Serhiy Storchaka | 39e70a4 | 2013-01-25 15:30:58 +0200 | [diff] [blame] | 502 | |
Andrew Svetlov | cd49d53 | 2012-03-25 11:43:02 +0300 | [diff] [blame] | 503 | sys.displayhook = rpc.displayhook |
Kurt B. Kaiser | f609a34 | 2007-12-28 03:57:56 +0000 | [diff] [blame] | 504 | # page help() text to shell. |
| 505 | import pydoc # import must be done here to capture i/o binding |
| 506 | pydoc.pager = pydoc.plainpager |
Benjamin Peterson | 0d4931e | 2013-05-11 22:24:28 -0500 | [diff] [blame] | 507 | |
| 508 | # Keep a reference to stdin so that it won't try to exit IDLE if |
| 509 | # sys.stdin gets changed from within IDLE's shell. See issue17838. |
| 510 | self._keep_stdin = sys.stdin |
| 511 | |
Miss Islington (bot) | d4af553 | 2019-07-06 05:54:17 -0700 | [diff] [blame] | 512 | install_recursionlimit_wrappers() |
| 513 | |
Kurt B. Kaiser | 9f36609 | 2003-06-02 01:50:19 +0000 | [diff] [blame] | 514 | self.interp = self.get_remote_proxy("interp") |
Kurt B. Kaiser | a00050f | 2003-05-08 20:26:55 +0000 | [diff] [blame] | 515 | rpc.RPCHandler.getresponse(self, myseq=None, wait=0.05) |
| 516 | |
| 517 | def exithook(self): |
| 518 | "override SocketIO method - wait for MainThread to shut us down" |
Kurt B. Kaiser | 67fd0ea | 2003-05-24 20:59:15 +0000 | [diff] [blame] | 519 | time.sleep(10) |
Kurt B. Kaiser | a00050f | 2003-05-08 20:26:55 +0000 | [diff] [blame] | 520 | |
| 521 | def EOFhook(self): |
| 522 | "Override SocketIO method - terminate wait on callback and exit thread" |
Kurt B. Kaiser | 67fd0ea | 2003-05-24 20:59:15 +0000 | [diff] [blame] | 523 | global quitting |
| 524 | quitting = True |
Kurt B. Kaiser | 93e8e54 | 2003-06-13 22:03:43 +0000 | [diff] [blame] | 525 | thread.interrupt_main() |
Kurt B. Kaiser | a00050f | 2003-05-08 20:26:55 +0000 | [diff] [blame] | 526 | |
| 527 | def decode_interrupthook(self): |
| 528 | "interrupt awakened thread" |
Kurt B. Kaiser | 67fd0ea | 2003-05-24 20:59:15 +0000 | [diff] [blame] | 529 | global quitting |
| 530 | quitting = True |
Kurt B. Kaiser | 93e8e54 | 2003-06-13 22:03:43 +0000 | [diff] [blame] | 531 | thread.interrupt_main() |
Kurt B. Kaiser | 11c53e2 | 2003-03-22 19:40:19 +0000 | [diff] [blame] | 532 | |
Chui Tey | 5d2af63 | 2002-05-26 13:36:41 +0000 | [diff] [blame] | 533 | |
Kurt B. Kaiser | dcba662 | 2004-12-21 22:10:32 +0000 | [diff] [blame] | 534 | class Executive(object): |
Chui Tey | 5d2af63 | 2002-05-26 13:36:41 +0000 | [diff] [blame] | 535 | |
| 536 | def __init__(self, rpchandler): |
Kurt B. Kaiser | ffd3a42 | 2002-06-26 02:32:09 +0000 | [diff] [blame] | 537 | self.rpchandler = rpchandler |
Kurt B. Kaiser | adc6384 | 2002-08-25 14:08:07 +0000 | [diff] [blame] | 538 | self.locals = __main__.__dict__ |
Terry Jan Reedy | 06e2029 | 2018-06-19 23:00:35 -0400 | [diff] [blame] | 539 | self.calltip = calltip.Calltip() |
Terry Jan Reedy | 6fa5bdc | 2016-05-28 13:22:31 -0400 | [diff] [blame] | 540 | self.autocomplete = autocomplete.AutoComplete() |
Chui Tey | 5d2af63 | 2002-05-26 13:36:41 +0000 | [diff] [blame] | 541 | |
| 542 | def runcode(self, code): |
Guido van Rossum | 8ce8a78 | 2007-11-01 19:42:39 +0000 | [diff] [blame] | 543 | global interruptable |
Kurt B. Kaiser | 86bc464 | 2003-02-27 23:04:17 +0000 | [diff] [blame] | 544 | try: |
Kurt B. Kaiser | 9f36609 | 2003-06-02 01:50:19 +0000 | [diff] [blame] | 545 | self.usr_exc_info = None |
Guido van Rossum | 8ce8a78 | 2007-11-01 19:42:39 +0000 | [diff] [blame] | 546 | interruptable = True |
| 547 | try: |
| 548 | exec(code, self.locals) |
| 549 | finally: |
| 550 | interruptable = False |
Terry Jan Reedy | 6d965b3 | 2019-05-19 22:52:22 -0400 | [diff] [blame] | 551 | except SystemExit as e: |
| 552 | if e.args: # SystemExit called with an argument. |
| 553 | ob = e.args[0] |
| 554 | if not isinstance(ob, (type(None), int)): |
| 555 | print('SystemExit: ' + str(ob), file=sys.stderr) |
| 556 | # Return to the interactive prompt. |
Kurt B. Kaiser | 86bc464 | 2003-02-27 23:04:17 +0000 | [diff] [blame] | 557 | except: |
Kurt B. Kaiser | 9f36609 | 2003-06-02 01:50:19 +0000 | [diff] [blame] | 558 | self.usr_exc_info = sys.exc_info() |
Kurt B. Kaiser | 67fd0ea | 2003-05-24 20:59:15 +0000 | [diff] [blame] | 559 | if quitting: |
Kurt B. Kaiser | 62df044 | 2003-05-28 01:47:46 +0000 | [diff] [blame] | 560 | exit() |
Kurt B. Kaiser | 67fd0ea | 2003-05-24 20:59:15 +0000 | [diff] [blame] | 561 | print_exception() |
Kurt B. Kaiser | 9f36609 | 2003-06-02 01:50:19 +0000 | [diff] [blame] | 562 | jit = self.rpchandler.console.getvar("<<toggle-jit-stack-viewer>>") |
| 563 | if jit: |
| 564 | self.rpchandler.interp.open_remote_stack_viewer() |
Kurt B. Kaiser | 11c53e2 | 2003-03-22 19:40:19 +0000 | [diff] [blame] | 565 | else: |
Kurt B. Kaiser | 9ec454e | 2003-05-12 02:33:47 +0000 | [diff] [blame] | 566 | flush_stdout() |
Chui Tey | 5d2af63 | 2002-05-26 13:36:41 +0000 | [diff] [blame] | 567 | |
Kurt B. Kaiser | 003091c | 2003-02-17 18:57:16 +0000 | [diff] [blame] | 568 | def interrupt_the_server(self): |
Guido van Rossum | 8ce8a78 | 2007-11-01 19:42:39 +0000 | [diff] [blame] | 569 | if interruptable: |
| 570 | thread.interrupt_main() |
Kurt B. Kaiser | 11c53e2 | 2003-03-22 19:40:19 +0000 | [diff] [blame] | 571 | |
Kurt B. Kaiser | 0e3a577 | 2002-06-16 03:32:24 +0000 | [diff] [blame] | 572 | def start_the_debugger(self, gui_adap_oid): |
Terry Jan Reedy | 6fa5bdc | 2016-05-28 13:22:31 -0400 | [diff] [blame] | 573 | return debugger_r.start_debugger(self.rpchandler, gui_adap_oid) |
Kurt B. Kaiser | ffd3a42 | 2002-06-26 02:32:09 +0000 | [diff] [blame] | 574 | |
| 575 | def stop_the_debugger(self, idb_adap_oid): |
| 576 | "Unregister the Idb Adapter. Link objects and Idb then subject to GC" |
| 577 | self.rpchandler.unregister(idb_adap_oid) |
Chui Tey | 5d2af63 | 2002-05-26 13:36:41 +0000 | [diff] [blame] | 578 | |
Kurt B. Kaiser | 5afa1df | 2002-10-10 08:25:24 +0000 | [diff] [blame] | 579 | def get_the_calltip(self, name): |
| 580 | return self.calltip.fetch_tip(name) |
| 581 | |
Kurt B. Kaiser | b175445 | 2005-11-18 22:05:48 +0000 | [diff] [blame] | 582 | def get_the_completion_list(self, what, mode): |
| 583 | return self.autocomplete.fetch_completions(what, mode) |
| 584 | |
Chui Tey | 5d2af63 | 2002-05-26 13:36:41 +0000 | [diff] [blame] | 585 | def stackviewer(self, flist_oid=None): |
Kurt B. Kaiser | 9f36609 | 2003-06-02 01:50:19 +0000 | [diff] [blame] | 586 | if self.usr_exc_info: |
| 587 | typ, val, tb = self.usr_exc_info |
| 588 | else: |
Chui Tey | 5d2af63 | 2002-05-26 13:36:41 +0000 | [diff] [blame] | 589 | return None |
| 590 | flist = None |
| 591 | if flist_oid is not None: |
Kurt B. Kaiser | ffd3a42 | 2002-06-26 02:32:09 +0000 | [diff] [blame] | 592 | flist = self.rpchandler.get_remote_proxy(flist_oid) |
Chui Tey | 5d2af63 | 2002-05-26 13:36:41 +0000 | [diff] [blame] | 593 | while tb and tb.tb_frame.f_globals["__name__"] in ["rpc", "run"]: |
| 594 | tb = tb.tb_next |
Kurt B. Kaiser | 9f36609 | 2003-06-02 01:50:19 +0000 | [diff] [blame] | 595 | sys.last_type = typ |
| 596 | sys.last_value = val |
Terry Jan Reedy | 6fa5bdc | 2016-05-28 13:22:31 -0400 | [diff] [blame] | 597 | item = stackviewer.StackTreeItem(flist, tb) |
| 598 | return debugobj_r.remote_object_tree_item(item) |
Terry Jan Reedy | 95a3f11 | 2013-06-28 23:50:12 -0400 | [diff] [blame] | 599 | |
Terry Jan Reedy | 81bb97d | 2019-05-24 21:59:53 -0400 | [diff] [blame] | 600 | |
| 601 | if __name__ == '__main__': |
| 602 | from unittest import main |
| 603 | main('idlelib.idle_test.test_run', verbosity=2) |
| 604 | |
| 605 | capture_warnings(False) # Make sure turned off; see bpo-18081. |