@@ -106,8 +106,7 @@ def import_module(partname, fqname, parent):
     return m
 
 
-# Replacement for reload()
-def reload_hook(module):
+def reload(module):
     name = module.__name__
     if '.' not in name:
         return import_module(name, name, None)
@@ -119,8 +118,6 @@ def reload_hook(module):
 
 # Save the original hooks
 original_import = __builtin__.__import__
-original_reload = __builtin__.reload
 
 # Now install our hooks
 __builtin__.__import__ = import_hook
-__builtin__.reload = reload_hook
@@ -262,7 +262,6 @@ def test():
         rl.unlock()
     finally:
         print [1]
-        sys.exc_traceback = None
         print [2]
         if rl:
             rl.unlock()
 
@@ -122,7 +122,7 @@ EMACS=     emacs
 
 # The end of this should reflect the major/minor version numbers of
 # the release:
-WHATSNEW=whatsnew26
+WHATSNEW=whatsnew30
 
 # what's what
 MANDVIFILES=	paper-$(PAPER)/api.dvi paper-$(PAPER)/ext.dvi \
 
@@ -171,7 +171,6 @@ LIBFILES= $(MANSTYLES) $(INDEXSTYLES) $(COMMONTEX) \
 	lib/libgdbm.tex \
 	lib/libtermios.tex \
 	lib/libfcntl.tex \
-	lib/libposixfile.tex \
 	lib/libsyslog.tex \
 	lib/liblogging.tex \
 	lib/libpdb.tex \
@@ -192,7 +191,6 @@ LIBFILES= $(MANSTYLES) $(INDEXSTYLES) $(COMMONTEX) \
 	lib/libsgmllib.tex \
 	lib/librfc822.tex \
 	lib/libmimetools.tex \
-	lib/libmimewriter.tex \
 	lib/libbinascii.tex \
 	lib/libmm.tex \
 	lib/libaudioop.tex \
@@ -235,7 +233,6 @@ LIBFILES= $(MANSTYLES) $(INDEXSTYLES) $(COMMONTEX) \
 	lib/libzipfile.tex \
 	lib/libpprint.tex \
 	lib/libcode.tex \
-	lib/libmimify.tex \
 	lib/libre.tex \
 	lib/libuserdict.tex \
 	lib/libdis.tex \
 
@@ -140,10 +140,7 @@ \section{Importing Modules \label{importing}}
 \end{cfuncdesc}
 
 \begin{cfuncdesc}{PyObject*}{PyImport_ReloadModule}{PyObject *m}
-  Reload a module.  This is best described by referring to the
-  built-in Python function \function{reload()}\bifuncindex{reload}, as
-  the standard \function{reload()} function calls this function
-  directly.  Return a new reference to the reloaded module, or \NULL{}
+  Reload a module.  Return a new reference to the reloaded module, or \NULL{}
   with an exception set on failure (the module still exists in this
   case).
 \end{cfuncdesc}
 
@@ -399,12 +399,7 @@ \section{The Module's Method Table and Initialization Function
 following a \cfunction{fork()} without an intervening
 \cfunction{exec()}) can create problems for some extension modules.
 Extension module authors should exercise caution when initializing
-internal data structures.
-Note also that the \function{reload()} function can be used with
-extension modules, and will call the module initialization function
-(\cfunction{initspam()} in the example), but will not load the module
-again if it was loaded from a dynamically loadable object file
-(\file{.so} on \UNIX, \file{.dll} on Windows).}
+internal data structures.}
 
 A more substantial example module is included in the Python source
 distribution as \file{Modules/xxmodule.c}.  This file may be used as a 
 
@@ -980,7 +980,7 @@ element.
 that's a slice of the iterator.  With a single ``stop`` argument, 
 it will return the first ``stop``
 elements.  If you supply a starting index, you'll get ``stop-start``
