continue_stmt: 'continue'
return_stmt: 'return' [testlist]
yield_stmt: yield_expr
-raise_stmt: 'raise' [test [',' test [',' test]]]
+raise_stmt: 'raise' [test ['from' test]]
import_stmt: import_name | import_from
import_name: 'import' dotted_as_names
# note below: the ('.' | '...') is necessary because '...' is tokenized as ELLIPSIS
} With;
struct {
- expr_ty type;
- expr_ty inst;
- expr_ty tback;
+ expr_ty exc;
+ expr_ty cause;
} Raise;
struct {
#define With(a0, a1, a2, a3, a4, a5) _Py_With(a0, a1, a2, a3, a4, a5)
stmt_ty _Py_With(expr_ty context_expr, expr_ty optional_vars, asdl_seq * body,
int lineno, int col_offset, PyArena *arena);
-#define Raise(a0, a1, a2, a3, a4, a5) _Py_Raise(a0, a1, a2, a3, a4, a5)
-stmt_ty _Py_Raise(expr_ty type, expr_ty inst, expr_ty tback, int lineno, int
- col_offset, PyArena *arena);
+#define Raise(a0, a1, a2, a3, a4) _Py_Raise(a0, a1, a2, a3, a4)
+stmt_ty _Py_Raise(expr_ty exc, expr_ty cause, int lineno, int col_offset,
+ PyArena *arena);
#define TryExcept(a0, a1, a2, a3, a4, a5) _Py_TryExcept(a0, a1, a2, a3, a4, a5)
stmt_ty _Py_TryExcept(asdl_seq * body, asdl_seq * handlers, asdl_seq * orelse,
int lineno, int col_offset, PyArena *arena);
/* Error objects */
+/* PyException_HEAD defines the initial segment of every exception class. */
+#define PyException_HEAD PyObject_HEAD; PyObject *dict;\
+ PyObject *args; PyObject *traceback;\
+ PyObject *context; PyObject *cause;
+
typedef struct {
- PyObject_HEAD
- PyObject *dict;
- PyObject *args;
+ PyException_HEAD
} PyBaseExceptionObject;
typedef struct {
- PyObject_HEAD
- PyObject *dict;
- PyObject *args;
+ PyException_HEAD
PyObject *msg;
PyObject *filename;
PyObject *lineno;
} PySyntaxErrorObject;
typedef struct {
- PyObject_HEAD
- PyObject *dict;
- PyObject *args;
+ PyException_HEAD
PyObject *encoding;
PyObject *object;
Py_ssize_t start;
} PyUnicodeErrorObject;
typedef struct {
- PyObject_HEAD
- PyObject *dict;
- PyObject *args;
+ PyException_HEAD
PyObject *code;
} PySystemExitObject;
typedef struct {
- PyObject_HEAD
- PyObject *dict;
- PyObject *args;
+ PyException_HEAD
PyObject *myerrno;
PyObject *strerror;
PyObject *filename;
#ifdef MS_WINDOWS
typedef struct {
- PyObject_HEAD
- PyObject *dict;
- PyObject *args;
+ PyException_HEAD
PyObject *myerrno;
PyObject *strerror;
PyObject *filename;
PyAPI_FUNC(int) PyErr_ExceptionMatches(PyObject *);
PyAPI_FUNC(void) PyErr_NormalizeException(PyObject**, PyObject**, PyObject**);
+/* Traceback manipulation (PEP 3134) */
+PyAPI_FUNC(int) PyException_SetTraceback(PyObject *, PyObject *);
+PyAPI_FUNC(PyObject *) PyException_GetTraceback(PyObject *);
+
+/* Cause manipulation (PEP 3134) */
+PyAPI_FUNC(PyObject *) PyException_GetCause(PyObject *);
+PyAPI_FUNC(void) PyException_SetCause(PyObject *, PyObject *);
+
+/* Context manipulation (PEP 3134) */
+PyAPI_FUNC(PyObject *) PyException_GetContext(PyObject *);
+PyAPI_FUNC(void) PyException_SetContext(PyObject *, PyObject *);
+
+
/* */
#define PyExceptionClass_Check(x) \
#define PyExceptionInstance_Class(x) ((PyObject*)((x)->ob_type))
-
+
/* Predefined exceptions */
PyAPI_DATA(PyObject *) PyExc_BaseException;
PyAPI_FUNC(int) PyErr_WarnEx(PyObject *category, const char *msg,
Py_ssize_t stack_level);
PyAPI_FUNC(int) PyErr_WarnExplicit(PyObject *, const char *,
- const char *, int,
+ const char *, int,
const char *, PyObject *);
/* In sigcheck.c or signalmodule.c */
# Don't rely on sys.exc_info() still containing
# the right information. Another exception may
# have been raised and caught by an exit method
- raise exc[0], exc[1], exc[2]
+ raise exc[0](exc[1]).with_traceback(exc[2])
class closing(object):
'42\n'
>>> exc_info = failure.exc_info
- >>> raise exc_info[0], exc_info[1], exc_info[2]
+ >>> raise exc_info[1] # Already has the traceback
Traceback (most recent call last):
...
KeyError
'42\n'
>>> exc_info = failure.exc_info
- >>> raise exc_info[0], exc_info[1], exc_info[2]
+ >>> raise exc_info[1] # Already has the traceback
Traceback (most recent call last):
...
KeyError
del ce
else:
- raise ImportError, 'no os specific module found'
+ raise ImportError('no os specific module found')
sys.modules['os.path'] = path
from os.path import curdir, pardir, sep, pathsep, defpath, altsep, devnull
saved_exc = e
saved_tb = tb
if saved_exc:
- raise error, saved_exc, saved_tb
- raise error, last_exc, tb
+ raise error(saved_exc).with_traceback(saved_tb)
+ raise error(last_exc).with_traceback(tb)
# Change environ to automatically call putenv(), unsetenv if they exist.
elif WIFEXITED(sts):
return WEXITSTATUS(sts)
else:
- raise error, "Not stopped, signaled or exited???"
+ raise error("Not stopped, signaled or exited???")
def spawnv(mode, file, args):
"""spawnv(mode, file, args) -> integer
# If
"if v:pass",
# Raise
- "raise Exception, 'string'",
+ "raise Exception('string')",
# TryExcept
"try:\n pass\nexcept Exception:\n pass",
# TryFinally
('Module', [('For', (1, 0), ('Name', (1, 4), 'v', ('Store',)), ('Name', (1, 9), 'v', ('Load',)), [('Pass', (1, 11))], [])]),
('Module', [('While', (1, 0), ('Name', (1, 6), 'v', ('Load',)), [('Pass', (1, 8))], [])]),
('Module', [('If', (1, 0), ('Name', (1, 3), 'v', ('Load',)), [('Pass', (1, 5))], [])]),
-('Module', [('Raise', (1, 0), ('Name', (1, 6), 'Exception', ('Load',)), ('Str', (1, 17), 'string'), None)]),
+('Module', [('Raise', (1, 0), ('Call', (1, 6), ('Name', (1, 6), 'Exception', ('Load',)), [('Str', (1, 16), 'string')], [], None, None), None)]),
('Module', [('TryExcept', (1, 0), [('Pass', (2, 2))], [('excepthandler', (3, 0), ('Name', (3, 7), 'Exception', ('Load',)), None, [('Pass', (4, 2))], 3, 0)], [])]),
('Module', [('TryFinally', (1, 0), [('Pass', (2, 2))], [('Pass', (4, 2))])]),
('Module', [('Assert', (1, 0), ('Name', (1, 7), 'v', ('Load',)), None)]),
def raise_catch(self, exc, excname):
try:
- raise exc, "spam"
+ raise exc("spam")
except exc as err:
buf1 = str(err)
try:
class BadException(Exception):
def __init__(self_):
- raise RuntimeError, "can't instantiate BadException"
+ raise RuntimeError("can't instantiate BadException")
class InvalidException:
pass
'pickled "%r", attribute "%s' %
(e, checkArgName))
+ def testWithTraceback(self):
+ try:
+ raise IndexError(4)
+ except:
+ tb = sys.exc_info()[2]
+
+ e = BaseException().with_traceback(tb)
+ self.failUnless(isinstance(e, BaseException))
+ self.assertEqual(e.__traceback__, tb)
+
+ e = IndexError(5).with_traceback(tb)
+ self.failUnless(isinstance(e, IndexError))
+ self.assertEqual(e.__traceback__, tb)
+
+ class MyException(Exception):
+ pass
+
+ e = MyException().with_traceback(tb)
+ self.failUnless(isinstance(e, MyException))
+ self.assertEqual(e.__traceback__, tb)
+
+ def testInvalidTraceback(self):
+ try:
+ Exception().__traceback__ = 5
+ except TypeError as e:
+ self.failUnless("__traceback__ must be a traceback" in str(e))
+ else:
+ self.fail("No exception raised")
+
+ def testNoneClearsTracebackAttr(self):
+ try:
+ raise IndexError(4)
+ except:
+ tb = sys.exc_info()[2]
+
+ e = Exception()
+ e.__traceback__ = tb
+ e.__traceback__ = None
+ self.assertEqual(e.__traceback__, None)
+
+ def testChainingAttrs(self):
+ e = Exception()
+ self.assertEqual(e.__context__, None)
+ self.assertEqual(e.__cause__, None)
+
+ e = TypeError()
+ self.assertEqual(e.__context__, None)
+ self.assertEqual(e.__cause__, None)
+
+ class MyException(EnvironmentError):
+ pass
+
+ e = MyException()
+ self.assertEqual(e.__context__, None)
+ self.assertEqual(e.__cause__, None)
+
def testKeywordArgs(self):
# test that builtin exception don't take keyword args,
# but user-defined subclasses can if they want
def testRaise(self):
# 'raise' test [',' test]
- try: raise RuntimeError, 'just testing'
+ try: raise RuntimeError('just testing')
except RuntimeError: pass
try: raise KeyboardInterrupt
except KeyboardInterrupt: pass
a = AClass()
b = BClass()
- try: raise AClass, b
- except BClass as v:
- if v != b: self.fail("v!=b")
- else: self.fail("no exception")
-
- try: raise b
+ try:
+ raise b
except AClass as v:
- if v != b: self.fail("v!=b AClass")
+ self.assertEqual(v, b)
else:
self.fail("no exception")
##except TypeError: pass
##else: self.fail("no exception")
- try: raise DClass, a
+ try: raise DClass(a)
except DClass as v:
self.assert_(isinstance(v, DClass))
else:
--- /dev/null
+# Copyright 2007 Google, Inc. All Rights Reserved.
+# Licensed to PSF under a Contributor Agreement.
+
+"""Tests for the raise statement."""
+
+from test import test_support
+import sys
+import types
+import unittest
+
+
+def get_tb():
+ try:
+ raise OSError()
+ except:
+ return sys.exc_info()[2]
+
+
+class TestRaise(unittest.TestCase):
+ def test_invalid_reraise(self):
+ try:
+ raise
+ except RuntimeError as e:
+ self.failUnless("No active exception" in str(e))
+ else:
+ self.fail("No exception raised")
+
+ def test_reraise(self):
+ try:
+ try:
+ raise IndexError()
+ except IndexError as e:
+ exc1 = e
+ raise
+ except IndexError as exc2:
+ self.failUnless(exc1 is exc2)
+ else:
+ self.fail("No exception raised")
+
+
+class TestCause(unittest.TestCase):
+ def test_invalid_cause(self):
+ try:
+ raise IndexError from 5
+ except TypeError as e:
+ self.failUnless("exception cause" in str(e))
+ else:
+ self.fail("No exception raised")
+
+ def test_class_cause(self):
+ try:
+ raise IndexError from KeyError
+ except IndexError as e:
+ self.failUnless(isinstance(e.__cause__, KeyError))
+ else:
+ self.fail("No exception raised")
+
+ def test_instance_cause(self):
+ cause = KeyError()
+ try:
+ raise IndexError from cause
+ except IndexError as e:
+ self.failUnless(e.__cause__ is cause)
+ else:
+ self.fail("No exception raised")
+
+
+class TestTraceback(unittest.TestCase):
+ def test_sets_traceback(self):
+ try:
+ raise IndexError()
+ except IndexError as e:
+ self.failUnless(isinstance(e.__traceback__, types.TracebackType))
+ else:
+ self.fail("No exception raised")
+
+ def test_accepts_traceback(self):
+ tb = get_tb()
+ try:
+ raise IndexError().with_traceback(tb)
+ except IndexError as e:
+ self.assertNotEqual(e.__traceback__, tb)
+ self.assertEqual(e.__traceback__.tb_next, tb)
+ else:
+ self.fail("No exception raised")
+
+
+# Disabled until context is implemented
+# class TestContext(object):
+# def test_instance_context_bare_raise(self):
+# context = IndexError()
+# try:
+# try:
+# raise context
+# except:
+# raise OSError()
+# except OSError as e:
+# self.assertEqual(e.__context__, context)
+# else:
+# self.fail("No exception raised")
+#
+# def test_class_context_bare_raise(self):
+# context = IndexError
+# try:
+# try:
+# raise context
+# except:
+# raise OSError()
+# except OSError as e:
+# self.assertNotEqual(e.__context__, context)
+# self.failUnless(isinstance(e.__context__, context))
+# else:
+# self.fail("No exception raised")
+
+
+class TestRemovedFunctionality(unittest.TestCase):
+ def test_tuples(self):
+ try:
+ raise (IndexError, KeyError) # This should be a tuple!
+ except TypeError:
+ pass
+ else:
+ self.fail("No exception raised")
+
+ def test_strings(self):
+ try:
+ raise "foo"
+ except TypeError:
+ pass
+ else:
+ self.fail("No exception raised")
+
+
+def test_main():
+ test_support.run_unittest(__name__)
+
+
+if __name__ == "__main__":
+ unittest.main()
+# Copyright 2007 Google, Inc. All Rights Reserved.
+# Licensed to PSF under a Contributor Agreement.
+
+"""Tests for the raise statement."""
+
+from test import test_support
+import sys
+import types
+import unittest
+
+
+def get_tb():
+ try:
+ raise OSError()
+ except:
+ return sys.exc_info()[2]
+
+
+class TestRaise(unittest.TestCase):
+ def test_invalid_reraise(self):
+ try:
+ raise
+ except RuntimeError as e:
+ self.failUnless("No active exception" in str(e))
+ else:
+ self.fail("No exception raised")
+
+ def test_reraise(self):
+ try:
+ try:
+ raise IndexError()
+ except IndexError as e:
+ exc1 = e
+ raise
+ except IndexError as exc2:
+ self.failUnless(exc1 is exc2)
+ else:
+ self.fail("No exception raised")
+
+
+class TestCause(unittest.TestCase):
+ def test_invalid_cause(self):
+ try:
+ raise IndexError from 5
+ except TypeError as e:
+ self.failUnless("exception cause" in str(e))
+ else:
+ self.fail("No exception raised")
+
+ def test_class_cause(self):
+ try:
+ raise IndexError from KeyError
+ except IndexError as e:
+ self.failUnless(isinstance(e.__cause__, KeyError))
+ else:
+ self.fail("No exception raised")
+
+ def test_instance_cause(self):
+ cause = KeyError()
+ try:
+ raise IndexError from cause
+ except IndexError as e:
+ self.failUnless(e.__cause__ is cause)
+ else:
+ self.fail("No exception raised")
+
+
+class TestTraceback(unittest.TestCase):
+ def test_sets_traceback(self):
+ try:
+ raise IndexError()
+ except IndexError as e:
+ self.failUnless(isinstance(e.__traceback__, types.TracebackType))
+ else:
+ self.fail("No exception raised")
+
+ def test_accepts_traceback(self):
+ tb = get_tb()
+ try:
+ raise IndexError().with_traceback(tb)
+ except IndexError as e:
+ self.assertNotEqual(e.__traceback__, tb)
+ self.assertEqual(e.__traceback__.tb_next, tb)
+ else:
+ self.fail("No exception raised")
+
+
+# Disabled until context is implemented
+# class TestContext(object):
+# def test_instance_context_bare_raise(self):
+# context = IndexError()
+# try:
+# try:
+# raise context
+# except:
+# raise OSError()
+# except OSError as e:
+# self.assertEqual(e.__context__, context)
+# else:
+# self.fail("No exception raised")
+#
+# def test_class_context_bare_raise(self):
+# context = IndexError
+# try:
+# try:
+# raise context
+# except:
+# raise OSError()
+# except OSError as e:
+# self.assertNotEqual(e.__context__, context)
+# self.failUnless(isinstance(e.__context__, context))
+# else:
+# self.fail("No exception raised")
+
+
+class TestRemovedFunctionality(unittest.TestCase):
+ def test_tuples(self):
+ try:
+ raise (IndexError, KeyError) # This should be a tuple!
+ except TypeError:
+ pass
+ else:
+ self.fail("No exception raised")
+
+ def test_strings(self):
+ try:
+ raise "foo"
+ except TypeError:
+ pass
+ else:
+ self.fail("No exception raised")
+
+
+def test_main():
+ test_support.run_unittest(__name__)
+
+
+if __name__ == "__main__":
+ unittest.main()
+# Copyright 2007 Google, Inc. All Rights Reserved.
+# Licensed to PSF under a Contributor Agreement.
+
+"""Tests for the raise statement."""
+
+from test import test_support
+import sys
+import types
+import unittest
+
+
+def get_tb():
+ try:
+ raise OSError()
+ except:
+ return sys.exc_info()[2]
+
+
+class TestRaise(unittest.TestCase):
+ def test_invalid_reraise(self):
+ try:
+ raise
+ except RuntimeError as e:
+ self.failUnless("No active exception" in str(e))
+ else:
+ self.fail("No exception raised")
+
+ def test_reraise(self):
+ try:
+ try:
+ raise IndexError()
+ except IndexError as e:
+ exc1 = e
+ raise
+ except IndexError as exc2:
+ self.failUnless(exc1 is exc2)
+ else:
+ self.fail("No exception raised")
+
+
+class TestCause(unittest.TestCase):
+ def test_invalid_cause(self):
+ try:
+ raise IndexError from 5
+ except TypeError as e:
+ self.failUnless("exception cause" in str(e))
+ else:
+ self.fail("No exception raised")
+
+ def test_class_cause(self):
+ try:
+ raise IndexError from KeyError
+ except IndexError as e:
+ self.failUnless(isinstance(e.__cause__, KeyError))
+ else:
+ self.fail("No exception raised")
+
+ def test_instance_cause(self):
+ cause = KeyError()
+ try:
+ raise IndexError from cause
+ except IndexError as e:
+ self.failUnless(e.__cause__ is cause)
+ else:
+ self.fail("No exception raised")
+
+
+class TestTraceback(unittest.TestCase):
+ def test_sets_traceback(self):
+ try:
+ raise IndexError()
+ except IndexError as e:
+ self.failUnless(isinstance(e.__traceback__, types.TracebackType))
+ else:
+ self.fail("No exception raised")
+
+ def test_accepts_traceback(self):
+ tb = get_tb()
+ try:
+ raise IndexError().with_traceback(tb)
+ except IndexError as e:
+ self.assertNotEqual(e.__traceback__, tb)
+ self.assertEqual(e.__traceback__.tb_next, tb)
+ else:
+ self.fail("No exception raised")
+
+
+# Disabled until context is implemented
+# class TestContext(object):
+# def test_instance_context_bare_raise(self):
+# context = IndexError()
+# try:
+# try:
+# raise context
+# except:
+# raise OSError()
+# except OSError as e:
+# self.assertEqual(e.__context__, context)
+# else:
+# self.fail("No exception raised")
+#
+# def test_class_context_bare_raise(self):
+# context = IndexError
+# try:
+# try:
+# raise context
+# except:
+# raise OSError()
+# except OSError as e:
+# self.assertNotEqual(e.__context__, context)
+# self.failUnless(isinstance(e.__context__, context))
+# else:
+# self.fail("No exception raised")
+
+
+class TestRemovedFunctionality(unittest.TestCase):
+ def test_tuples(self):
+ try:
+ raise (IndexError, KeyError) # This should be a tuple!
+ except TypeError:
+ pass
+ else:
+ self.fail("No exception raised")
+
+ def test_strings(self):
+ try:
+ raise "foo"
+ except TypeError:
+ pass
+ else:
+ self.fail("No exception raised")
+
+
+def test_main():
+ test_support.run_unittest(__name__)
+
+
+if __name__ == "__main__":
+ unittest.main()
...
SyntaxError: can't assign to function call
+Make sure that the old "raise X, Y[, Z]" form is gone:
+ >>> raise X, Y
+ Traceback (most recent call last):
+ ...
+ SyntaxError: invalid syntax
+ >>> raise X, Y, Z
+ Traceback (most recent call last):
+ ...
+ SyntaxError: invalid syntax
+
"""
import re
# test that the exit machinery handles SystemExits properly
import subprocess
- # both unnormalized...
- rc = subprocess.call([sys.executable, "-c",
- "raise SystemExit, 46"])
- self.assertEqual(rc, 46)
- # ... and normalized
rc = subprocess.call([sys.executable, "-c",
"raise SystemExit(47)"])
self.assertEqual(rc, 47)
ex = sys.exc_info()
self.entered = None
if ex is not exc_info:
- raise ex[0], ex[1], ex[2]
+ raise ex[0](ex[1]).with_traceback(ex[2])
class MockNested(Nested):
def get_file():
return __file__
if __loader__.get_data("some.data") != b"some data":
- raise AssertionError, "bad data"\n"""
+ raise AssertionError("bad data")\n"""
pyc = make_pyc(compile(src, "<???>", "exec"), NOW)
files = {TESTMOD + pyc_ext: (NOW, pyc),
"some.data": (NOW, "some data")}
else:
return getattr(self, name)(url, data)
except socket.error as msg:
- raise IOError, ('socket error', msg), sys.exc_info()[2]
+ raise IOError('socket error', msg).with_traceback(sys.exc_info()[2])
def open_unknown(self, fullurl, data=None):
"""Overridable interface to open unknown URL type."""
headers = mimetools.Message(StringIO(headers))
return addinfourl(fp, headers, "ftp:" + url)
except ftperrors() as msg:
- raise IOError, ('ftp error', msg), sys.exc_info()[2]
+ raise IOError('ftp error', msg).with_traceback(sys.exc_info()[2])
def open_data(self, url, data=None):
"""Use "data" URL."""
conn = self.ftp.ntransfercmd(cmd)
except ftplib.error_perm as reason:
if str(reason)[:3] != '550':
- raise IOError, ('ftp error', reason), sys.exc_info()[2]
+ raise IOError('ftp error', reason).with_traceback(sys.exc_info()[2])
if not conn:
# Set transfer mode to ASCII!
self.ftp.voidcmd('TYPE A')
# preserved for consistency
except TypeError:
ty,va,tb = sys.exc_info()
- raise TypeError, "not a valid non-string sequence or mapping object", tb
+ raise TypeError("not a valid non-string sequence or mapping object").with_traceback(tb)
l = []
if not doseq:
headers = mimetools.Message(sf)
return addinfourl(fp, headers, req.get_full_url())
except ftplib.all_errors as msg:
- raise IOError, ('ftp error', msg), sys.exc_info()[2]
+ raise IOError('ftp error', msg).with_traceback(sys.exc_info()[2])
def connect_ftp(self, user, passwd, host, port, dirs, timeout):
fw = ftpwrapper(user, passwd, host, port, dirs, timeout)
try:
if self.headers_sent:
# Re-raise original exception if headers sent
- raise exc_info[0], exc_info[1], exc_info[2]
+ raise exc_info[0](exc_info[1]).with_traceback(exc_info[2])
finally:
exc_info = None # avoid dangling circular ref
elif self.headers is not None:
if 'PY_VERSION' in ln:
return ln.split()[-1][1:-1]
- raise RuntimeError, "Cannot find full version??"
+ raise RuntimeError("Cannot find full version??")
# The directory we'll use to create the build (will be erased and recreated)
WORKDIR = "/tmp/_py"
xit = fd.close()
if xit != None:
sys.stdout.write(data)
- raise RuntimeError, "command failed: %s"%(commandline,)
+ raise RuntimeError("command failed: %s"%(commandline,))
if VERBOSE:
sys.stdout.write(data); sys.stdout.flush()
xit = fd.close()
if xit != None:
sys.stdout.write(data)
- raise RuntimeError, "command failed: %s"%(commandline,)
+ raise RuntimeError("command failed: %s"%(commandline,))
return data
SRCDIR=v
else:
- raise NotImplementedError, k
+ raise NotImplementedError(k)
SRCDIR=os.path.abspath(SRCDIR)
WORKDIR=os.path.abspath(WORKDIR)
xit = fp.close()
if xit is not None:
sys.stdout.write(data)
- raise RuntimeError, "Cannot extract %s"%(archiveName,)
+ raise RuntimeError("Cannot extract %s"%(archiveName,))
return os.path.join(builddir, retval)
dirname = 'Python-Docs-%s' % self.doc_version
if os.path.exists(self.build_html):
- raise RuntimeError, '%s: already exists, please remove and try again' % self.build_html
+ raise RuntimeError('%s: already exists, please remove and try again' % self.build_html)
os.chdir(self.build_base)
self.spawn('curl','-O', url)
self.spawn('tar', '-xjf', tarfile)
self.mkpath(self.build_base)
self.ensureHtml()
if not os.path.isdir(self.build_html):
- raise RuntimeError, \
- "Can't find source folder for documentation."
+ raise RuntimeError("Can't find source folder for documentation.")
self.mkpath(self.build_dest)
if dep_util.newer(os.path.join(self.build_html,'index.html'), os.path.join(self.build_dest,'index.html')):
self.mkpath(self.build_dest)
if k in fields:
self.packageInfo[k] = v
elif not k in ["OutputDir"]:
- raise Error, "Unknown package option: %s" % k
+ raise Error("Unknown package option: %s" % k)
# Check where we should leave the output. Default is current directory
outputdir = options.get("OutputDir", os.getcwd())
def Pstring(str):
if len(str) > 255:
- raise ValueError, 'String too large'
+ raise ValueError('String too large')
return chr(len(str))+str
def writeestr(dst, edict):
return NULL;
/* the dict is created on the fly in PyObject_GenericSetAttr */
self->dict = NULL;
+ self->traceback = NULL;
self->args = PyTuple_New(0);
if (!self->args) {
{
Py_CLEAR(self->dict);
Py_CLEAR(self->args);
+ Py_CLEAR(self->traceback);
return 0;
}
{
Py_VISIT(self->dict);
Py_VISIT(self->args);
+ Py_VISIT(self->traceback);
return 0;
}
Py_RETURN_NONE;
}
+static PyObject *
+BaseException_with_traceback(PyObject *self, PyObject *tb) {
+ if (PyException_SetTraceback(self, tb))
+ return NULL;
+
+ Py_INCREF(self);
+ return self;
+}
+
static PyMethodDef BaseException_methods[] = {
{"__reduce__", (PyCFunction)BaseException_reduce, METH_NOARGS },
{"__setstate__", (PyCFunction)BaseException_setstate, METH_O },
+ {"with_traceback", (PyCFunction)BaseException_with_traceback, METH_O },
{NULL, NULL, 0, NULL},
};
return 0;
}
+static PyObject *
+BaseException_get_tb(PyBaseExceptionObject *self)
+{
+ if (self->traceback == NULL) {
+ Py_INCREF(Py_None);
+ return Py_None;
+ }
+ Py_INCREF(self->traceback);
+ return self->traceback;
+}
+
+static int
+BaseException_set_tb(PyBaseExceptionObject *self, PyObject *tb)
+{
+ if (tb == NULL) {
+ PyErr_SetString(PyExc_TypeError, "__traceback__ may not be deleted");
+ return -1;
+ }
+ else if (!(tb == Py_None || PyTraceBack_Check(tb))) {
+ PyErr_SetString(PyExc_TypeError,
+ "__traceback__ must be a traceback or None");
+ return -1;
+ }
+
+ Py_XINCREF(tb);
+ Py_XDECREF(self->traceback);
+ self->traceback = tb;
+ return 0;
+}
+
static PyGetSetDef BaseException_getset[] = {
{"__dict__", (getter)BaseException_get_dict, (setter)BaseException_set_dict},
{"args", (getter)BaseException_get_args, (setter)BaseException_set_args},
+ {"__traceback__", (getter)BaseException_get_tb, (setter)BaseException_set_tb},
{NULL},
};
+PyObject *
+PyException_GetTraceback(PyObject *self) {
+ PyBaseExceptionObject *base_self = (PyBaseExceptionObject *)self;
+ Py_XINCREF(base_self->traceback);
+ return base_self->traceback;
+}
+
+
+int
+PyException_SetTraceback(PyObject *self, PyObject *tb) {
+ return BaseException_set_tb((PyBaseExceptionObject *)self, tb);
+}
+
+PyObject *
+PyException_GetCause(PyObject *self) {
+ PyObject *cause = ((PyBaseExceptionObject *)self)->cause;
+ Py_XINCREF(cause);
+ return cause;
+}
+
+/* Steals a reference to cause */
+void
+PyException_SetCause(PyObject *self, PyObject *cause) {
+ PyObject *old_cause = ((PyBaseExceptionObject *)self)->cause;
+ ((PyBaseExceptionObject *)self)->cause = cause;
+ Py_XDECREF(old_cause);
+}
+
+PyObject *
+PyException_GetContext(PyObject *self) {
+ PyObject *context = ((PyBaseExceptionObject *)self)->context;
+ Py_XINCREF(context);
+ return context;
+}
+
+/* Steals a reference to context */
+void
+PyException_SetContext(PyObject *self, PyObject *context) {
+ PyObject *old_context = ((PyBaseExceptionObject *)self)->context;
+ ((PyBaseExceptionObject *)self)->context = context;
+ Py_XDECREF(old_context);
+}
+
+
+static PyMemberDef BaseException_members[] = {
+ {"__context__", T_OBJECT, offsetof(PyBaseExceptionObject, context), 0,
+ PyDoc_STR("exception context")},
+ {"__cause__", T_OBJECT, offsetof(PyBaseExceptionObject, cause), 0,
+ PyDoc_STR("exception cause")},
+ {NULL} /* Sentinel */
+};
+
static PyTypeObject _PyExc_BaseException = {
PyVarObject_HEAD_INIT(NULL, 0)
"BaseException", /*tp_name*/
0, /* tp_iter */
0, /* tp_iternext */
BaseException_methods, /* tp_methods */
- 0, /* tp_members */
+ BaseException_members, /* tp_members */
BaseException_getset, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
| If(expr test, stmt* body, stmt* orelse)
| With(expr context_expr, expr? optional_vars, stmt* body)
- -- 'type' is a bad name
- | Raise(expr? type, expr? inst, expr? tback)
+ | Raise(expr? exc, expr? cause)
| TryExcept(stmt* body, excepthandler* handlers, stmt* orelse)
| TryFinally(stmt* body, stmt* finalbody)
| Assert(expr test, expr? msg)
/*
- __version__ 56266.
+ __version__ 465.
This module must be committed separately after each AST grammar change;
The __version__ number is set to the revision number of the commit
};
static PyTypeObject *Raise_type;
static char *Raise_fields[]={
- "type",
- "inst",
- "tback",
+ "exc",
+ "cause",
};
static PyTypeObject *TryExcept_type;
static char *TryExcept_fields[]={
if (!If_type) return 0;
With_type = make_type("With", stmt_type, With_fields, 3);
if (!With_type) return 0;
- Raise_type = make_type("Raise", stmt_type, Raise_fields, 3);
+ Raise_type = make_type("Raise", stmt_type, Raise_fields, 2);
if (!Raise_type) return 0;
TryExcept_type = make_type("TryExcept", stmt_type, TryExcept_fields, 3);
if (!TryExcept_type) return 0;
}
stmt_ty
-Raise(expr_ty type, expr_ty inst, expr_ty tback, int lineno, int col_offset,
- PyArena *arena)
+Raise(expr_ty exc, expr_ty cause, int lineno, int col_offset, PyArena *arena)
{
stmt_ty p;
p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = Raise_kind;
- p->v.Raise.type = type;
- p->v.Raise.inst = inst;
- p->v.Raise.tback = tback;
+ p->v.Raise.exc = exc;
+ p->v.Raise.cause = cause;
p->lineno = lineno;
p->col_offset = col_offset;
return p;
case Raise_kind:
result = PyType_GenericNew(Raise_type, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_expr(o->v.Raise.type);
- if (!value) goto failed;
- if (PyObject_SetAttrString(result, "type", value) == -1)
- goto failed;
- Py_DECREF(value);
- value = ast2obj_expr(o->v.Raise.inst);
+ value = ast2obj_expr(o->v.Raise.exc);
if (!value) goto failed;
- if (PyObject_SetAttrString(result, "inst", value) == -1)
+ if (PyObject_SetAttrString(result, "exc", value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr(o->v.Raise.tback);
+ value = ast2obj_expr(o->v.Raise.cause);
if (!value) goto failed;
- if (PyObject_SetAttrString(result, "tback", value) == -1)
+ if (PyObject_SetAttrString(result, "cause", value) == -1)
goto failed;
Py_DECREF(value);
break;
if (PyDict_SetItemString(d, "AST", (PyObject*)AST_type) < 0) return;
if (PyModule_AddIntConstant(m, "PyCF_ONLY_AST", PyCF_ONLY_AST) < 0)
return;
- if (PyModule_AddStringConstant(m, "__version__", "56266") < 0)
+ if (PyModule_AddStringConstant(m, "__version__", "465") < 0)
return;
if (PyDict_SetItemString(d, "mod", (PyObject*)mod_type) < 0) return;
if (PyDict_SetItemString(d, "Module", (PyObject*)Module_type) < 0)
}
case raise_stmt:
if (NCH(ch) == 1)
- return Raise(NULL, NULL, NULL, LINENO(n), n->n_col_offset, c->c_arena);
- else if (NCH(ch) == 2) {
+ return Raise(NULL, NULL, LINENO(n), n->n_col_offset, c->c_arena);
+ else if (NCH(ch) >= 2) {
+ expr_ty cause = NULL;
expr_ty expression = ast_for_expr(c, CHILD(ch, 1));
if (!expression)
return NULL;
- return Raise(expression, NULL, NULL, LINENO(n), n->n_col_offset, c->c_arena);
- }
- else if (NCH(ch) == 4) {
- expr_ty expr1, expr2;
-
- expr1 = ast_for_expr(c, CHILD(ch, 1));
- if (!expr1)
- return NULL;
- expr2 = ast_for_expr(c, CHILD(ch, 3));
- if (!expr2)
- return NULL;
-
- return Raise(expr1, expr2, NULL, LINENO(n), n->n_col_offset, c->c_arena);
- }
- else if (NCH(ch) == 6) {
- expr_ty expr1, expr2, expr3;
-
- expr1 = ast_for_expr(c, CHILD(ch, 1));
- if (!expr1)
- return NULL;
- expr2 = ast_for_expr(c, CHILD(ch, 3));
- if (!expr2)
- return NULL;
- expr3 = ast_for_expr(c, CHILD(ch, 5));
- if (!expr3)
- return NULL;
-
- return Raise(expr1, expr2, expr3, LINENO(n), n->n_col_offset, c->c_arena);
+ if (NCH(ch) == 4) {
+ cause = ast_for_expr(c, CHILD(ch, 3));
+ if (!cause)
+ return NULL;
+ }
+ return Raise(expression, cause, LINENO(n), n->n_col_offset, c->c_arena);
}
default:
PyErr_Format(PyExc_SystemError,
WHY_YIELD = 0x0040 /* 'yield' operator */
};
-static enum why_code do_raise(PyObject *, PyObject *, PyObject *);
+static enum why_code do_raise(PyObject *, PyObject *);
static int unpack_iterable(PyObject *, int, int, PyObject **);
/* for manipulating the thread switch and periodic "stuff" - used to be
default: switch (opcode) {
#endif
case RAISE_VARARGS:
- u = v = w = NULL;
+ v = w = NULL;
switch (oparg) {
- case 3:
- u = POP(); /* traceback */
- /* Fallthrough */
- case 2:
- v = POP(); /* value */
- /* Fallthrough */
+ case 2:
+ v = POP(); /* cause */
case 1:
w = POP(); /* exc */
case 0: /* Fallthrough */
- why = do_raise(w, v, u);
+ why = do_raise(w, v);
break;
default:
PyErr_SetString(PyExc_SystemError,
tstate->exc_type = type;
tstate->exc_value = value;
tstate->exc_traceback = tb;
+ PyException_SetTraceback(value, tb);
Py_XDECREF(tmp_type);
Py_XDECREF(tmp_value);
Py_XDECREF(tmp_tb);
/* Logic for the raise statement (too complicated for inlining).
This *consumes* a reference count to each of its arguments. */
static enum why_code
-do_raise(PyObject *type, PyObject *value, PyObject *tb)
+do_raise(PyObject *exc, PyObject *cause)
{
- if (type == NULL) {
+ PyObject *type = NULL, *value = NULL, *tb = NULL;
+
+ if (exc == NULL) {
/* Reraise */
PyThreadState *tstate = PyThreadState_GET();
- type = tstate->exc_type == NULL ? Py_None : tstate->exc_type;
+ type = tstate->exc_type;
value = tstate->exc_value;
tb = tstate->exc_traceback;
- Py_XINCREF(type);
+ if (type == Py_None) {
+ PyErr_SetString(PyExc_RuntimeError,
+ "No active exception to reraise");
+ return WHY_EXCEPTION;
+ }
+ Py_XINCREF(type);
Py_XINCREF(value);
Py_XINCREF(tb);
+ PyErr_Restore(type, value, tb);
+ return WHY_RERAISE;
}
/* We support the following forms of raise:
- raise <class>, <classinstance>
- raise <class>, <argument tuple>
- raise <class>, None
- raise <class>, <argument>
- raise <classinstance>, None
- raise <string>, <object>
- raise <string>, None
-
- An omitted second argument is the same as None.
-
- In addition, raise <tuple>, <anything> is the same as
- raising the tuple's first item (and it better have one!);
- this rule is applied recursively.
-
- Finally, an optional third argument can be supplied, which
- gives the traceback to be substituted (useful when
- re-raising an exception after examining it). */
-
- /* First, check the traceback argument, replacing None with
- NULL. */
- if (tb == Py_None) {
- Py_DECREF(tb);
- tb = NULL;
- }
- else if (tb != NULL && !PyTraceBack_Check(tb)) {
- PyErr_SetString(PyExc_TypeError,
- "raise: arg 3 must be a traceback or None");
- goto raise_error;
- }
-
- /* Next, replace a missing value with None */
- if (value == NULL) {
- value = Py_None;
- Py_INCREF(value);
- }
+ raise
+ raise <instance>
+ raise <type> */
- /* Next, repeatedly, replace a tuple exception with its first item */
- while (PyTuple_Check(type) && PyTuple_Size(type) > 0) {
- PyObject *tmp = type;
- type = PyTuple_GET_ITEM(type, 0);
+ if (PyExceptionClass_Check(exc)) {
+ type = exc;
+ value = PyObject_CallObject(exc, NULL);
+ if (value == NULL)
+ goto raise_error;
+ }
+ else if (PyExceptionInstance_Check(exc)) {
+ value = exc;
+ type = PyExceptionInstance_Class(exc);
Py_INCREF(type);
- Py_DECREF(tmp);
- }
-
- if (PyExceptionClass_Check(type))
- PyErr_NormalizeException(&type, &value, &tb);
-
- else if (PyExceptionInstance_Check(type)) {
- /* Raising an instance. The value should be a dummy. */
- if (value != Py_None) {
- PyErr_SetString(PyExc_TypeError,
- "instance exception may not have a separate value");
- goto raise_error;
- }
- else {
- /* Normalize to raise <class>, <instance> */
- Py_DECREF(value);
- value = type;
- type = PyExceptionInstance_Class(type);
- Py_INCREF(type);
- }
}
else {
/* Not something you can raise. You get an exception
anyway, just not what you specified :-) */
+ Py_DECREF(exc);
+ Py_XDECREF(cause);
PyErr_SetString(PyExc_TypeError,
"exceptions must derive from BaseException");
goto raise_error;
}
+
+ tb = PyException_GetTraceback(value);
+ if (cause) {
+ PyObject *fixed_cause;
+ if (PyExceptionClass_Check(cause)) {
+ fixed_cause = PyObject_CallObject(cause, NULL);
+ if (fixed_cause == NULL)
+ goto raise_error;
+ }
+ else if (PyExceptionInstance_Check(cause)) {
+ fixed_cause = cause;
+ }
+ else {
+ Py_DECREF(cause);
+ PyErr_SetString(PyExc_TypeError,
+ "exception causes must derive from BaseException");
+ goto raise_error;
+ }
+ PyException_SetCause(value, fixed_cause);
+ }
+
PyErr_Restore(type, value, tb);
- if (tb == NULL)
- return WHY_EXCEPTION;
- else
- return WHY_RERAISE;
- raise_error:
+ return WHY_EXCEPTION;
+
+raise_error:
Py_XDECREF(value);
Py_XDECREF(type);
Py_XDECREF(tb);
ADDOP_O(c, LOAD_GLOBAL, assertion_error, names);
if (s->v.Assert.msg) {
VISIT(c, expr, s->v.Assert.msg);
- ADDOP_I(c, RAISE_VARARGS, 2);
- }
- else {
- ADDOP_I(c, RAISE_VARARGS, 1);
+ ADDOP_I(c, CALL_FUNCTION, 1);
}
+ ADDOP_I(c, RAISE_VARARGS, 1);
compiler_use_next_block(c, end);
ADDOP(c, POP_TOP);
return 1;
return compiler_if(c, s);
case Raise_kind:
n = 0;
- if (s->v.Raise.type) {
- VISIT(c, expr, s->v.Raise.type);
+ if (s->v.Raise.exc) {
+ VISIT(c, expr, s->v.Raise.exc);
n++;
- if (s->v.Raise.inst) {
- VISIT(c, expr, s->v.Raise.inst);
- n++;
- if (s->v.Raise.tback) {
- VISIT(c, expr, s->v.Raise.tback);
- n++;
- }
- }
+ if (s->v.Raise.cause) {
+ VISIT(c, expr, s->v.Raise.cause);
+ n++;
+ }
}
ADDOP_I(c, RAISE_VARARGS, n);
break;
{0, 1},
};
static arc arcs_24_2[2] = {
- {30, 3},
+ {71, 3},
{0, 2},
};
static arc arcs_24_3[1] = {
{24, 4},
};
-static arc arcs_24_4[2] = {
- {30, 5},
+static arc arcs_24_4[1] = {
{0, 4},
};
-static arc arcs_24_5[1] = {
- {24, 6},
-};
-static arc arcs_24_6[1] = {
- {0, 6},
-};
-static state states_24[7] = {
+static state states_24[5] = {
{1, arcs_24_0},
{2, arcs_24_1},
{2, arcs_24_2},
{1, arcs_24_3},
- {2, arcs_24_4},
- {1, arcs_24_5},
- {1, arcs_24_6},
+ {1, arcs_24_4},
};
static arc arcs_25_0[2] = {
- {71, 1},
{72, 1},
+ {73, 1},
};
static arc arcs_25_1[1] = {
{0, 1},
{1, arcs_25_1},
};
static arc arcs_26_0[1] = {
- {73, 1},
+ {74, 1},
};
static arc arcs_26_1[1] = {
- {74, 2},
+ {75, 2},
};
static arc arcs_26_2[1] = {
{0, 2},
{1, arcs_26_2},
};
static arc arcs_27_0[1] = {
- {75, 1},
+ {71, 1},
};
static arc arcs_27_1[3] = {
{76, 2},
{76, 2},
{77, 2},
{12, 3},
- {73, 4},
+ {74, 4},
};
static arc arcs_27_3[1] = {
- {73, 4},
+ {74, 4},
};
static arc arcs_27_4[3] = {
{31, 5},
};
static dfa dfas[81] = {
{256, "single_input", 0, 3, states_0,
- "\004\050\060\200\000\000\000\050\170\052\034\144\011\040\004\000\200\041\224\017\101"},
+ "\004\050\060\200\000\000\000\050\370\044\034\144\011\040\004\000\200\041\224\017\101"},
{257, "file_input", 0, 2, states_1,
- "\204\050\060\200\000\000\000\050\170\052\034\144\011\040\004\000\200\041\224\017\101"},
+ "\204\050\060\200\000\000\000\050\370\044\034\144\011\040\004\000\200\041\224\017\101"},
{258, "eval_input", 0, 3, states_2,
"\000\040\040\200\000\000\000\000\000\040\000\000\000\040\004\000\200\041\224\017\000"},
{259, "decorator", 0, 7, states_3,
{267, "vfpdef", 0, 2, states_11,
"\000\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
{268, "stmt", 0, 2, states_12,
- "\000\050\060\200\000\000\000\050\170\052\034\144\011\040\004\000\200\041\224\017\101"},
+ "\000\050\060\200\000\000\000\050\370\044\034\144\011\040\004\000\200\041\224\017\101"},
{269, "simple_stmt", 0, 4, states_13,
- "\000\040\040\200\000\000\000\050\170\052\034\000\000\040\004\000\200\041\224\017\100"},
+ "\000\040\040\200\000\000\000\050\370\044\034\000\000\040\004\000\200\041\224\017\100"},
{270, "small_stmt", 0, 2, states_14,
- "\000\040\040\200\000\000\000\050\170\052\034\000\000\040\004\000\200\041\224\017\100"},
+ "\000\040\040\200\000\000\000\050\370\044\034\000\000\040\004\000\200\041\224\017\100"},
{271, "expr_stmt", 0, 6, states_15,
"\000\040\040\200\000\000\000\000\000\040\000\000\000\040\004\000\200\041\224\017\000"},
{272, "augassign", 0, 2, states_16,
"\000\000\000\000\000\000\000\000\040\000\000\000\000\000\000\000\000\000\000\000\000"},
{279, "yield_stmt", 0, 2, states_23,
"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\100"},
- {280, "raise_stmt", 0, 7, states_24,
+ {280, "raise_stmt", 0, 5, states_24,
"\000\000\000\000\000\000\000\000\100\000\000\000\000\000\000\000\000\000\000\000\000"},
{281, "import_stmt", 0, 2, states_25,
- "\000\000\000\000\000\000\000\000\000\012\000\000\000\000\000\000\000\000\000\000\000"},
+ "\000\000\000\000\000\000\000\000\200\004\000\000\000\000\000\000\000\000\000\000\000"},
{282, "import_name", 0, 3, states_26,
- "\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000"},
+ "\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000"},
{283, "import_from", 0, 8, states_27,
- "\000\000\000\000\000\000\000\000\000\010\000\000\000\000\000\000\000\000\000\000\000"},
+ "\000\000\000\000\000\000\000\000\200\000\000\000\000\000\000\000\000\000\000\000\000"},
{284, "import_as_name", 0, 4, states_28,
"\000\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
{285, "dotted_as_name", 0, 4, states_29,
{299, "except_clause", 0, 5, states_43,
"\000\000\000\000\000\000\000\000\000\000\000\000\100\000\000\000\000\000\000\000\000"},
{300, "suite", 0, 5, states_44,
- "\004\040\040\200\000\000\000\050\170\052\034\000\000\040\004\000\200\041\224\017\100"},
+ "\004\040\040\200\000\000\000\050\370\044\034\000\000\040\004\000\200\041\224\017\100"},
{301, "test", 0, 6, states_45,
"\000\040\040\200\000\000\000\000\000\040\000\000\000\040\004\000\200\041\224\017\000"},
{302, "test_nocond", 0, 2, states_46,
{1, "continue"},
{1, "return"},
{1, "raise"},
+ {1, "from"},
{282, 0},
{283, 0},
{1, "import"},
{287, 0},
- {1, "from"},
{23, 0},
{52, 0},
{286, 0},
3040 (added signature annotations)
3050 (print becomes a function)
3060 (PEP 3115 metaclass syntax)
+ 3070 (PEP 3109 raise changes)
.
*/
#define MAGIC (3060 | ((long)'\r'<<16) | ((long)'\n'<<24))
VISIT_SEQ(st, stmt, s->v.If.orelse);
break;
case Raise_kind:
- if (s->v.Raise.type) {
- VISIT(st, expr, s->v.Raise.type);
- if (s->v.Raise.inst) {
- VISIT(st, expr, s->v.Raise.inst);
- if (s->v.Raise.tback)
- VISIT(st, expr, s->v.Raise.tback);
- }
+ if (s->v.Raise.exc) {
+ VISIT(st, expr, s->v.Raise.exc);
+ if (s->v.Raise.cause) {
+ VISIT(st, expr, s->v.Raise.cause);
+ }
}
break;
case TryExcept_kind:
def setflags(self, **kw):
for key in kw.keys():
if key not in self.validflags:
- raise NameError, "invalid keyword argument: %s" % str(key)
+ raise NameError("invalid keyword argument: %s" % str(key))
for key, value in kw.items():
setattr(self, key, value)
names = os.listdir(path)
except os.error as msg:
exc_type, exc_value, exc_tb = sys.exc_info()
- raise IOError, msg, exc_tb
+ raise IOError(msg).with_traceback(exc_tb)
names.sort()
s = MyStringIO("file:"+url, {'content-type': 'text/html'})
s.write('<BASE HREF="file:%s">\n' %
projects / python / commitdiff