try:
result = eval(expr)
except:
- result = sys.exc_type
+ result = sys.exc_info()[0]
print '->', result
if isinstance(result, str) or isinstance(value, str):
ok = (result == value)
method = getattr(self, methodname)
reply = (None, apply(method, args), id)
except:
- reply = (sys.exc_type, sys.exc_value, id)
+ reply = (sys.exc_info()[:2], id)
if id < 0 and reply[:2] == (None, None):
if self._verbose > 1: print "Suppress reply"
return 1
try:
browserfunc(i_selector, i_host, i_port)
except (IOError, socket.error):
- print '***', sys.exc_type, ':', sys.exc_value
+ t, v, tb = sys.exc_info()
+ print '***', t, ':', v
else:
print 'Unsupported object type'
behave as intended and may fail in mysterious ways.
The error indicator consists of three Python objects corresponding to
-\withsubitem{(in module sys)}{
- \ttindex{exc_type}\ttindex{exc_value}\ttindex{exc_traceback}}
-the Python variables \code{sys.exc_type}, \code{sys.exc_value} and
-\code{sys.exc_traceback}. API functions exist to interact with the
-error indicator in various ways. There is a separate error indicator
-for each thread.
+the result of \code{sys.exc_info()}. API functions exist to interact
+with the error indicator in various ways. There is a separate
+error indicator for each thread.
% XXX Order of these should be more thoughtful.
% Either alphabetical or some kind of structure.
The full exception state consists of three objects (all of which can
be \NULL): the exception type, the corresponding exception
value, and the traceback. These have the same meanings as the Python
-\withsubitem{(in module sys)}{
- \ttindex{exc_type}\ttindex{exc_value}\ttindex{exc_traceback}}
-objects \code{sys.exc_type}, \code{sys.exc_value}, and
-\code{sys.exc_traceback}; however, they are not the same: the Python
+result of \code{sys.exc_info()}; however, they are not the same: the Python
objects represent the last exception being handled by a Python
\keyword{try} \ldots\ \keyword{except} statement, while the C level
exception state only exists while an exception is being passed on
between C functions until it reaches the Python bytecode interpreter's
-main loop, which takes care of transferring it to \code{sys.exc_type}
+main loop, which takes care of transferring it to \code{sys.exc_info()}
and friends.
Note that starting with Python 1.5, the preferred, thread-safe way to
variable stores the ``associated value'' of the exception (the second
argument to \keyword{raise}). A third variable contains the stack
traceback in case the error originated in Python code. These three
-variables are the C equivalents of the Python variables
-\code{sys.exc_type}, \code{sys.exc_value} and \code{sys.exc_traceback} (see
-the section on module \module{sys} in the
+variables are the C equivalents of the result in Python of
+\method{sys.exc_info()} (see the section on module \module{sys} in the
\citetitle[../lib/lib.html]{Python Library Reference}). It is
important to know about them to understand how errors are passed
around.
``wrapper'' around the interpreter.
The module uses traceback objects --- this is the object type that is
-stored in the variables \code{sys.exc_traceback} (deprecated) and
-\code{sys.last_traceback} and returned as the third item from
-\function{sys.exc_info()}.
+stored in the \code{sys.last_traceback} variable and returned
+as the third item from \function{sys.exc_info()}.
\obindex{traceback}
The module defines the following functions:
\end{funcdesc}
\begin{funcdesc}{print_exc}{\optional{limit\optional{, file}}}
-This is a shorthand for \code{print_exception(sys.exc_type,
-sys.exc_value, sys.exc_traceback, \var{limit}, \var{file})}. (In
-fact, it uses \function{sys.exc_info()} to retrieve the same
-information in a thread-safe way instead of using the deprecated
-variables.)
+This is a shorthand for \code{print_exception(*\function{sys.exc_info()}}.
\end{funcdesc}
\begin{funcdesc}{format_exc}{\optional{limit}}
not handle the exception.)
Before an except clause's suite is executed, details about the
-exception are assigned to three variables in the
-\module{sys}\refbimodindex{sys} module: \code{sys.exc_type} receives
-the object identifying the exception; \code{sys.exc_value} receives
-the exception's parameter; \code{sys.exc_traceback} receives a
+exception are stored in the \module{sys}\refbimodindex{sys} module
+and can be access via \function{sys.exc_info()}. \function{sys.exc_info()}
+returns a 3-tuple consisting of: \code{exc_type} receives
+the object identifying the exception; \code{exc_value} receives
+the exception's parameter; \code{exc_traceback} receives a
traceback object\obindex{traceback} (see section~\ref{traceback})
identifying the point in the program where the exception occurred.
-These details are also available through the \function{sys.exc_info()}
-function, which returns a tuple \code{(\var{exc_type}, \var{exc_value},
-\var{exc_traceback})}. Use of the corresponding variables is
-deprecated in favor of this function, since their use is unsafe in a
-threaded program. As of Python 1.5, the variables are restored to
-their previous values (before the call) when returning from a function
-that handled an exception.
-\withsubitem{(in module sys)}{\ttindex{exc_type}
- \ttindex{exc_value}\ttindex{exc_traceback}}
+\function{sys.exc_info()} values are restored to their previous values
+(before the call) when returning from a function that handled an exception.
The optional \keyword{else} clause is executed if and when control
flows off the end of the \keyword{try} clause.\footnote{
except:
# report exception back to server
response = xmlrpclib.dumps(
- xmlrpclib.Fault(1, "%s:%s" % (sys.exc_type, sys.exc_value)),
+ xmlrpclib.Fault(1, "%s:%s" % sys.exc_info()[:2]),
encoding=self.encoding, allow_none=self.allow_none,
)
except:
results.append(
{'faultCode' : 1,
- 'faultString' : "%s:%s" % (sys.exc_type, sys.exc_value)}
+ 'faultString' : "%s:%s" % sys.exc_info()[:2]}
)
return results
try:
callback()
except:
- print "warning: callback failed in WindowList", \
- sys.exc_type, ":", sys.exc_value
+ t, v, tb = sys.exc_info()
+ print "warning: callback failed in WindowList", t, ":", v
registry = WindowList()
def _report_exception(self):
"""Internal function."""
import sys
- exc, val, tb = sys.exc_type, sys.exc_value, sys.exc_traceback
+ exc, val, tb = sys.exc_info()
root = self._root()
root.report_callback_exception(exc, val, tb)
def _configure(self, cmd, cnf, kw):
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.)"""
+ """Shorthand for 'print_exception(*sys.exc_info(), limit, file)'."""
if file is None:
file = sys.stderr
try:
raise 'spam'
except:
pass
- frame = sys.exc_traceback.tb_frame
+ tb = sys.exc_info()[2]
+ frame = tb.tb_frame
while frame is not None:
del frame.f_trace
frame = frame.f_back
raise bdb.BdbQuit
except:
print 'XXX Exception during debugger interaction.', \
- self.formatexception(sys.exc_type, sys.exc_value)
+ self.formatexception(sys.exc_info[:2])
import traceback
traceback.print_exc()
return self.trace_dispatch
try:
raise 'spam'
except:
- frame = sys.exc_traceback.tb_frame.f_back
+ tb = sys.exc_info()[2]
+ frame = tb.tb_frame.f_back
d.start(frame)
def startfrombottom():
raise 'spam'
except:
pass
- frame = sys.exc_traceback.tb_frame
+ tb = sys.exc_info()[2]
+ frame = tb.tb_frame
while 1:
if frame.f_code.co_name == 'mainloop' or frame.f_back is None:
break
except:
if debugging:
sys.settrace(None)
- PyDebugger.postmortem(sys.exc_type, sys.exc_value, sys.exc_traceback)
+ PyDebugger.postmortem(*sys.exc_info())
return
else:
tracebackwindow.traceback(1, filename)
settings = FontSettings.FontDialog(self.fontsettings, self.tabsettings)
if settings:
self.fontsettings, self.tabsettings = settings
- sys.exc_traceback = None
self.w.fonttext.set(self.template % (self.fontsettings[0], self.fontsettings[2]))
def close(self):
fontsettings = prefs.pyedit.fontsettings = ("Geneva", 0, 10, (0, 0, 0))
tabsettings = prefs.pyedit.tabsettings = (8, 1)
windowsize = prefs.pyedit.windowsize = (500, 250)
- sys.exc_traceback = None
return fontsettings, tabsettings, windowsize
def seteditorprefs(fontsettings, tabsettings, windowsize):
Py_XDECREF(tmp_type);
Py_XDECREF(tmp_value);
Py_XDECREF(tmp_tb);
- /* For b/w compatibility */
- PySys_SetObject("exc_type", Py_None);
- PySys_SetObject("exc_value", Py_None);
- PySys_SetObject("exc_traceback", Py_None);
Py_INCREF(Py_None);
return Py_None;
}
except SystemExit, n:
sys.exit(n)
except:
- t, v, tb = sys.exc_type, sys.exc_value, sys.exc_traceback
+ t, v, tb = sys.exc_info()
print
import cgi
cgi.print_exception(t, v, tb)
projects / python / commitdiff