-elements, and if you supply a value for ``step`, elements will be
+elements, and if you supply a value for ``step``, elements will be
 skipped accordingly.  Unlike Python's string and list slicing, you
 can't use negative values for ``start``, ``stop``, or ``step``.
 
 
@@ -146,8 +146,6 @@ \chapter*{Front Matter\label{front}}
 \input{libmhlib}
 \input{libmimetools}
 \input{libmimetypes}
-\input{libmimewriter}
-\input{libmimify}
 \input{libmultifile}
 \input{librfc822}
 
@@ -265,7 +263,6 @@ \chapter*{Front Matter\label{front}}
 \input{libpty}
 \input{libfcntl}
 \input{libpipes}
-\input{libposixfile}
 \input{libresource}
 \input{libnis}
 \input{libsyslog}
 
@@ -237,7 +237,7 @@ \section{\module{codecs} ---
 \begin{funcdesc}{iterdecode}{iterable, encoding\optional{, errors}}
 Uses an incremental decoder to iteratively decode the input provided by
 \var{iterable}. This function is a generator. \var{errors} (as well as
-any other keyword argument) is passed through to the incremental encoder.
+any other keyword argument) is passed through to the incremental decoder.
 \versionadded{2.5}
 \end{funcdesc}
 
 
@@ -890,82 +890,6 @@ \section{Built-in Functions \label{built-in-funcs}}
 \end{verbatim}
 \end{funcdesc}
 
-\begin{funcdesc}{reload}{module}
-  Reload a previously imported \var{module}.  The
-  argument must be a module object, so it must have been successfully
-  imported before.  This is useful if you have edited the module
-  source file using an external editor and want to try out the new
-  version without leaving the Python interpreter.  The return value is
-  the module object (the same as the \var{module} argument).
-
-  When \code{reload(module)} is executed:
-
-\begin{itemize}
-
-    \item Python modules' code is recompiled and the module-level code
-    reexecuted, defining a new set of objects which are bound to names in
-    the module's dictionary.  The \code{init} function of extension
-    modules is not called a second time.
-
-    \item As with all other objects in Python the old objects are only
-    reclaimed after their reference counts drop to zero.
-
-    \item The names in the module namespace are updated to point to
-    any new or changed objects.
-
-    \item Other references to the old objects (such as names external
-    to the module) are not rebound to refer to the new objects and
-    must be updated in each namespace where they occur if that is
-    desired.
-
-\end{itemize}
-
-  There are a number of other caveats:
-
-  If a module is syntactically correct but its initialization fails,
-  the first \keyword{import} statement for it does not bind its name
-  locally, but does store a (partially initialized) module object in
-  \code{sys.modules}.  To reload the module you must first
-  \keyword{import} it again (this will bind the name to the partially
-  initialized module object) before you can \function{reload()} it.
-
-  When a module is reloaded, its dictionary (containing the module's
-  global variables) is retained.  Redefinitions of names will override
-  the old definitions, so this is generally not a problem.  If the new
-  version of a module does not define a name that was defined by the
-  old version, the old definition remains.  This feature can be used
-  to the module's advantage if it maintains a global table or cache of
-  objects --- with a \keyword{try} statement it can test for the
-  table's presence and skip its initialization if desired:
-
-\begin{verbatim}
-try:
-    cache
-except NameError:
-    cache = {}
-\end{verbatim}
-
-
-  It is legal though generally not very useful to reload built-in or
-  dynamically loaded modules, except for \refmodule{sys},
-  \refmodule[main]{__main__} and \refmodule[builtin]{__builtin__}.  In
-  many cases, however, extension modules are not designed to be
-  initialized more than once, and may fail in arbitrary ways when
-  reloaded.
-
-  If a module imports objects from another module using \keyword{from}
-  \ldots{} \keyword{import} \ldots{}, calling \function{reload()} for
-  the other module does not redefine the objects imported from it ---
-  one way around this is to re-execute the \keyword{from} statement,
-  another is to use \keyword{import} and qualified names
-  (\var{module}.\var{name}) instead.
-
-  If a module instantiates instances of a class, reloading the module
-  that defines the class does not affect the method definitions of the
-  instances --- they continue to use the old class definition.  The
-  same is true for derived classes.
-\end{funcdesc}
-
 \begin{funcdesc}{repr}{object}
   Return a string containing a printable representation of an object.
   This is the same value yielded by conversions (reverse quotes).