You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
301 lines
10 KiB
301 lines
10 KiB
"""Extract, format and print information about Python stack traces.""" |
|
|
|
import linecache |
|
import sys |
|
import types |
|
|
|
__all__ = ['extract_stack', 'extract_tb', 'format_exception', |
|
'format_exception_only', 'format_list', 'format_stack', |
|
'format_tb', 'print_exc', 'print_exception', 'print_last', |
|
'print_stack', 'print_tb', 'tb_lineno'] |
|
|
|
def _print(file, str='', terminator='\n'): |
|
file.write(str+terminator) |
|
|
|
|
|
def print_list(extracted_list, file=None): |
|
"""Print the list of tuples as returned by extract_tb() or |
|
extract_stack() as a formatted stack trace to the given file.""" |
|
if not file: |
|
file = sys.stderr |
|
for filename, lineno, name, line in extracted_list: |
|
_print(file, |
|
' File "%s", line %d, in %s' % (filename,lineno,name)) |
|
if line: |
|
_print(file, ' %s' % line.strip()) |
|
|
|
def format_list(extracted_list): |
|
"""Format a list of traceback entry tuples for printing. |
|
|
|
Given a list of tuples as returned by extract_tb() or |
|
extract_stack(), return a list of strings ready for printing. |
|
Each string in the resulting list corresponds to the item with the |
|
same index in the argument list. Each string ends in a newline; |
|
the strings may contain internal newlines as well, for those items |
|
whose source text line is not None. |
|
""" |
|
list = [] |
|
for filename, lineno, name, line in extracted_list: |
|
item = ' File "%s", line %d, in %s\n' % (filename,lineno,name) |
|
if line: |
|
item = item + ' %s\n' % line.strip() |
|
list.append(item) |
|
return list |
|
|
|
|
|
def print_tb(tb, limit=None, file=None): |
|
"""Print up to 'limit' stack trace entries from the traceback 'tb'. |
|
|
|
If 'limit' is omitted or None, all entries are printed. If 'file' |
|
is omitted or None, the output goes to sys.stderr; otherwise |
|
'file' should be an open file or file-like object with a write() |
|
method. |
|
""" |
|
if not file: |
|
file = sys.stderr |
|
if limit is None: |
|
if hasattr(sys, 'tracebacklimit'): |
|
limit = sys.tracebacklimit |
|
n = 0 |
|
while tb is not None and (limit is None or n < limit): |
|
f = tb.tb_frame |
|
lineno = tb_lineno(tb) |
|
co = f.f_code |
|
filename = co.co_filename |
|
name = co.co_name |
|
_print(file, |
|
' File "%s", line %d, in %s' % (filename,lineno,name)) |
|
line = linecache.getline(filename, lineno) |
|
if line: _print(file, ' ' + line.strip()) |
|
tb = tb.tb_next |
|
n = n+1 |
|
|
|
def format_tb(tb, limit = None): |
|
"""A shorthand for 'format_list(extract_stack(f, limit)).""" |
|
return format_list(extract_tb(tb, limit)) |
|
|
|
def extract_tb(tb, limit = None): |
|
"""Return list of up to limit pre-processed entries from traceback. |
|
|
|
This is useful for alternate formatting of stack traces. If |
|
'limit' is omitted or None, all entries are extracted. A |
|
pre-processed stack trace entry is a quadruple (filename, line |
|
number, function name, text) representing the information that is |
|
usually printed for a stack trace. The text is a string with |
|
leading and trailing whitespace stripped; if the source is not |
|
available it is None. |
|
""" |
|
if limit is None: |
|
if hasattr(sys, 'tracebacklimit'): |
|
limit = sys.tracebacklimit |
|
list = [] |
|
n = 0 |
|
while tb is not None and (limit is None or n < limit): |
|
f = tb.tb_frame |
|
lineno = tb_lineno(tb) |
|
co = f.f_code |
|
filename = co.co_filename |
|
name = co.co_name |
|
line = linecache.getline(filename, lineno) |
|
if line: line = line.strip() |
|
else: line = None |
|
list.append((filename, lineno, name, line)) |
|
tb = tb.tb_next |
|
n = n+1 |
|
return list |
|
|
|
|
|
def print_exception(etype, value, tb, limit=None, file=None): |
|
"""Print exception up to 'limit' stack trace entries from 'tb' to 'file'. |
|
|
|
This differs from print_tb() in the following ways: (1) if |
|
traceback is not None, it prints a header "Traceback (most recent |
|
call last):"; (2) it prints the exception type and value after the |
|
stack trace; (3) if type is SyntaxError and value has the |
|
appropriate format, it prints the line where the syntax error |
|
occurred with a caret on the next line indicating the approximate |
|
position of the error. |
|
""" |
|
if not file: |
|
file = sys.stderr |
|
if tb: |
|
_print(file, 'Traceback (most recent call last):') |
|
print_tb(tb, limit, file) |
|
lines = format_exception_only(etype, value) |
|
for line in lines[:-1]: |
|
_print(file, line, ' ') |
|
_print(file, lines[-1], '') |
|
|
|
def format_exception(etype, value, tb, limit = None): |
|
"""Format a stack trace and the exception information. |
|
|
|
The arguments have the same meaning as the corresponding arguments |
|
to print_exception(). The return value is a list of strings, each |
|
ending in a newline and some containing internal newlines. When |
|
these lines are concatenated and printed, exactly the same text is |
|
printed as does print_exception(). |
|
""" |
|
if tb: |
|
list = ['Traceback (most recent call last):\n'] |
|
list = list + format_tb(tb, limit) |
|
else: |
|
list = [] |
|
list = list + format_exception_only(etype, value) |
|
return list |
|
|
|
def format_exception_only(etype, value): |
|
"""Format the exception part of a traceback. |
|
|
|
The arguments are the exception type and value such as given by |
|
sys.last_type and sys.last_value. The return value is a list of |
|
strings, each ending in a newline. Normally, the list contains a |
|
single string; however, for SyntaxError exceptions, it contains |
|
several lines that (when printed) display detailed information |
|
about where the syntax error occurred. The message indicating |
|
which exception occurred is the always last string in the list. |
|
""" |
|
list = [] |
|
if type(etype) == types.ClassType: |
|
stype = etype.__name__ |
|
else: |
|
stype = etype |
|
if value is None: |
|
list.append(str(stype) + '\n') |
|
else: |
|
if etype is SyntaxError: |
|
try: |
|
msg, (filename, lineno, offset, line) = value |
|
except: |
|
pass |
|
else: |
|
if not filename: filename = "<string>" |
|
list.append(' File "%s", line %d\n' % |
|
(filename, lineno)) |
|
if line is not None: |
|
i = 0 |
|
while i < len(line) and line[i].isspace(): |
|
i = i+1 |
|
list.append(' %s\n' % line.strip()) |
|
if offset is not None: |
|
s = ' ' |
|
for c in line[i:offset-1]: |
|
if c.isspace(): |
|
s = s + c |
|
else: |
|
s = s + ' ' |
|
list.append('%s^\n' % s) |
|
value = msg |
|
s = _some_str(value) |
|
if s: |
|
list.append('%s: %s\n' % (str(stype), s)) |
|
else: |
|
list.append('%s\n' % str(stype)) |
|
return list |
|
|
|
def _some_str(value): |
|
try: |
|
return str(value) |
|
except: |
|
return '<unprintable %s object>' % type(value).__name__ |
|
|
|
|
|
def print_exc(limit=None, file=None): |
|
"""Shorthand for 'print_exception(sys.exc_type, sys.exc_value, sys.exc_traceback, limit, file)'. |
|
(In fact, it uses sys.exc_info() to retrieve the same information |
|
in a thread-safe way.)""" |
|
if not file: |
|
file = sys.stderr |
|
try: |
|
etype, value, tb = sys.exc_info() |
|
print_exception(etype, value, tb, limit, file) |
|
finally: |
|
etype = value = tb = None |
|
|
|
def print_last(limit=None, file=None): |
|
"""This is a shorthand for 'print_exception(sys.last_type, |
|
sys.last_value, sys.last_traceback, limit, file)'.""" |
|
if not file: |
|
file = sys.stderr |
|
print_exception(sys.last_type, sys.last_value, sys.last_traceback, |
|
limit, file) |
|
|
|
|
|
def print_stack(f=None, limit=None, file=None): |
|
"""Print a stack trace from its invocation point. |
|
|
|
The optional 'f' argument can be used to specify an alternate |
|
stack frame at which to start. The optional 'limit' and 'file' |
|
arguments have the same meaning as for print_exception(). |
|
""" |
|
if f is None: |
|
try: |
|
raise ZeroDivisionError |
|
except ZeroDivisionError: |
|
f = sys.exc_info()[2].tb_frame.f_back |
|
print_list(extract_stack(f, limit), file) |
|
|
|
def format_stack(f=None, limit=None): |
|
"""Shorthand for 'format_list(extract_stack(f, limit))'.""" |
|
if f is None: |
|
try: |
|
raise ZeroDivisionError |
|
except ZeroDivisionError: |
|
f = sys.exc_info()[2].tb_frame.f_back |
|
return format_list(extract_stack(f, limit)) |
|
|
|
def extract_stack(f=None, limit = None): |
|
"""Extract the raw traceback from the current stack frame. |
|
|
|
The return value has the same format as for extract_tb(). The |
|
optional 'f' and 'limit' arguments have the same meaning as for |
|
print_stack(). Each item in the list is a quadruple (filename, |
|
line number, function name, text), and the entries are in order |
|
from oldest to newest stack frame. |
|
""" |
|
if f is None: |
|
try: |
|
raise ZeroDivisionError |
|
except ZeroDivisionError: |
|
f = sys.exc_info()[2].tb_frame.f_back |
|
if limit is None: |
|
if hasattr(sys, 'tracebacklimit'): |
|
limit = sys.tracebacklimit |
|
list = [] |
|
n = 0 |
|
while f is not None and (limit is None or n < limit): |
|
lineno = f.f_lineno # XXX Too bad if -O is used |
|
co = f.f_code |
|
filename = co.co_filename |
|
name = co.co_name |
|
line = linecache.getline(filename, lineno) |
|
if line: line = line.strip() |
|
else: line = None |
|
list.append((filename, lineno, name, line)) |
|
f = f.f_back |
|
n = n+1 |
|
list.reverse() |
|
return list |
|
|
|
def tb_lineno(tb): |
|
"""Calculate correct line number of traceback given in tb. |
|
|
|
Even works with -O on. |
|
""" |
|
# Coded by Marc-Andre Lemburg from the example of PyCode_Addr2Line() |
|
# in compile.c. |
|
# Revised version by Jim Hugunin to work with JPython too. |
|
|
|
c = tb.tb_frame.f_code |
|
if not hasattr(c, 'co_lnotab'): |
|
return tb.tb_lineno |
|
|
|
tab = c.co_lnotab |
|
line = c.co_firstlineno |
|
stopat = tb.tb_lasti |
|
addr = 0 |
|
for i in range(0, len(tab), 2): |
|
addr = addr + ord(tab[i]) |
|
if addr > stopat: |
|
break |
|
line = line + ord(tab[i+1]) |
|
return line
|
|
|