New file, which is imported by the built-in module when python is

started with the -X option.  This file contains the definitions for
the built-in exception classes.

Lib/exceptions.py

@@ -0,0 +1,164 @@
+"""Class based built-in exception hierarchy.
+
+This is an experimental new feature whereby all the standard built-in
+exceptions, traditionally string object, are replaced with classes.
+This gives Python's exception handling mechanism a more
+object-oriented feel.
+
+Most existing code should continue to work with class based
+exceptions.  Some tricky uses of IOError may break, but the most
+common uses should work.
+
+To use this new feature, start the python executable with the -X option.
+
+Here is a rundown of the class hierarchy.  You can change this by
+editing this file, but it isn't recommended.  The classes with a `*'
+are new with this feature and are not available unless class based
+exceptions are used.
+
+StandardError(*)
+ |
+ +-- SystemExit
+ +-- KeyboardInterrupt
+ +-- ImportError
+ +-- IOError
+ +-- EOFError
+ +-- RuntimeError
+ +-- NameError
+ +-- AttributeError
+ +-- SyntaxError
+ +-- TypeError
+ +-- AssertionError
+ +-- LookupError(*)
+ |    |
+ |    +-- IndexError
+ |    +-- KeyError
+ |
+ +-- NumberError(*)
+ |    |
+ |    +-- OverflowError
+ |    +-- ZeroDivisionError
+ |    +-- FloatingPointError
+ |
+ +-- ValueError
+ +-- SystemError
+ +-- MemoryError
+"""
+
+class StandardError:
+    def __init__(self, *args):
+        if len(args) == 0:
+            self.args = None
+        elif len(args) == 1:
+            # de-tuplify
+            self.args = args[0]
+        else:
+            self.args = args
+
+    def __str__(self):
+        if self.args == None:
+            return ''
+        elif type(self.args) == type(''):
+            return self.args
+        else:
+            return `self.args`
+
+    def __getitem__(self, i):
+	if type(self.args) == type(()):
+	    return self.args[i]
+	elif i == 0:
+	    return self.args
+	else:
+	    raise IndexError
+
+class SyntaxError(StandardError):
+    def __init__(self, msg, info):
+        self.msg = msg
+        self.filename, self.lineno, self.offset, self.text = info
+
+    def __str__(self):
+        return msg
+
+
+class IOError(StandardError):
+    def __init__(self, *args):
+        self.errno = None
+        self.strerror = None
+        if len(args) == 1:
+            # de-tuplify
+            self.args = args[0]
+        elif len(args) == 2:
+            # common case: PyErr_SetFromErrno()
+            self.args = args
+            self.errno = args[0]
+            self.strerror = args[1]
+        else:
+            self.args = args
+
+
+class RuntimeError(StandardError):
+    pass
+
+class SystemError(StandardError):
+    pass
+
+class EOFError(StandardError):
+    pass
+
+class ImportError(StandardError):
+    pass
+
+class TypeError(StandardError):
+    pass
+
+class ValueError(StandardError):
+    pass
+
+class KeyboardInterrupt(StandardError):
+    pass
+
+class AssertionError(StandardError):
+    pass
+
+class NumberError(StandardError):
+    pass
+
+class OverflowError(NumberError):
+    pass
+
+class FloatingPointError(NumberError):
+    pass
+
+class ZeroDivisionError(NumberError):
+    pass
+
+class LookupError(StandardError):
+    pass
+
+class IndexError(LookupError):
+    pass
+
+class KeyError(LookupError):
+    pass
+
+# debate: should these two inherit from LookupError?
+class AttributeError(StandardError):
+    pass
+
+class NameError(StandardError):
+    pass
+
+class SystemExit(StandardError):
+    def __init__(self, *args):
+        if len(args) == 0:
+            self.args = None
+        elif len(args) == 1:
+            # de-tuplify
+            self.args = args[0]
+        else:
+            self.args = args
+        self.code = self.args
+
+
+class MemoryError(StandardError):
+    pass