Lib/dos-8x3/tracebac.py

   1 # Format and print Python stack traces
   2
   3 import linecache
   4 import string
   5 import sys
   6 import types
   7
   8 def _print(file, str='', terminator='\n'):
   9         file.write(str+terminator)
  10
  11
  12 def print_list(extracted_list, file=None):
  13         if not file:
  14                 file = sys.stderr
  15         for filename, lineno, name, line in extracted_list:
  16                 _print(file,
  17                        '  File "%s", line %d, in %s' % (filename,lineno,name))
  18                 if line:
  19                         _print(file, '    %s' % string.strip(line))
  20
  21 def format_list(extracted_list):
  22         list = []
  23         for filename, lineno, name, line in extracted_list:
  24                 item = '  File "%s", line %d, in %s\n' % (filename,lineno,name)
  25                 if line:
  26                         item = item + '    %s\n' % string.strip(line)
  27                 list.append(item)
  28         return list
  29
  30
  31 def print_tb(tb, limit=None, file=None):
  32         if not file:
  33                 file = sys.stderr
  34         if limit is None:
  35                 if hasattr(sys, 'tracebacklimit'):
  36                         limit = sys.tracebacklimit
  37         n = 0
  38         while tb is not None and (limit is None or n < limit):
  39                 f = tb.tb_frame
  40                 lineno = tb_lineno(tb)
  41                 co = f.f_code
  42                 filename = co.co_filename
  43                 name = co.co_name
  44                 _print(file,
  45                        '  File "%s", line %d, in %s' % (filename,lineno,name))
  46                 line = linecache.getline(filename, lineno)
  47                 if line: _print(file, '    ' + string.strip(line))
  48                 tb = tb.tb_next
  49                 n = n+1
  50
  51 def format_tb(tb, limit = None):
  52         return format_list(extract_tb(tb, limit))
  53
  54 def extract_tb(tb, limit = None):
  55         if limit is None:
  56                 if hasattr(sys, 'tracebacklimit'):
  57                         limit = sys.tracebacklimit
  58         list = []
  59         n = 0
  60         while tb is not None and (limit is None or n < limit):
  61                 f = tb.tb_frame
  62                 lineno = tb_lineno(tb)
  63                 co = f.f_code
  64                 filename = co.co_filename
  65                 name = co.co_name
  66                 line = linecache.getline(filename, lineno)
  67                 if line: line = string.strip(line)
  68                 else: line = None
  69                 list.append((filename, lineno, name, line))
  70                 tb = tb.tb_next
  71                 n = n+1
  72         return list
  73
  74
  75 def print_exception(etype, value, tb, limit=None, file=None):
  76         if not file:
  77                 file = sys.stderr
  78         if tb:
  79                 _print(file, 'Traceback (innermost last):')
  80                 print_tb(tb, limit, file)
  81         lines = format_exception_only(etype, value)
  82         for line in lines[:-1]:
  83                 _print(file, line, ' ')
  84         _print(file, lines[-1], '')
  85
  86 def format_exception(etype, value, tb, limit = None):
  87         if tb:
  88                 list = ['Traceback (innermost last):\n']
  89                 list = list + format_tb(tb, limit)
  90         else:
  91                 list = []
  92         list = list + format_exception_only(etype, value)
  93         return list
  94
  95 def format_exception_only(etype, value):
  96         list = []
  97         if type(etype) == types.ClassType:
  98                 stype = etype.__name__
  99         else:
 100                 stype = etype
 101         if value is None:
 102                 list.append(str(stype) + '\n')
 103         else:
 104                 if etype is SyntaxError:
 105                         try:
 106                                 msg, (filename, lineno, offset, line) = value
 107                         except:
 108                                 pass
 109                         else:
 110                                 if not filename: filename = "<string>"
 111                                 list.append('  File "%s", line %d\n' %
 112                                             (filename, lineno))
 113                                 i = 0
 114                                 while i < len(line) and \
 115                                       line[i] in string.whitespace:
 116                                         i = i+1
 117                                 list.append('    %s\n' % string.strip(line))
 118                                 s = '    '
 119                                 for c in line[i:offset-1]:
 120                                         if c in string.whitespace:
 121                                                 s = s + c
 122                                         else:
 123                                                 s = s + ' '
 124                                 list.append('%s^\n' % s)
 125                                 value = msg
 126                 list.append('%s: %s\n' % (str(stype), str(value)))
 127         return list
 128
 129
 130 def print_exc(limit=None, file=None):
 131         if not file:
 132                 file = sys.stderr
 133         try:
 134             etype, value, tb = sys.exc_info()
 135             print_exception(etype, value, tb, limit, file)
 136         finally:
 137             etype = value = tb = None
 138
 139 def print_last(limit=None, file=None):
 140         if not file:
 141                 file = sys.stderr
 142         print_exception(sys.last_type, sys.last_value, sys.last_traceback,
 143                         limit, file)
 144
 145
 146 def print_stack(f=None, limit=None, file=None):
 147         if f is None:
 148                 try:
 149                         raise ZeroDivisionError
 150                 except ZeroDivisionError:
 151                         f = sys.exc_info()[2].tb_frame.f_back
 152         print_list(extract_stack(f, limit), file)
 153
 154 def format_stack(f=None, limit=None):
 155         if f is None:
 156                 try:
 157                         raise ZeroDivisionError
 158                 except ZeroDivisionError:
 159                         f = sys.exc_info()[2].tb_frame.f_back
 160         return format_list(extract_stack(f, limit))
 161
 162 def extract_stack(f=None, limit = None):
 163         if f is None:
 164                 try:
 165                         raise ZeroDivisionError
 166                 except ZeroDivisionError:
 167                         f = sys.exc_info()[2].tb_frame.f_back
 168         if limit is None:
 169                 if hasattr(sys, 'tracebacklimit'):
 170                         limit = sys.tracebacklimit
 171         list = []
 172         n = 0
 173         while f is not None and (limit is None or n < limit):
 174                 lineno = f.f_lineno     # XXX Too bad if -O is used
 175                 co = f.f_code
 176                 filename = co.co_filename
 177                 name = co.co_name
 178                 line = linecache.getline(filename, lineno)
 179                 if line: line = string.strip(line)
 180                 else: line = None
 181                 list.append((filename, lineno, name, line))
 182                 f = f.f_back
 183                 n = n+1
 184         list.reverse()
 185         return list
 186
 187 # Calculate the correct line number of the traceback given in tb (even
 188 # with -O on).
 189 # Coded by Marc-Andre Lemburg from the example of PyCode_Addr2Line()
 190 # in compile.c.
 191 # Revised version by Jim Hugunin to work with JPython too.
 192
 193 def tb_lineno(tb):
 194         c = tb.tb_frame.f_code
 195         if not hasattr(c, 'co_lnotab'):
 196                 return tb.tb_lineno
 197
 198         tab = c.co_lnotab
 199         line = c.co_firstlineno
 200         stopat = tb.tb_lasti
 201         addr = 0
 202         for i in range(0, len(tab), 2):
 203                 addr = addr + ord(tab[i])
 204                 if addr > stopat:
 205                         break
 206                 line = line + ord(tab[i+1])
 207         return line