Merge lp:~mitya57/ubuntu/saucy/python3.3/3.3.2-5ubuntu1 into lp:ubuntu/saucy/python3.3

[Dmitry Shachnev]

* Merge with Debian unstable, remaining change:
  - Regenerate the control file.
* debian/patches/platform-lsbrelease.diff: fix indentaion, which
  caused this patch to not work properly. LP: #1220508.

[lp:~mitya57/ubuntu/saucy/python3.3/3.3.2-5ubuntu1]

37. By Dmitry Shachnev on 2013-09-17

d/control: Revert Multi-Arch headers change

=== modified file 'debian/PVER-minimal.postinst.in'
--- debian/PVER-minimal.postinst.in	2013-06-05 12:28:37 +0000
+++ debian/PVER-minimal.postinst.in	2013-09-17 18:06:34 +0000
@@ -35,9 +35,13 @@
     # only available before removal of the packaging package
     rm -f /etc/@PVER@/sysconfig.cfg
 
-    ls -L /usr/lib/@PVER@/sitecustomize.py >/dev/null 2>&1 \
-      || filt='| fgrep -v sitecustomize.py'
-    files=$(dpkg -L lib@PVER@-minimal | sed -n '/^\/usr\/lib\/@PVER@\/.*\.py$/p' $filt)
+    if ls -L /usr/lib/@PVER@/sitecustomize.py >/dev/null 2>&1; then
+	filt='cat'
+    else
+	filt='fgrep -v sitecustomize.py'
+    fi
+    files=$(dpkg -L lib@PVER@-minimal \
+		| sed -n '/^\/usr\/lib\/@PVER@\/.*\.py$/p' | $filt)
     if [ -n "$files" ]; then
 	@PVER@ -E -S /usr/lib/@PVER@/py_compile.py $files
 	if grep -sq '^byte-compile[^#]*optimize' /etc/python/debian_config; then

=== modified file 'debian/changelog'
--- debian/changelog	2013-06-05 12:28:37 +0000
+++ debian/changelog	2013-09-17 18:06:34 +0000
@@ -1,3 +1,32 @@
+python3.3 (3.3.2-5ubuntu1) UNRELEASED; urgency=low
+
+  * Merge with Debian unstable, remaining change:
+    - Regenerate the control file.
+  * debian/patches/platform-lsbrelease.diff: fix indentaion, which
+    caused this patch to not work properly. LP: #1220508.
+
+ -- Dmitry Shachnev <[e-mail]>  Tue, 17 Sep 2013 21:00:31 +0400
+
+python3.3 (3.3.2-5) unstable; urgency=low
+
+  * Update to 20130803 from the 3.3 branch.
+    - Fix fcntl test case on KFreeBSD (Petr Salinger).
+  * Disable some socket tests on KFreeBSD (Petr Salinger).
+  * Fix multiarch include header for sparc64. Closes: #714802.
+  * Update package descriptions (Filipus Klutiero). Closes: #715801.
+
+ -- Matthias Klose <[e-mail]>  Sun, 04 Aug 2013 17:38:35 +0200
+
+python3.3 (3.3.2-4) unstable; urgency=low
+
+  * Update to 20130612 from the 3.3 branch.
+  * Refresh patches.
+  * Don't run consistency check for cross builds.
+  * Really skip byte compile of non-existing sitecustomize.py.
+  * Fix the multiarch header file for mips64 (YunQiang Su). Closes: #710374.
+
+ -- Matthias Klose <[e-mail]>  Wed, 12 Jun 2013 22:55:02 +0200
+
 python3.3 (3.3.2-3ubuntu1) saucy; urgency=low
 
   * Merge with Debian; remaining changes:

=== modified file 'debian/control'
--- debian/control	2013-06-05 12:28:37 +0000
+++ debian/control	2013-09-17 18:06:34 +0000
@@ -14,6 +14,7 @@
   libsqlite3-dev, libffi-dev (>= 3.0.5),
   libgpm2 [!hurd-i386 !kfreebsd-i386 !kfreebsd-amd64],
   mime-support, netbase, bzip2, python3:any,
+  gcc (>= 4:4.8) [amd64 armel armhf i386 x32 kfreebsd-any hurd-any],
   xvfb, xauth
 Build-Depends-Indep: python-sphinx
 Standards-Version: 3.9.4
@@ -28,7 +29,7 @@
 Depends: python3.3-minimal (= ${binary:Version}), libpython3.3-stdlib (= ${binary:Version}), mime-support, ${shlibs:Depends}, ${misc:Depends}
 Suggests: python3.3-doc, binutils
 Description: Interactive high-level object-oriented language (version 3.3)
- Version 3.3 of the high-level, interactive object oriented language,
+ Python is a high-level, interactive, object-oriented language. Its 3.3 version
  includes an extensive class library with lots of goodies for
  network programming, system administration, sounds and graphics.
 
@@ -40,13 +41,13 @@
 Depends: libpython3.3-minimal (= ${binary:Version}), mime-support, ${shlibs:Depends}, ${misc:Depends}
 Provides: python3.3-cjkcodecs, python3.3-ctypes, python3.3-elementtree, python3.3-celementtree, python3.3-wsgiref, python3.3-gdbm, python3.3-profiler, python3.3-lzma
 Replaces: python3.3 (<< 3.3.1~rc1-2~)
-Description: Interactive high-level object-oriented language (version 3.3)
- Version 3.3 of the high-level, interactive object oriented language,
+Description: Interactive high-level object-oriented language (standard library, version 3.3)
+ Python is a high-level, interactive, object-oriented language. Its 3.3 version
  includes an extensive class library with lots of goodies for
  network programming, system administration, sounds and graphics.
  .
- This package contains the standard library. It is normally not
- used on it's own, but as a dependency of python3.3.
+ This package contains Python 3.3's standard library. It is normally not
+ used on its own, but as a dependency of python3.3.
 
 Package: python3.3-minimal
 Architecture: any
@@ -87,7 +88,7 @@
 Depends: libpython3.3-stdlib (= ${binary:Version}), ${shlibs:Depends}, ${misc:Depends}
 Replaces: python3.3 (<< 3.0~rc1)
 Description: Shared Python runtime library (version 3.3)
- Version 3.3 of the high-level, interactive object oriented language,
+ Python is a high-level, interactive, object-oriented language. Its 3.3 version
  includes an extensive class library with lots of goodies for
  network programming, system administration, sounds and graphics.
  .

=== modified file 'debian/control.in'
--- debian/control.in	2013-06-05 12:28:37 +0000
+++ debian/control.in	2013-09-17 18:06:34 +0000
@@ -13,6 +13,7 @@
   libsqlite3-dev, libffi-dev (>= 3.0.5),
   libgpm2 [!hurd-i386 !kfreebsd-i386 !kfreebsd-amd64],
   mime-support, netbase, bzip2, python3@bd_qual@,
+  gcc (>= 4:4.8) [amd64 armel armhf i386 x32 kfreebsd-any hurd-any],
   xvfb, xauth
 Build-Depends-Indep: python-sphinx
 Standards-Version: 3.9.4
@@ -27,7 +28,7 @@
 Depends: @PVER@-minimal (= ${binary:Version}), lib@PVER@-stdlib (= ${binary:Version}), mime-support, ${shlibs:Depends}, ${misc:Depends}
 Suggests: @PVER@-doc, binutils
 Description: Interactive high-level object-oriented language (version @VER@)
- Version @VER@ of the high-level, interactive object oriented language,
+ Python is a high-level, interactive, object-oriented language. Its @VER@ version
  includes an extensive class library with lots of goodies for
  network programming, system administration, sounds and graphics.
 
@@ -39,13 +40,13 @@
 Depends: lib@PVER@-minimal (= ${binary:Version}), mime-support, ${shlibs:Depends}, ${misc:Depends}
 Provides: python@VER@-cjkcodecs, python@VER@-ctypes, python@VER@-elementtree, python@VER@-celementtree, python@VER@-wsgiref, @PVER@-gdbm, @PVER@-profiler, @PVER@-lzma
 Replaces: @PVER@ (<< 3.3.1~rc1-2~)
-Description: Interactive high-level object-oriented language (version @VER@)
- Version @VER@ of the high-level, interactive object oriented language,
+Description: Interactive high-level object-oriented language (standard library, version @VER@)
+ Python is a high-level, interactive, object-oriented language. Its @VER@ version
  includes an extensive class library with lots of goodies for
  network programming, system administration, sounds and graphics.
  .
- This package contains the standard library. It is normally not
- used on it's own, but as a dependency of @PVER@.
+ This package contains Python @VER@'s standard library. It is normally not
+ used on its own, but as a dependency of python@VER@.
 
 Package: @PVER@-minimal
 Architecture: any
@@ -86,7 +87,7 @@
 Depends: lib@PVER@-stdlib (= ${binary:Version}), ${shlibs:Depends}, ${misc:Depends}
 Replaces: @PVER@ (<< 3.0~rc1)
 Description: Shared Python runtime library (version @VER@)
- Version @VER@ of the high-level, interactive object oriented language,
+ Python is a high-level, interactive, object-oriented language. Its @VER@ version
  includes an extensive class library with lots of goodies for
  network programming, system administration, sounds and graphics.
  .

=== modified file 'debian/multiarch.h.in'
--- debian/multiarch.h.in	2013-06-05 12:28:37 +0000
+++ debian/multiarch.h.in	2013-09-17 18:06:34 +0000
@@ -20,21 +20,21 @@
 # elif defined(__m68k__) && !defined(__mcoldfire__)
 #  include <m68k-linux-gnu/@subdir@/@header@>
 # elif defined(__mips_hard_float) && defined(_MIPSEL)
-#  if defined(_ABIO32)
+#  if _MIPS_SIM == _ABIO32
 #   include <mipsel-linux-gnu/@subdir@/@header@>
-#  elif defined(_ABIN32)
+#  elif _MIPS_SIM == _ABIN32
 #   include <mips64el-linux-gnuabin32/@subdir@/@header@>
-#  elif defined(_ABI64)
+#  elif _MIPS_SIM == _ABI64
 #   include <mips64el-linux-gnuabi64/@subdir@/@header@>
 #  else
 #   error unknown multiarch location for @header@
 #  endif
 # elif defined(__mips_hard_float)
-#  if defined(_ABIO32)
+#  if _MIPS_SIM == _ABIO32
 #   include <mips-linux-gnu/@subdir@/@header@>
-#  elif defined(_ABIN32)
+#  elif _MIPS_SIM == _ABIN32
 #   include <mips64-linux-gnuabin32/@subdir@/@header@>
-#  elif defined(_ABI64)
+#  elif _MIPS_SIM == _ABI64
 #   include <mips64-linux-gnuabi64/@subdir@/@header@>
 #  else
 #   error unknown multiarch location for @header@
@@ -51,10 +51,10 @@
 #  include <s390-linux-gnu/@subdir@/@header@>
 # elif defined(__sh__) && defined(__LITTLE_ENDIAN__)
 #  include <sh4-linux-gnu/@subdir@/@header@>
+# elif defined(__sparc64__)
+#  include <sparc64-linux-gnu/@subdir@/@header@>
 # elif defined(__sparc__)
 #  include <sparc-linux-gnu/@subdir@/@header@>
-# elif defined(__sparc64__)
-#  include <sparc64-linux-gnu/@subdir@/@header@>
 # else
 #   error unknown multiarch location for @header@
 # endif

=== modified file 'debian/patches/add-python-config-sh.diff'
--- debian/patches/add-python-config-sh.diff	2013-06-05 12:28:37 +0000
+++ debian/patches/add-python-config-sh.diff	2013-09-17 18:06:34 +0000
@@ -1,8 +1,6 @@
-Index: b/Makefile.pre.in
-===================================================================
 --- a/Makefile.pre.in
 +++ b/Makefile.pre.in
-@@ -1161,6 +1161,8 @@
+@@ -1175,6 +1175,8 @@
  	# Substitution happens here, as the completely-expanded BINDIR
  	# is not available in configure
  	sed -e "s,@EXENAME@,$(BINDIR)/python$(LDVERSION)$(EXE)," < $(srcdir)/Misc/python-config.in >python-config
@@ -11,7 +9,7 @@
  
  # Install the include files
  INCLDIRSTOMAKE=$(INCLUDEDIR) $(CONFINCLUDEDIR) $(INCLUDEPY) $(CONFINCLUDEPY)
-@@ -1219,6 +1221,7 @@
+@@ -1233,6 +1235,7 @@
  	$(INSTALL_SCRIPT) $(srcdir)/Modules/makesetup $(DESTDIR)$(LIBPL)/makesetup
  	$(INSTALL_SCRIPT) $(srcdir)/install-sh $(DESTDIR)$(LIBPL)/install-sh
  	$(INSTALL_SCRIPT) python-config $(DESTDIR)$(BINDIR)/python$(LDVERSION)-config
@@ -19,8 +17,6 @@
  	rm python-config
  	@if [ -s Modules/python.exp -a \
  		"`echo $(MACHDEP) | sed 's/^\(...\).*/\1/'`" = "aix" ]; then \
-Index: b/Misc/python-config.sh.in
-===================================================================
 --- /dev/null
 +++ b/Misc/python-config.sh.in
 @@ -0,0 +1,107 @@
@@ -131,8 +127,6 @@
 +        ;;
 +esac
 +done
-Index: b/configure.ac
-===================================================================
 --- a/configure.ac
 +++ b/configure.ac
 @@ -917,6 +917,7 @@

=== modified file 'debian/patches/atomic-pyc-rename.diff'
--- debian/patches/atomic-pyc-rename.diff	2013-06-05 12:28:37 +0000
+++ debian/patches/atomic-pyc-rename.diff	2013-09-17 18:06:34 +0000
@@ -1,6 +1,5 @@
-diff -r 6ab88d6527f1 Lib/py_compile.py
---- a/Lib/py_compile.py	Tue May 21 11:44:41 2013 -0400
-+++ b/Lib/py_compile.py	Tue May 21 14:43:25 2013 -0400
+--- a/Lib/py_compile.py
++++ b/Lib/py_compile.py
 @@ -138,14 +138,25 @@
      except OSError as error:
          if error.errno != errno.EEXIST:

=== modified file 'debian/patches/avoid-rpath.diff'
--- debian/patches/avoid-rpath.diff	2012-08-26 23:15:00 +0000
+++ debian/patches/avoid-rpath.diff	2013-09-17 18:06:34 +0000
@@ -1,9 +1,8 @@
 # DP: avoid runtime library path for some extension modules.
 
-diff -r 12a56a349af2 setup.py
---- a/setup.py	Sat Jun 30 19:28:16 2012 +0200
-+++ b/setup.py	Sun Jul 01 10:25:14 2012 +0200
-@@ -957,6 +957,15 @@
+--- a/setup.py
++++ b/setup.py
+@@ -1011,6 +1011,15 @@
                  print("bsddb lib dir:", dblib_dir, " inc dir:", db_incdir)
              db_incs = [db_incdir]
              dblibs = [dblib]
@@ -19,7 +18,7 @@
          else:
              if db_setup_debug: print("db: no appropriate library found")
              db_incs = None
-@@ -1065,6 +1074,9 @@
+@@ -1121,6 +1130,9 @@
              # can end up with a bad search path order.
              if sqlite_incdir not in self.compiler.include_dirs:
                  include_dirs.append(sqlite_incdir)

=== modified file 'debian/patches/bdist-wininst-notfound.diff'
--- debian/patches/bdist-wininst-notfound.diff	2012-06-21 16:04:00 +0000
+++ debian/patches/bdist-wininst-notfound.diff	2013-09-17 18:06:34 +0000
@@ -1,8 +1,6 @@
 # DP: suggest installation of the pythonX.Y-dev package, if bdist_wininst
 # DP: cannot find the wininst-* files.
 
-Index: b/Lib/distutils/command/bdist_wininst.py
-===================================================================
 --- a/Lib/distutils/command/bdist_wininst.py
 +++ b/Lib/distutils/command/bdist_wininst.py
 @@ -342,7 +342,10 @@

=== modified file 'debian/patches/ctypes-arm.diff'
--- debian/patches/ctypes-arm.diff	2012-07-13 00:43:42 +0000
+++ debian/patches/ctypes-arm.diff	2013-09-17 18:06:34 +0000
@@ -1,8 +1,6 @@
-Index: b/Lib/ctypes/util.py
-===================================================================
 --- a/Lib/ctypes/util.py
 +++ b/Lib/ctypes/util.py
-@@ -170,16 +170,27 @@
+@@ -199,16 +199,27 @@
  
          def _findSoname_ldconfig(name):
              import struct

=== modified file 'debian/patches/deb-locations.diff'
--- debian/patches/deb-locations.diff	2012-06-21 16:04:00 +0000
+++ debian/patches/deb-locations.diff	2013-09-17 18:06:34 +0000
@@ -1,7 +1,5 @@
 # DP: adjust locations of directories to debian policy
 
-Index: b/Lib/pydoc.py
-===================================================================
 --- a/Lib/pydoc.py
 +++ b/Lib/pydoc.py
 @@ -27,6 +27,10 @@
@@ -15,8 +13,6 @@
      http://docs.python.org/X.Y/library/
  
  This can be overridden by setting the PYTHONDOCS environment variable
-Index: b/Misc/python.man
-===================================================================
 --- a/Misc/python.man
 +++ b/Misc/python.man
 @@ -305,7 +305,7 @@

=== modified file 'debian/patches/deb-setup.diff'
--- debian/patches/deb-setup.diff	2012-08-28 19:47:58 +0000
+++ debian/patches/deb-setup.diff	2013-09-17 18:06:34 +0000
@@ -1,10 +1,8 @@
 # DP: Don't include /usr/local/include and /usr/local/lib as gcc search paths
 
-Index: b/setup.py
-===================================================================
 --- a/setup.py
 +++ b/setup.py
-@@ -248,8 +248,10 @@
+@@ -238,8 +238,10 @@
          # unfortunately, distutils doesn't let us provide separate C and C++
          # compilers
          if compiler is not None:
@@ -16,8 +14,8 @@
 +            args['compiler_so'] = compiler + ' ' + ccshared + ' ' + cppflags + ' ' + cflags
          self.compiler.set_executables(**args)
  
-         # Not only do we write the builddir cookie, but we manually install
-@@ -455,12 +457,7 @@
+         build_ext.build_extensions(self)
+@@ -435,12 +437,7 @@
              os.unlink(tmpfile)
  
      def detect_modules(self):

=== modified file 'debian/patches/disable-sem-check.diff'
--- debian/patches/disable-sem-check.diff	2012-06-21 16:04:00 +0000
+++ debian/patches/disable-sem-check.diff	2013-09-17 18:06:34 +0000
@@ -1,10 +1,8 @@
 # DP: Assume working semaphores, don't rely on running kernel for the check.
 
-Index: b/configure.ac
-===================================================================
 --- a/configure.ac
 +++ b/configure.ac
-@@ -3595,8 +3595,13 @@
+@@ -3798,8 +3798,13 @@
  AC_MSG_RESULT($ac_cv_posix_semaphores_enabled)
  if test $ac_cv_posix_semaphores_enabled = no
  then
@@ -20,7 +18,7 @@
  fi
  
  # Multiprocessing check for broken sem_getvalue
-@@ -3631,8 +3636,13 @@
+@@ -3834,8 +3839,13 @@
  AC_MSG_RESULT($ac_cv_broken_sem_getvalue)
  if test $ac_cv_broken_sem_getvalue = yes
  then

=== modified file 'debian/patches/distutils-init.diff'
--- debian/patches/distutils-init.diff	2012-08-13 11:05:00 +0000
+++ debian/patches/distutils-init.diff	2013-09-17 18:06:34 +0000
@@ -1,10 +1,8 @@
 # DP: Use _sysconfigdata.py in distutils to initialize distutils
 
-Index: b/Lib/distutils/sysconfig.py
-===================================================================
 --- a/Lib/distutils/sysconfig.py
 +++ b/Lib/distutils/sysconfig.py
-@@ -442,49 +442,11 @@
+@@ -454,49 +454,11 @@
  
  def _init_posix():
      """Initialize the module as appropriate for POSIX systems."""

=== modified file 'debian/patches/distutils-install-layout.diff'
--- debian/patches/distutils-install-layout.diff	2013-03-26 10:45:37 +0000
+++ debian/patches/distutils-install-layout.diff	2013-09-17 18:06:34 +0000
@@ -2,8 +2,6 @@
 # DP: - installs into $prefix/dist-packages instead of $prefix/site-packages.
 # DP: - doesn't encode the python version into the egg name.
 
-Index: b/Lib/distutils/command/install_egg_info.py
-===================================================================
 --- a/Lib/distutils/command/install_egg_info.py
 +++ b/Lib/distutils/command/install_egg_info.py
 @@ -14,18 +14,38 @@
@@ -50,8 +48,6 @@
          self.target = os.path.join(self.install_dir, basename)
          self.outputs = [self.target]
  
-Index: b/Lib/distutils/command/install.py
-===================================================================
 --- a/Lib/distutils/command/install.py
 +++ b/Lib/distutils/command/install.py
 @@ -50,6 +50,20 @@
@@ -137,8 +133,6 @@
  
      def finalize_other(self):
          """Finalizes options for non-posix platforms"""
-Index: b/Lib/distutils/sysconfig.py
-===================================================================
 --- a/Lib/distutils/sysconfig.py
 +++ b/Lib/distutils/sysconfig.py
 @@ -136,6 +136,7 @@
@@ -158,8 +152,6 @@
          else:
              return os.path.join(libpython, "site-packages")
      elif os.name == "nt":
-Index: b/Lib/site.py
-===================================================================
 --- a/Lib/site.py
 +++ b/Lib/site.py
 @@ -285,6 +285,13 @@
@@ -176,8 +168,6 @@
      return known_paths
  
  def getsitepackages(prefixes=None):
-Index: b/Lib/test/test_site.py
-===================================================================
 --- a/Lib/test/test_site.py
 +++ b/Lib/test/test_site.py
 @@ -239,12 +239,20 @@
@@ -205,8 +195,6 @@
          else:
              # other platforms
              self.assertEqual(len(dirs), 2)
-Index: b/Lib/distutils/tests/test_bdist_dumb.py
-===================================================================
 --- a/Lib/distutils/tests/test_bdist_dumb.py
 +++ b/Lib/distutils/tests/test_bdist_dumb.py
 @@ -88,7 +88,7 @@
@@ -218,8 +206,6 @@
          if not sys.dont_write_bytecode:
              wanted.append('foo.%s.pyc' % imp.get_tag())
          self.assertEqual(contents, sorted(wanted))
-Index: b/Lib/distutils/tests/test_install.py
-===================================================================
 --- a/Lib/distutils/tests/test_install.py
 +++ b/Lib/distutils/tests/test_install.py
 @@ -194,7 +194,7 @@
@@ -240,8 +226,6 @@
          self.assertEqual(found, expected)
  
      def test_debug_mode(self):
-Index: b/Lib/pydoc.py
-===================================================================
 --- a/Lib/pydoc.py
 +++ b/Lib/pydoc.py
 @@ -383,6 +383,7 @@

=== modified file 'debian/patches/distutils-link.diff'
--- debian/patches/distutils-link.diff	2012-06-21 16:04:00 +0000
+++ debian/patches/distutils-link.diff	2013-09-17 18:06:34 +0000
@@ -1,10 +1,8 @@
 # DP: Don't add standard library dirs to library_dirs and runtime_library_dirs.
 
-Index: b/Lib/distutils/unixccompiler.py
-===================================================================
 --- a/Lib/distutils/unixccompiler.py
 +++ b/Lib/distutils/unixccompiler.py
-@@ -211,6 +211,13 @@
+@@ -153,6 +153,13 @@
                                          runtime_library_dirs)
          libraries, library_dirs, runtime_library_dirs = fixed_args
  

=== modified file 'debian/patches/distutils-sysconfig.diff'
--- debian/patches/distutils-sysconfig.diff	2013-03-26 10:45:37 +0000
+++ debian/patches/distutils-sysconfig.diff	2013-09-17 18:06:34 +0000
@@ -2,8 +2,6 @@
 # DP: the python build, when CFLAGS, CPPFLAGS, LDSHARED) are not set
 # DP: in the environment.
 
-Index: b/Lib/distutils/sysconfig.py
-===================================================================
 --- a/Lib/distutils/sysconfig.py
 +++ b/Lib/distutils/sysconfig.py
 @@ -194,9 +194,11 @@
@@ -18,9 +16,9 @@
 +                            'CCSHARED', 'LDSHARED', 'SHLIB_SUFFIX', 'AR', 'ARFLAGS',
 +                            'CONFIGURE_CPPFLAGS', 'CONFIGURE_CFLAGS', 'CONFIGURE_LDFLAGS')
  
-         newcc = None
          if 'CC' in os.environ:
-@@ -211,13 +213,22 @@
+             newcc = os.environ['CC']
+@@ -217,13 +219,22 @@
              cpp = cc + " -E"           # not always
          if 'LDFLAGS' in os.environ:
              ldshared = ldshared + ' ' + os.environ['LDFLAGS']

=== modified file 'debian/patches/enable-fpectl.diff'
--- debian/patches/enable-fpectl.diff	2012-06-21 16:04:00 +0000
+++ debian/patches/enable-fpectl.diff	2013-09-17 18:06:34 +0000
@@ -1,10 +1,8 @@
 # DP: Enable the build of the fpectl module.
 
-Index: b/setup.py
-===================================================================
 --- a/setup.py
 +++ b/setup.py
-@@ -1211,6 +1211,9 @@
+@@ -1292,6 +1292,9 @@
          else:
              missing.append('_curses_panel')
  

=== modified file 'debian/patches/ext-no-libpython-link.diff'
--- debian/patches/ext-no-libpython-link.diff	2012-11-28 13:47:16 +0000
+++ debian/patches/ext-no-libpython-link.diff	2013-09-17 18:06:34 +0000
@@ -2,7 +2,7 @@
 
 --- a/Lib/distutils/command/build_ext.py
 +++ b/Lib/distutils/command/build_ext.py
-@@ -243,7 +243,7 @@
+@@ -250,7 +250,7 @@
          # for extensions under Linux or Solaris with a shared Python library,
          # Python's library directory must be appended to library_dirs
          sysconfig.get_config_var('Py_ENABLE_SHARED')
@@ -11,7 +11,7 @@
              and sysconfig.get_config_var('Py_ENABLE_SHARED')):
              if sys.executable.startswith(os.path.join(sys.exec_prefix, "bin")):
                  # building third party extensions
-@@ -753,7 +753,7 @@
+@@ -760,7 +760,7 @@
              return ext.libraries
          else:
              from distutils import sysconfig

=== modified file 'debian/patches/hg-updates.diff'
--- debian/patches/hg-updates.diff	2013-06-05 12:28:37 +0000
+++ debian/patches/hg-updates.diff	2013-09-17 18:06:34 +0000
@@ -1,7 +1,1257 @@
-# DP: hg updates of the 3.3 release branch (until 2013-05-27, 83934:e57c8a90b2df).
+# DP: hg updates of the 3.3 release branch (until 2013-08-03, 84986:c503cea0e8c2).
 
 # hg diff -r v3.3.2 | filterdiff --exclude=.hgignore --exclude=.hgeol --exclude=.hgtags --remove-timestamps
 
+diff -r d047928ae3f6 Doc/c-api/allocation.rst
+--- a/Doc/c-api/allocation.rst
++++ b/Doc/c-api/allocation.rst
+@@ -32,7 +32,7 @@
+    Allocate a new Python object using the C structure type *TYPE* and the
+    Python type object *type*.  Fields not defined by the Python object header
+    are not initialized; the object's reference count will be one.  The size of
+-   the memory allocation is determined from the :attr:`tp_basicsize` field of
++   the memory allocation is determined from the :c:member:`~PyTypeObject.tp_basicsize` field of
+    the type object.
+ 
+ 
+@@ -41,7 +41,7 @@
+    Allocate a new Python object using the C structure type *TYPE* and the
+    Python type object *type*.  Fields not defined by the Python object header
+    are not initialized.  The allocated memory allows for the *TYPE* structure
+-   plus *size* fields of the size given by the :attr:`tp_itemsize` field of
++   plus *size* fields of the size given by the :c:member:`~PyTypeObject.tp_itemsize` field of
+    *type*.  This is useful for implementing objects like tuples, which are
+    able to determine their size at construction time.  Embedding the array of
+    fields into the same allocation decreases the number of allocations,
+@@ -52,7 +52,7 @@
+ 
+    Releases memory allocated to an object using :c:func:`PyObject_New` or
+    :c:func:`PyObject_NewVar`.  This is normally called from the
+-   :attr:`tp_dealloc` handler specified in the object's type.  The fields of
++   :c:member:`~PyTypeObject.tp_dealloc` handler specified in the object's type.  The fields of
+    the object should not be accessed after this call as the memory is no
+    longer a valid Python object.
+ 
+diff -r d047928ae3f6 Doc/c-api/exceptions.rst
+--- a/Doc/c-api/exceptions.rst
++++ b/Doc/c-api/exceptions.rst
+@@ -607,28 +607,28 @@
+    Ends a :c:func:`Py_EnterRecursiveCall`.  Must be called once for each
+    *successful* invocation of :c:func:`Py_EnterRecursiveCall`.
+ 
+-Properly implementing :attr:`tp_repr` for container types requires
++Properly implementing :c:member:`~PyTypeObject.tp_repr` for container types requires
+ special recursion handling.  In addition to protecting the stack,
+-:attr:`tp_repr` also needs to track objects to prevent cycles.  The
++:c:member:`~PyTypeObject.tp_repr` also needs to track objects to prevent cycles.  The
+ following two functions facilitate this functionality.  Effectively,
+ these are the C equivalent to :func:`reprlib.recursive_repr`.
+ 
+ .. c:function:: int Py_ReprEnter(PyObject *object)
+ 
+-   Called at the beginning of the :attr:`tp_repr` implementation to
++   Called at the beginning of the :c:member:`~PyTypeObject.tp_repr` implementation to
+    detect cycles.
+ 
+    If the object has already been processed, the function returns a
+-   positive integer.  In that case the :attr:`tp_repr` implementation
++   positive integer.  In that case the :c:member:`~PyTypeObject.tp_repr` implementation
+    should return a string object indicating a cycle.  As examples,
+    :class:`dict` objects return ``{...}`` and :class:`list` objects
+    return ``[...]``.
+ 
+    The function will return a negative integer if the recursion limit
+-   is reached.  In that case the :attr:`tp_repr` implementation should
++   is reached.  In that case the :c:member:`~PyTypeObject.tp_repr` implementation should
+    typically return ``NULL``.
+ 
+-   Otherwise, the function returns zero and the :attr:`tp_repr`
++   Otherwise, the function returns zero and the :c:member:`~PyTypeObject.tp_repr`
+    implementation can continue normally.
+ 
+ .. c:function:: void Py_ReprLeave(PyObject *object)
+diff -r d047928ae3f6 Doc/c-api/gcsupport.rst
+--- a/Doc/c-api/gcsupport.rst
++++ b/Doc/c-api/gcsupport.rst
+@@ -12,10 +12,10 @@
+ or strings), do not need to provide any explicit support for garbage
+ collection.
+ 
+-To create a container type, the :attr:`tp_flags` field of the type object must
++To create a container type, the :c:member:`~PyTypeObject.tp_flags` field of the type object must
+ include the :const:`Py_TPFLAGS_HAVE_GC` and provide an implementation of the
+-:attr:`tp_traverse` handler.  If instances of the type are mutable, a
+-:attr:`tp_clear` implementation must also be provided.
++:c:member:`~PyTypeObject.tp_traverse` handler.  If instances of the type are mutable, a
++:c:member:`~PyTypeObject.tp_clear` implementation must also be provided.
+ 
+ 
+ .. data:: Py_TPFLAGS_HAVE_GC
+@@ -57,7 +57,7 @@
+    Adds the object *op* to the set of container objects tracked by the
+    collector.  The collector can run at unexpected times so objects must be
+    valid while being tracked.  This should be called once all the fields
+-   followed by the :attr:`tp_traverse` handler become valid, usually near the
++   followed by the :c:member:`~PyTypeObject.tp_traverse` handler become valid, usually near the
+    end of the constructor.
+ 
+ 
+@@ -86,8 +86,8 @@
+    Remove the object *op* from the set of container objects tracked by the
+    collector.  Note that :c:func:`PyObject_GC_Track` can be called again on
+    this object to add it back to the set of tracked objects.  The deallocator
+-   (:attr:`tp_dealloc` handler) should call this for the object before any of
+-   the fields used by the :attr:`tp_traverse` handler become invalid.
++   (:c:member:`~PyTypeObject.tp_dealloc` handler) should call this for the object before any of
++   the fields used by the :c:member:`~PyTypeObject.tp_traverse` handler become invalid.
+ 
+ 
+ .. c:function:: void _PyObject_GC_UNTRACK(PyObject *op)
+@@ -95,19 +95,19 @@
+    A macro version of :c:func:`PyObject_GC_UnTrack`.  It should not be used for
+    extension modules.
+ 
+-The :attr:`tp_traverse` handler accepts a function parameter of this type:
++The :c:member:`~PyTypeObject.tp_traverse` handler accepts a function parameter of this type:
+ 
+ 
+ .. c:type:: int (*visitproc)(PyObject *object, void *arg)
+ 
+-   Type of the visitor function passed to the :attr:`tp_traverse` handler.
++   Type of the visitor function passed to the :c:member:`~PyTypeObject.tp_traverse` handler.
+    The function should be called with an object to traverse as *object* and
+-   the third parameter to the :attr:`tp_traverse` handler as *arg*.  The
++   the third parameter to the :c:member:`~PyTypeObject.tp_traverse` handler as *arg*.  The
+    Python core uses several visitor functions to implement cyclic garbage
+    detection; it's not expected that users will need to write their own
+    visitor functions.
+ 
+-The :attr:`tp_traverse` handler must have the following type:
++The :c:member:`~PyTypeObject.tp_traverse` handler must have the following type:
+ 
+ 
+ .. c:type:: int (*traverseproc)(PyObject *self, visitproc visit, void *arg)
+@@ -119,15 +119,15 @@
+    object argument.  If *visit* returns a non-zero value that value should be
+    returned immediately.
+ 
+-To simplify writing :attr:`tp_traverse` handlers, a :c:func:`Py_VISIT` macro is
+-provided.  In order to use this macro, the :attr:`tp_traverse` implementation
++To simplify writing :c:member:`~PyTypeObject.tp_traverse` handlers, a :c:func:`Py_VISIT` macro is
++provided.  In order to use this macro, the :c:member:`~PyTypeObject.tp_traverse` implementation
+ must name its arguments exactly *visit* and *arg*:
+ 
+ 
+ .. c:function:: void Py_VISIT(PyObject *o)
+ 
+    Call the *visit* callback, with arguments *o* and *arg*. If *visit* returns
+-   a non-zero value, then return it.  Using this macro, :attr:`tp_traverse`
++   a non-zero value, then return it.  Using this macro, :c:member:`~PyTypeObject.tp_traverse`
+    handlers look like::
+ 
+       static int
+@@ -138,7 +138,7 @@
+           return 0;
+       }
+ 
+-The :attr:`tp_clear` handler must be of the :c:type:`inquiry` type, or *NULL*
++The :c:member:`~PyTypeObject.tp_clear` handler must be of the :c:type:`inquiry` type, or *NULL*
+ if the object is immutable.
+ 
+ 
+diff -r d047928ae3f6 Doc/c-api/type.rst
+--- a/Doc/c-api/type.rst
++++ b/Doc/c-api/type.rst
+@@ -37,10 +37,10 @@
+ 
+ .. c:function:: long PyType_GetFlags(PyTypeObject* type)
+ 
+-   Return the :attr:`tp_flags` member of *type*. This function is primarily
++   Return the :c:member:`~PyTypeObject.tp_flags` member of *type*. This function is primarily
+    meant for use with `Py_LIMITED_API`; the individual flag bits are
+    guaranteed to be stable across Python releases, but access to
+-   :attr:`tp_flags` itself is not part of the limited API.
++   :c:member:`~PyTypeObject.tp_flags` itself is not part of the limited API.
+ 
+    .. versionadded:: 3.2
+ 
+@@ -70,14 +70,14 @@
+ 
+ .. c:function:: PyObject* PyType_GenericAlloc(PyTypeObject *type, Py_ssize_t nitems)
+ 
+-   Generic handler for the :attr:`tp_alloc` slot of a type object.  Use
++   Generic handler for the :c:member:`~PyTypeObject.tp_alloc` slot of a type object.  Use
+    Python's default memory allocation mechanism to allocate a new instance and
+    initialize all its contents to *NULL*.
+ 
+ .. c:function:: PyObject* PyType_GenericNew(PyTypeObject *type, PyObject *args, PyObject *kwds)
+ 
+-   Generic handler for the :attr:`tp_new` slot of a type object.  Create a
+-   new instance using the type's :attr:`tp_alloc` slot.
++   Generic handler for the :c:member:`~PyTypeObject.tp_new` slot of a type object.  Create a
++   new instance using the type's :c:member:`~PyTypeObject.tp_alloc` slot.
+ 
+ .. c:function:: int PyType_Ready(PyTypeObject *type)
+ 
+diff -r d047928ae3f6 Doc/c-api/typeobj.rst
+--- a/Doc/c-api/typeobj.rst
++++ b/Doc/c-api/typeobj.rst
+@@ -35,7 +35,7 @@
+ The type object structure extends the :c:type:`PyVarObject` structure. The
+ :attr:`ob_size` field is used for dynamic types (created by  :func:`type_new`,
+ usually called from a class statement). Note that :c:data:`PyType_Type` (the
+-metatype) initializes :attr:`tp_itemsize`, which means that its instances (i.e.
++metatype) initializes :c:member:`~PyTypeObject.tp_itemsize`, which means that its instances (i.e.
+ type objects) *must* have the :attr:`ob_size` field.
+ 
+ 
+@@ -102,7 +102,7 @@
+    should be just the type name.  If the module is a submodule of a package, the
+    full package name is part of the full module name.  For example, a type named
+    :class:`T` defined in module :mod:`M` in subpackage :mod:`Q` in package :mod:`P`
+-   should have the :attr:`tp_name` initializer ``"P.Q.M.T"``.
++   should have the :c:member:`~PyTypeObject.tp_name` initializer ``"P.Q.M.T"``.
+ 
+    For dynamically allocated type objects, this should just be the type name, and
+    the module name explicitly stored in the type dict as the value for key
+@@ -113,7 +113,7 @@
+    attribute, and everything after the last dot is made accessible as the
+    :attr:`__name__` attribute.
+ 
+-   If no dot is present, the entire :attr:`tp_name` field is made accessible as the
++   If no dot is present, the entire :c:member:`~PyTypeObject.tp_name` field is made accessible as the
+    :attr:`__name__` attribute, and the :attr:`__module__` attribute is undefined
+    (unless explicitly set in the dictionary, as explained above).  This means your
+    type will be impossible to pickle.
+@@ -127,13 +127,13 @@
+    These fields allow calculating the size in bytes of instances of the type.
+ 
+    There are two kinds of types: types with fixed-length instances have a zero
+-   :attr:`tp_itemsize` field, types with variable-length instances have a non-zero
+-   :attr:`tp_itemsize` field.  For a type with fixed-length instances, all
+-   instances have the same size, given in :attr:`tp_basicsize`.
++   :c:member:`~PyTypeObject.tp_itemsize` field, types with variable-length instances have a non-zero
++   :c:member:`~PyTypeObject.tp_itemsize` field.  For a type with fixed-length instances, all
++   instances have the same size, given in :c:member:`~PyTypeObject.tp_basicsize`.
+ 
+    For a type with variable-length instances, the instances must have an
+-   :attr:`ob_size` field, and the instance size is :attr:`tp_basicsize` plus N
+-   times :attr:`tp_itemsize`, where N is the "length" of the object.  The value of
++   :attr:`ob_size` field, and the instance size is :c:member:`~PyTypeObject.tp_basicsize` plus N
++   times :c:member:`~PyTypeObject.tp_itemsize`, where N is the "length" of the object.  The value of
+    N is typically stored in the instance's :attr:`ob_size` field.  There are
+    exceptions:  for example, ints use a negative :attr:`ob_size` to indicate a
+    negative number, and N is ``abs(ob_size)`` there.  Also, the presence of an
+@@ -146,20 +146,20 @@
+    :c:macro:`PyObject_HEAD` or :c:macro:`PyObject_VAR_HEAD` (whichever is used to
+    declare the instance struct) and this in turn includes the :attr:`_ob_prev` and
+    :attr:`_ob_next` fields if they are present.  This means that the only correct
+-   way to get an initializer for the :attr:`tp_basicsize` is to use the
++   way to get an initializer for the :c:member:`~PyTypeObject.tp_basicsize` is to use the
+    ``sizeof`` operator on the struct used to declare the instance layout.
+    The basic size does not include the GC header size.
+ 
+    These fields are inherited separately by subtypes.  If the base type has a
+-   non-zero :attr:`tp_itemsize`, it is generally not safe to set
+-   :attr:`tp_itemsize` to a different non-zero value in a subtype (though this
++   non-zero :c:member:`~PyTypeObject.tp_itemsize`, it is generally not safe to set
++   :c:member:`~PyTypeObject.tp_itemsize` to a different non-zero value in a subtype (though this
+    depends on the implementation of the base type).
+ 
+    A note about alignment: if the variable items require a particular alignment,
+-   this should be taken care of by the value of :attr:`tp_basicsize`.  Example:
+-   suppose a type implements an array of ``double``. :attr:`tp_itemsize` is
++   this should be taken care of by the value of :c:member:`~PyTypeObject.tp_basicsize`.  Example:
++   suppose a type implements an array of ``double``. :c:member:`~PyTypeObject.tp_itemsize` is
+    ``sizeof(double)``. It is the programmer's responsibility that
+-   :attr:`tp_basicsize` is a multiple of ``sizeof(double)`` (assuming this is the
++   :c:member:`~PyTypeObject.tp_basicsize` is a multiple of ``sizeof(double)`` (assuming this is the
+    alignment requirement for ``double``).
+ 
+ 
+@@ -175,10 +175,10 @@
+    destructor function should free all references which the instance owns, free all
+    memory buffers owned by the instance (using the freeing function corresponding
+    to the allocation function used to allocate the buffer), and finally (as its
+-   last action) call the type's :attr:`tp_free` function.  If the type is not
++   last action) call the type's :c:member:`~PyTypeObject.tp_free` function.  If the type is not
+    subtypable (doesn't have the :const:`Py_TPFLAGS_BASETYPE` flag bit set), it is
+    permissible to call the object deallocator directly instead of via
+-   :attr:`tp_free`.  The object deallocator should be the one used to allocate the
++   :c:member:`~PyTypeObject.tp_free`.  The object deallocator should be the one used to allocate the
+    instance; this is normally :c:func:`PyObject_Del` if the instance was allocated
+    using :c:func:`PyObject_New` or :c:func:`PyObject_VarNew`, or
+    :c:func:`PyObject_GC_Del` if the instance was allocated using
+@@ -193,25 +193,25 @@
+ 
+    The print function is only called when the instance is printed to a *real* file;
+    when it is printed to a pseudo-file (like a :class:`StringIO` instance), the
+-   instance's :attr:`tp_repr` or :attr:`tp_str` function is called to convert it to
+-   a string.  These are also called when the type's :attr:`tp_print` field is
+-   *NULL*.  A type should never implement :attr:`tp_print` in a way that produces
+-   different output than :attr:`tp_repr` or :attr:`tp_str` would.
++   instance's :c:member:`~PyTypeObject.tp_repr` or :c:member:`~PyTypeObject.tp_str` function is called to convert it to
++   a string.  These are also called when the type's :c:member:`~PyTypeObject.tp_print` field is
++   *NULL*.  A type should never implement :c:member:`~PyTypeObject.tp_print` in a way that produces
++   different output than :c:member:`~PyTypeObject.tp_repr` or :c:member:`~PyTypeObject.tp_str` would.
+ 
+    The print function is called with the same signature as :c:func:`PyObject_Print`:
+    ``int tp_print(PyObject *self, FILE *file, int flags)``.  The *self* argument is
+    the instance to be printed.  The *file* argument is the stdio file to which it
+    is to be printed.  The *flags* argument is composed of flag bits. The only flag
+    bit currently defined is :const:`Py_PRINT_RAW`. When the :const:`Py_PRINT_RAW`
+-   flag bit is set, the instance should be printed the same way as :attr:`tp_str`
++   flag bit is set, the instance should be printed the same way as :c:member:`~PyTypeObject.tp_str`
+    would format it; when the :const:`Py_PRINT_RAW` flag bit is clear, the instance
+-   should be printed the same was as :attr:`tp_repr` would format it. It should
++   should be printed the same was as :c:member:`~PyTypeObject.tp_repr` would format it. It should
+    return ``-1`` and set an exception condition when an error occurred during the
+    comparison.
+ 
+-   It is possible that the :attr:`tp_print` field will be deprecated. In any case,
+-   it is recommended not to define :attr:`tp_print`, but instead to rely on
+-   :attr:`tp_repr` and :attr:`tp_str` for printing.
++   It is possible that the :c:member:`~PyTypeObject.tp_print` field will be deprecated. In any case,
++   it is recommended not to define :c:member:`~PyTypeObject.tp_print`, but instead to rely on
++   :c:member:`~PyTypeObject.tp_repr` and :c:member:`~PyTypeObject.tp_str` for printing.
+ 
+    This field is inherited by subtypes.
+ 
+@@ -221,13 +221,13 @@
+    An optional pointer to the get-attribute-string function.
+ 
+    This field is deprecated.  When it is defined, it should point to a function
+-   that acts the same as the :attr:`tp_getattro` function, but taking a C string
++   that acts the same as the :c:member:`~PyTypeObject.tp_getattro` function, but taking a C string
+    instead of a Python string object to give the attribute name.  The signature is
+    the same as for :c:func:`PyObject_GetAttrString`.
+ 
+-   This field is inherited by subtypes together with :attr:`tp_getattro`: a subtype
+-   inherits both :attr:`tp_getattr` and :attr:`tp_getattro` from its base type when
+-   the subtype's :attr:`tp_getattr` and :attr:`tp_getattro` are both *NULL*.
++   This field is inherited by subtypes together with :c:member:`~PyTypeObject.tp_getattro`: a subtype
++   inherits both :c:member:`~PyTypeObject.tp_getattr` and :c:member:`~PyTypeObject.tp_getattro` from its base type when
++   the subtype's :c:member:`~PyTypeObject.tp_getattr` and :c:member:`~PyTypeObject.tp_getattro` are both *NULL*.
+ 
+ 
+ .. c:member:: setattrfunc PyTypeObject.tp_setattr
+@@ -235,13 +235,13 @@
+    An optional pointer to the set-attribute-string function.
+ 
+    This field is deprecated.  When it is defined, it should point to a function
+-   that acts the same as the :attr:`tp_setattro` function, but taking a C string
++   that acts the same as the :c:member:`~PyTypeObject.tp_setattro` function, but taking a C string
+    instead of a Python string object to give the attribute name.  The signature is
+    the same as for :c:func:`PyObject_SetAttrString`.
+ 
+-   This field is inherited by subtypes together with :attr:`tp_setattro`: a subtype
+-   inherits both :attr:`tp_setattr` and :attr:`tp_setattro` from its base type when
+-   the subtype's :attr:`tp_setattr` and :attr:`tp_setattro` are both *NULL*.
++   This field is inherited by subtypes together with :c:member:`~PyTypeObject.tp_setattro`: a subtype
++   inherits both :c:member:`~PyTypeObject.tp_setattr` and :c:member:`~PyTypeObject.tp_setattro` from its base type when
++   the subtype's :c:member:`~PyTypeObject.tp_setattr` and :c:member:`~PyTypeObject.tp_setattro` are both *NULL*.
+ 
+ 
+ .. c:member:: void* PyTypeObject.tp_reserved
+@@ -275,7 +275,7 @@
+    objects which implement the number protocol.  These fields are documented in
+    :ref:`number-structs`.
+ 
+-   The :attr:`tp_as_number` field is not inherited, but the contained fields are
++   The :c:member:`~PyTypeObject.tp_as_number` field is not inherited, but the contained fields are
+    inherited individually.
+ 
+ 
+@@ -285,7 +285,7 @@
+    objects which implement the sequence protocol.  These fields are documented
+    in :ref:`sequence-structs`.
+ 
+-   The :attr:`tp_as_sequence` field is not inherited, but the contained fields
++   The :c:member:`~PyTypeObject.tp_as_sequence` field is not inherited, but the contained fields
+    are inherited individually.
+ 
+ 
+@@ -295,7 +295,7 @@
+    objects which implement the mapping protocol.  These fields are documented in
+    :ref:`mapping-structs`.
+ 
+-   The :attr:`tp_as_mapping` field is not inherited, but the contained fields
++   The :c:member:`~PyTypeObject.tp_as_mapping` field is not inherited, but the contained fields
+    are inherited individually.
+ 
+ 
+@@ -323,9 +323,9 @@
+    object raises :exc:`TypeError`.
+ 
+    This field is inherited by subtypes together with
+-   :attr:`tp_richcompare`: a subtype inherits both of
+-   :attr:`tp_richcompare` and :attr:`tp_hash`, when the subtype's
+-   :attr:`tp_richcompare` and :attr:`tp_hash` are both *NULL*.
++   :c:member:`~PyTypeObject.tp_richcompare`: a subtype inherits both of
++   :c:member:`~PyTypeObject.tp_richcompare` and :c:member:`~PyTypeObject.tp_hash`, when the subtype's
++   :c:member:`~PyTypeObject.tp_richcompare` and :c:member:`~PyTypeObject.tp_hash` are both *NULL*.
+ 
+ 
+ .. c:member:: ternaryfunc PyTypeObject.tp_call
+@@ -363,9 +363,9 @@
+    convenient to set this field to :c:func:`PyObject_GenericGetAttr`, which
+    implements the normal way of looking for object attributes.
+ 
+-   This field is inherited by subtypes together with :attr:`tp_getattr`: a subtype
+-   inherits both :attr:`tp_getattr` and :attr:`tp_getattro` from its base type when
+-   the subtype's :attr:`tp_getattr` and :attr:`tp_getattro` are both *NULL*.
++   This field is inherited by subtypes together with :c:member:`~PyTypeObject.tp_getattr`: a subtype
++   inherits both :c:member:`~PyTypeObject.tp_getattr` and :c:member:`~PyTypeObject.tp_getattro` from its base type when
++   the subtype's :c:member:`~PyTypeObject.tp_getattr` and :c:member:`~PyTypeObject.tp_getattro` are both *NULL*.
+ 
+ 
+ .. c:member:: setattrofunc PyTypeObject.tp_setattro
+@@ -376,9 +376,9 @@
+    convenient to set this field to :c:func:`PyObject_GenericSetAttr`, which
+    implements the normal way of setting object attributes.
+ 
+-   This field is inherited by subtypes together with :attr:`tp_setattr`: a subtype
+-   inherits both :attr:`tp_setattr` and :attr:`tp_setattro` from its base type when
+-   the subtype's :attr:`tp_setattr` and :attr:`tp_setattro` are both *NULL*.
++   This field is inherited by subtypes together with :c:member:`~PyTypeObject.tp_setattr`: a subtype
++   inherits both :c:member:`~PyTypeObject.tp_setattr` and :c:member:`~PyTypeObject.tp_setattro` from its base type when
++   the subtype's :c:member:`~PyTypeObject.tp_setattr` and :c:member:`~PyTypeObject.tp_setattro` are both *NULL*.
+ 
+ 
+ .. c:member:: PyBufferProcs* PyTypeObject.tp_as_buffer
+@@ -387,7 +387,7 @@
+    which implement the buffer interface.  These fields are documented in
+    :ref:`buffer-structs`.
+ 
+-   The :attr:`tp_as_buffer` field is not inherited, but the contained fields are
++   The :c:member:`~PyTypeObject.tp_as_buffer` field is not inherited, but the contained fields are
+    inherited individually.
+ 
+ 
+@@ -396,8 +396,8 @@
+    This field is a bit mask of various flags.  Some flags indicate variant
+    semantics for certain situations; others are used to indicate that certain
+    fields in the type object (or in the extension structures referenced via
+-   :attr:`tp_as_number`, :attr:`tp_as_sequence`, :attr:`tp_as_mapping`, and
+-   :attr:`tp_as_buffer`) that were historically not always present are valid; if
++   :c:member:`~PyTypeObject.tp_as_number`, :c:member:`~PyTypeObject.tp_as_sequence`, :c:member:`~PyTypeObject.tp_as_mapping`, and
++   :c:member:`~PyTypeObject.tp_as_buffer`) that were historically not always present are valid; if
+    such a flag bit is clear, the type fields it guards must not be accessed and
+    must be considered to have a zero or *NULL* value instead.
+ 
+@@ -407,13 +407,13 @@
+    inherited if the extension structure is inherited, i.e. the base type's value of
+    the flag bit is copied into the subtype together with a pointer to the extension
+    structure.  The :const:`Py_TPFLAGS_HAVE_GC` flag bit is inherited together with
+-   the :attr:`tp_traverse` and :attr:`tp_clear` fields, i.e. if the
++   the :c:member:`~PyTypeObject.tp_traverse` and :c:member:`~PyTypeObject.tp_clear` fields, i.e. if the
+    :const:`Py_TPFLAGS_HAVE_GC` flag bit is clear in the subtype and the
+-   :attr:`tp_traverse` and :attr:`tp_clear` fields in the subtype exist and have
++   :c:member:`~PyTypeObject.tp_traverse` and :c:member:`~PyTypeObject.tp_clear` fields in the subtype exist and have
+    *NULL* values.
+ 
+    The following bit masks are currently defined; these can be ORed together using
+-   the ``|`` operator to form the value of the :attr:`tp_flags` field.  The macro
++   the ``|`` operator to form the value of the :c:member:`~PyTypeObject.tp_flags` field.  The macro
+    :c:func:`PyType_HasFeature` takes a type and a flags value, *tp* and *f*, and
+    checks whether ``tp->tp_flags & f`` is non-zero.
+ 
+@@ -453,7 +453,7 @@
+       is set, instances must be created using :c:func:`PyObject_GC_New` and
+       destroyed using :c:func:`PyObject_GC_Del`.  More information in section
+       :ref:`supporting-cycle-detection`.  This bit also implies that the
+-      GC-related fields :attr:`tp_traverse` and :attr:`tp_clear` are present in
++      GC-related fields :c:member:`~PyTypeObject.tp_traverse` and :c:member:`~PyTypeObject.tp_clear` are present in
+       the type object.
+ 
+ 
+@@ -481,8 +481,8 @@
+    about Python's garbage collection scheme can be found in section
+    :ref:`supporting-cycle-detection`.
+ 
+-   The :attr:`tp_traverse` pointer is used by the garbage collector to detect
+-   reference cycles. A typical implementation of a :attr:`tp_traverse` function
++   The :c:member:`~PyTypeObject.tp_traverse` pointer is used by the garbage collector to detect
++   reference cycles. A typical implementation of a :c:member:`~PyTypeObject.tp_traverse` function
+    simply calls :c:func:`Py_VISIT` on each of the instance's members that are Python
+    objects.  For example, this is function :c:func:`local_traverse` from the
+    :mod:`_thread` extension module::
+@@ -508,9 +508,9 @@
+    :c:func:`local_traverse` to have these specific names; don't name them just
+    anything.
+ 
+-   This field is inherited by subtypes together with :attr:`tp_clear` and the
+-   :const:`Py_TPFLAGS_HAVE_GC` flag bit: the flag bit, :attr:`tp_traverse`, and
+-   :attr:`tp_clear` are all inherited from the base type if they are all zero in
++   This field is inherited by subtypes together with :c:member:`~PyTypeObject.tp_clear` and the
++   :const:`Py_TPFLAGS_HAVE_GC` flag bit: the flag bit, :c:member:`~PyTypeObject.tp_traverse`, and
++   :c:member:`~PyTypeObject.tp_clear` are all inherited from the base type if they are all zero in
+    the subtype.
+ 
+ 
+@@ -519,17 +519,17 @@
+    An optional pointer to a clear function for the garbage collector. This is only
+    used if the :const:`Py_TPFLAGS_HAVE_GC` flag bit is set.
+ 
+-   The :attr:`tp_clear` member function is used to break reference cycles in cyclic
+-   garbage detected by the garbage collector.  Taken together, all :attr:`tp_clear`
++   The :c:member:`~PyTypeObject.tp_clear` member function is used to break reference cycles in cyclic
++   garbage detected by the garbage collector.  Taken together, all :c:member:`~PyTypeObject.tp_clear`
+    functions in the system must combine to break all reference cycles.  This is
+-   subtle, and if in any doubt supply a :attr:`tp_clear` function.  For example,
+-   the tuple type does not implement a :attr:`tp_clear` function, because it's
++   subtle, and if in any doubt supply a :c:member:`~PyTypeObject.tp_clear` function.  For example,
++   the tuple type does not implement a :c:member:`~PyTypeObject.tp_clear` function, because it's
+    possible to prove that no reference cycle can be composed entirely of tuples.
+-   Therefore the :attr:`tp_clear` functions of other types must be sufficient to
++   Therefore the :c:member:`~PyTypeObject.tp_clear` functions of other types must be sufficient to
+    break any cycle containing a tuple.  This isn't immediately obvious, and there's
+-   rarely a good reason to avoid implementing :attr:`tp_clear`.
++   rarely a good reason to avoid implementing :c:member:`~PyTypeObject.tp_clear`.
+ 
+-   Implementations of :attr:`tp_clear` should drop the instance's references to
++   Implementations of :c:member:`~PyTypeObject.tp_clear` should drop the instance's references to
+    those of its members that may be Python objects, and set its pointers to those
+    members to *NULL*, as in the following example::
+ 
+@@ -554,18 +554,18 @@
+    so that *self* knows the contained object can no longer be used.  The
+    :c:func:`Py_CLEAR` macro performs the operations in a safe order.
+ 
+-   Because the goal of :attr:`tp_clear` functions is to break reference cycles,
++   Because the goal of :c:member:`~PyTypeObject.tp_clear` functions is to break reference cycles,
+    it's not necessary to clear contained objects like Python strings or Python
+    integers, which can't participate in reference cycles. On the other hand, it may
+    be convenient to clear all contained Python objects, and write the type's
+-   :attr:`tp_dealloc` function to invoke :attr:`tp_clear`.
++   :c:member:`~PyTypeObject.tp_dealloc` function to invoke :c:member:`~PyTypeObject.tp_clear`.
+ 
+    More information about Python's garbage collection scheme can be found in
+    section :ref:`supporting-cycle-detection`.
+ 
+-   This field is inherited by subtypes together with :attr:`tp_traverse` and the
+-   :const:`Py_TPFLAGS_HAVE_GC` flag bit: the flag bit, :attr:`tp_traverse`, and
+-   :attr:`tp_clear` are all inherited from the base type if they are all zero in
++   This field is inherited by subtypes together with :c:member:`~PyTypeObject.tp_traverse` and the
++   :const:`Py_TPFLAGS_HAVE_GC` flag bit: the flag bit, :c:member:`~PyTypeObject.tp_traverse`, and
++   :c:member:`~PyTypeObject.tp_clear` are all inherited from the base type if they are all zero in
+    the subtype.
+ 
+ 
+@@ -585,13 +585,13 @@
+       comparisons makes sense (e.g. ``==`` and ``!=``, but not ``<`` and
+       friends), directly raise :exc:`TypeError` in the rich comparison function.
+ 
+-   This field is inherited by subtypes together with :attr:`tp_hash`:
+-   a subtype inherits :attr:`tp_richcompare` and :attr:`tp_hash` when
+-   the subtype's :attr:`tp_richcompare` and :attr:`tp_hash` are both
++   This field is inherited by subtypes together with :c:member:`~PyTypeObject.tp_hash`:
++   a subtype inherits :c:member:`~PyTypeObject.tp_richcompare` and :c:member:`~PyTypeObject.tp_hash` when
++   the subtype's :c:member:`~PyTypeObject.tp_richcompare` and :c:member:`~PyTypeObject.tp_hash` are both
+    *NULL*.
+ 
+    The following constants are defined to be used as the third argument for
+-   :attr:`tp_richcompare` and for :c:func:`PyObject_RichCompare`:
++   :c:member:`~PyTypeObject.tp_richcompare` and for :c:func:`PyObject_RichCompare`:
+ 
+    +----------------+------------+
+    | Constant       | Comparison |
+@@ -619,26 +619,26 @@
+    instance structure needs to include a field of type :c:type:`PyObject\*` which is
+    initialized to *NULL*.
+ 
+-   Do not confuse this field with :attr:`tp_weaklist`; that is the list head for
++   Do not confuse this field with :c:member:`~PyTypeObject.tp_weaklist`; that is the list head for
+    weak references to the type object itself.
+ 
+    This field is inherited by subtypes, but see the rules listed below. A subtype
+    may override this offset; this means that the subtype uses a different weak
+    reference list head than the base type.  Since the list head is always found via
+-   :attr:`tp_weaklistoffset`, this should not be a problem.
++   :c:member:`~PyTypeObject.tp_weaklistoffset`, this should not be a problem.
+ 
+    When a type defined by a class statement has no :attr:`__slots__` declaration,
+    and none of its base types are weakly referenceable, the type is made weakly
+    referenceable by adding a weak reference list head slot to the instance layout
+-   and setting the :attr:`tp_weaklistoffset` of that slot's offset.
++   and setting the :c:member:`~PyTypeObject.tp_weaklistoffset` of that slot's offset.
+ 
+    When a type's :attr:`__slots__` declaration contains a slot named
+    :attr:`__weakref__`, that slot becomes the weak reference list head for
+    instances of the type, and the slot's offset is stored in the type's
+-   :attr:`tp_weaklistoffset`.
++   :c:member:`~PyTypeObject.tp_weaklistoffset`.
+ 
+    When a type's :attr:`__slots__` declaration does not contain a slot named
+-   :attr:`__weakref__`, the type inherits its :attr:`tp_weaklistoffset` from its
++   :attr:`__weakref__`, the type inherits its :c:member:`~PyTypeObject.tp_weaklistoffset` from its
+    base type.
+ 
+ .. c:member:: getiterfunc PyTypeObject.tp_iter
+@@ -660,7 +660,7 @@
+    *NULL* too.  Its presence signals that the instances of this type are
+    iterators.
+ 
+-   Iterator types should also define the :attr:`tp_iter` function, and that
++   Iterator types should also define the :c:member:`~PyTypeObject.tp_iter` function, and that
+    function should return the iterator instance itself (not a new iterator
+    instance).
+ 
+@@ -675,7 +675,7 @@
+    structures, declaring regular methods of this type.
+ 
+    For each entry in the array, an entry is added to the type's dictionary (see
+-   :attr:`tp_dict` below) containing a method descriptor.
++   :c:member:`~PyTypeObject.tp_dict` below) containing a method descriptor.
+ 
+    This field is not inherited by subtypes (methods are inherited through a
+    different mechanism).
+@@ -688,7 +688,7 @@
+    this type.
+ 
+    For each entry in the array, an entry is added to the type's dictionary (see
+-   :attr:`tp_dict` below) containing a member descriptor.
++   :c:member:`~PyTypeObject.tp_dict` below) containing a member descriptor.
+ 
+    This field is not inherited by subtypes (members are inherited through a
+    different mechanism).
+@@ -700,7 +700,7 @@
+    structures, declaring computed attributes of instances of this type.
+ 
+    For each entry in the array, an entry is added to the type's dictionary (see
+-   :attr:`tp_dict` below) containing a getset descriptor.
++   :c:member:`~PyTypeObject.tp_dict` below) containing a getset descriptor.
+ 
+    This field is not inherited by subtypes (computed attributes are inherited
+    through a different mechanism).
+@@ -748,7 +748,7 @@
+    .. warning::
+ 
+       It is not safe to use :c:func:`PyDict_SetItem` on or otherwise modify
+-      :attr:`tp_dict` with the dictionary C-API.
++      :c:member:`~PyTypeObject.tp_dict` with the dictionary C-API.
+ 
+ 
+ .. c:member:: descrgetfunc PyTypeObject.tp_descr_get
+@@ -784,7 +784,7 @@
+    the instance variable dictionary; this offset is used by
+    :c:func:`PyObject_GenericGetAttr`.
+ 
+-   Do not confuse this field with :attr:`tp_dict`; that is the dictionary for
++   Do not confuse this field with :c:member:`~PyTypeObject.tp_dict`; that is the dictionary for
+    attributes of the type object itself.
+ 
+    If the value of this field is greater than zero, it specifies the offset from
+@@ -793,20 +793,20 @@
+    offset is more expensive to use, and should only be used when the instance
+    structure contains a variable-length part.  This is used for example to add an
+    instance variable dictionary to subtypes of :class:`str` or :class:`tuple`. Note
+-   that the :attr:`tp_basicsize` field should account for the dictionary added to
++   that the :c:member:`~PyTypeObject.tp_basicsize` field should account for the dictionary added to
+    the end in that case, even though the dictionary is not included in the basic
+    object layout.  On a system with a pointer size of 4 bytes,
+-   :attr:`tp_dictoffset` should be set to ``-4`` to indicate that the dictionary is
++   :c:member:`~PyTypeObject.tp_dictoffset` should be set to ``-4`` to indicate that the dictionary is
+    at the very end of the structure.
+ 
+    The real dictionary offset in an instance can be computed from a negative
+-   :attr:`tp_dictoffset` as follows::
++   :c:member:`~PyTypeObject.tp_dictoffset` as follows::
+ 
+       dictoffset = tp_basicsize + abs(ob_size)*tp_itemsize + tp_dictoffset
+       if dictoffset is not aligned on sizeof(void*):
+           round up to sizeof(void*)
+ 
+-   where :attr:`tp_basicsize`, :attr:`tp_itemsize` and :attr:`tp_dictoffset` are
++   where :c:member:`~PyTypeObject.tp_basicsize`, :c:member:`~PyTypeObject.tp_itemsize` and :c:member:`~PyTypeObject.tp_dictoffset` are
+    taken from the type object, and :attr:`ob_size` is taken from the instance.  The
+    absolute value is taken because ints use the sign of :attr:`ob_size` to
+    store the sign of the number.  (There's never a need to do this calculation
+@@ -815,15 +815,15 @@
+    This field is inherited by subtypes, but see the rules listed below. A subtype
+    may override this offset; this means that the subtype instances store the
+    dictionary at a difference offset than the base type.  Since the dictionary is
+-   always found via :attr:`tp_dictoffset`, this should not be a problem.
++   always found via :c:member:`~PyTypeObject.tp_dictoffset`, this should not be a problem.
+ 
+    When a type defined by a class statement has no :attr:`__slots__` declaration,
+    and none of its base types has an instance variable dictionary, a dictionary
+-   slot is added to the instance layout and the :attr:`tp_dictoffset` is set to
++   slot is added to the instance layout and the :c:member:`~PyTypeObject.tp_dictoffset` is set to
+    that slot's offset.
+ 
+    When a type defined by a class statement has a :attr:`__slots__` declaration,
+-   the type inherits its :attr:`tp_dictoffset` from its base type.
++   the type inherits its :c:member:`~PyTypeObject.tp_dictoffset` from its base type.
+ 
+    (Adding a slot named :attr:`__dict__` to the :attr:`__slots__` declaration does
+    not have the expected effect, it just causes confusion.  Maybe this should be
+@@ -847,12 +847,12 @@
+    arguments represent positional and keyword arguments of the call to
+    :meth:`__init__`.
+ 
+-   The :attr:`tp_init` function, if not *NULL*, is called when an instance is
+-   created normally by calling its type, after the type's :attr:`tp_new` function
+-   has returned an instance of the type.  If the :attr:`tp_new` function returns an
++   The :c:member:`~PyTypeObject.tp_init` function, if not *NULL*, is called when an instance is
++   created normally by calling its type, after the type's :c:member:`~PyTypeObject.tp_new` function
++   has returned an instance of the type.  If the :c:member:`~PyTypeObject.tp_new` function returns an
+    instance of some other type that is not a subtype of the original type, no
+-   :attr:`tp_init` function is called; if :attr:`tp_new` returns an instance of a
+-   subtype of the original type, the subtype's :attr:`tp_init` is called.
++   :c:member:`~PyTypeObject.tp_init` function is called; if :c:member:`~PyTypeObject.tp_new` returns an instance of a
++   subtype of the original type, the subtype's :c:member:`~PyTypeObject.tp_init` is called.
+ 
+    This field is inherited by subtypes.
+ 
+@@ -869,14 +869,14 @@
+    initialization.  It should return a pointer to a block of memory of adequate
+    length for the instance, suitably aligned, and initialized to zeros, but with
+    :attr:`ob_refcnt` set to ``1`` and :attr:`ob_type` set to the type argument.  If
+-   the type's :attr:`tp_itemsize` is non-zero, the object's :attr:`ob_size` field
++   the type's :c:member:`~PyTypeObject.tp_itemsize` is non-zero, the object's :attr:`ob_size` field
+    should be initialized to *nitems* and the length of the allocated memory block
+    should be ``tp_basicsize + nitems*tp_itemsize``, rounded up to a multiple of
+    ``sizeof(void*)``; otherwise, *nitems* is not used and the length of the block
+-   should be :attr:`tp_basicsize`.
++   should be :c:member:`~PyTypeObject.tp_basicsize`.
+ 
+    Do not use this function to do any other instance initialization, not even to
+-   allocate additional memory; that should be done by :attr:`tp_new`.
++   allocate additional memory; that should be done by :c:member:`~PyTypeObject.tp_new`.
+ 
+    This field is inherited by static subtypes, but not by dynamic subtypes
+    (subtypes created by a class statement); in the latter, this field is always set
+@@ -898,20 +898,20 @@
+ 
+    The subtype argument is the type of the object being created; the *args* and
+    *kwds* arguments represent positional and keyword arguments of the call to the
+-   type.  Note that subtype doesn't have to equal the type whose :attr:`tp_new`
++   type.  Note that subtype doesn't have to equal the type whose :c:member:`~PyTypeObject.tp_new`
+    function is called; it may be a subtype of that type (but not an unrelated
+    type).
+ 
+-   The :attr:`tp_new` function should call ``subtype->tp_alloc(subtype, nitems)``
++   The :c:member:`~PyTypeObject.tp_new` function should call ``subtype->tp_alloc(subtype, nitems)``
+    to allocate space for the object, and then do only as much further
+    initialization as is absolutely necessary.  Initialization that can safely be
+-   ignored or repeated should be placed in the :attr:`tp_init` handler.  A good
++   ignored or repeated should be placed in the :c:member:`~PyTypeObject.tp_init` handler.  A good
+    rule of thumb is that for immutable types, all initialization should take place
+-   in :attr:`tp_new`, while for mutable types, most initialization should be
+-   deferred to :attr:`tp_init`.
++   in :c:member:`~PyTypeObject.tp_new`, while for mutable types, most initialization should be
++   deferred to :c:member:`~PyTypeObject.tp_init`.
+ 
+    This field is inherited by subtypes, except it is not inherited by static types
+-   whose :attr:`tp_base` is *NULL* or ``&PyBaseObject_Type``.
++   whose :c:member:`~PyTypeObject.tp_base` is *NULL* or ``&PyBaseObject_Type``.
+ 
+ 
+ .. c:member:: destructor PyTypeObject.tp_free
+@@ -935,7 +935,7 @@
+ 
+    The garbage collector needs to know whether a particular object is collectible
+    or not.  Normally, it is sufficient to look at the object's type's
+-   :attr:`tp_flags` field, and check the :const:`Py_TPFLAGS_HAVE_GC` flag bit.  But
++   :c:member:`~PyTypeObject.tp_flags` field, and check the :const:`Py_TPFLAGS_HAVE_GC` flag bit.  But
+    some types have a mixture of statically and dynamically allocated instances, and
+    the statically allocated instances are not collectible.  Such types should
+    define this function; it should return ``1`` for a collectible instance, and
+@@ -1006,7 +1006,7 @@
+ 
+ .. c:member:: PyTypeObject* PyTypeObject.tp_next
+ 
+-   Pointer to the next type object with a non-zero :attr:`tp_allocs` field.
++   Pointer to the next type object with a non-zero :c:member:`~PyTypeObject.tp_allocs` field.
+ 
+ Also, note that, in a garbage collected Python, tp_dealloc may be called from
+ any Python thread, not just the thread which created the object (if the object
+@@ -1145,13 +1145,13 @@
+ 
+    This function is used by :c:func:`PySequence_Concat` and has the same
+    signature.  It is also used by the ``+`` operator, after trying the numeric
+-   addition via the :attr:`tp_as_number.nb_add` slot.
++   addition via the :c:member:`~PyTypeObject.tp_as_number.nb_add` slot.
+ 
+ .. c:member:: ssizeargfunc PySequenceMethods.sq_repeat
+ 
+    This function is used by :c:func:`PySequence_Repeat` and has the same
+    signature.  It is also used by the ``*`` operator, after trying numeric
+-   multiplication via the :attr:`tp_as_number.nb_mul` slot.
++   multiplication via the :c:member:`~PyTypeObject.tp_as_number.nb_mul` slot.
+ 
+ .. c:member:: ssizeargfunc PySequenceMethods.sq_item
+ 
+diff -r d047928ae3f6 Doc/data/refcounts.dat
+--- a/Doc/data/refcounts.dat
++++ b/Doc/data/refcounts.dat
+@@ -210,7 +210,7 @@
+ 
+ PyDict_DelItemString:int:::
+ PyDict_DelItemString:PyObject*:p:0:
+-PyDict_DelItemString:char*:key::
++PyDict_DelItemString:const char*:key::
+ 
+ PyDict_GetItem:PyObject*::0:0
+ PyDict_GetItem:PyObject*:p:0:
+@@ -218,7 +218,7 @@
+ 
+ PyDict_GetItemString:PyObject*::0:
+ PyDict_GetItemString:PyObject*:p:0:
+-PyDict_GetItemString:char*:key::
++PyDict_GetItemString:const char*:key::
+ 
+ PyDict_Items:PyObject*::+1:
+ PyDict_Items:PyObject*:p:0:
+@@ -244,7 +244,7 @@
+ 
+ PyDict_SetItemString:int:::
+ PyDict_SetItemString:PyObject*:p:0:
+-PyDict_SetItemString:char*:key::
++PyDict_SetItemString:const char*:key::
+ PyDict_SetItemString:PyObject*:val:+1:
+ 
+ PyDict_Size:int:::
+@@ -277,13 +277,13 @@
+ PyErr_GivenExceptionMatches:PyObject*:exc:0:
+ 
+ PyErr_NewException:PyObject*::+1:
+-PyErr_NewException:char*:name::
++PyErr_NewException:const char*:name::
+ PyErr_NewException:PyObject*:base:0:
+ PyErr_NewException:PyObject*:dict:0:
+ 
+ PyErr_NewExceptionWithDoc:PyObject*::+1:
+-PyErr_NewExceptionWithDoc:char*:name::
+-PyErr_NewExceptionWithDoc:char*:doc::
++PyErr_NewExceptionWithDoc:const char*:name::
++PyErr_NewExceptionWithDoc:const char*:doc::
+ PyErr_NewExceptionWithDoc:PyObject*:base:0:
+ PyErr_NewExceptionWithDoc:PyObject*:dict:0:
+ 
+@@ -310,21 +310,21 @@
+ PyErr_SetExcFromWindowsErrWithFilename:PyObject*::null:
+ PyErr_SetExcFromWindowsErrWithFilename:PyObject*:type:0:
+ PyErr_SetExcFromWindowsErrWithFilename:int:ierr::
+-PyErr_SetExcFromWindowsErrWithFilename:char*:filename::
++PyErr_SetExcFromWindowsErrWithFilename:const char*:filename::
+ 
+ PyErr_SetFromErrno:PyObject*::null:
+ PyErr_SetFromErrno:PyObject*:type:0:
+ 
+ PyErr_SetFromErrnoWithFilename:PyObject*::null:
+ PyErr_SetFromErrnoWithFilename:PyObject*:type:0:
+-PyErr_SetFromErrnoWithFilename:char*:filename::
++PyErr_SetFromErrnoWithFilename:const char*:filename::
+ 
+ PyErr_SetFromWindowsErr:PyObject*::null:
+ PyErr_SetFromWindowsErr:int:ierr::
+ 
+ PyErr_SetFromWindowsErrWithFilename:PyObject*::null:
+ PyErr_SetFromWindowsErrWithFilename:int:ierr::
+-PyErr_SetFromWindowsErrWithFilename:char*:filename::
++PyErr_SetFromWindowsErrWithFilename:const char*:filename::
+ 
+ PyErr_SetInterrupt:void:::
+ 
+@@ -337,11 +337,11 @@
+ 
+ PyErr_SetString:void:::
+ PyErr_SetString:PyObject*:type:+1:
+-PyErr_SetString:char*:message::
++PyErr_SetString:const char*:message::
+ 
+ PyErr_Format:PyObject*::null:
+ PyErr_Format:PyObject*:exception:+1:
+-PyErr_Format:char*:format::
++PyErr_Format:const char*:format::
+ PyErr_Format::...::
+ 
+ PyErr_WarnEx:int:::
+@@ -386,22 +386,22 @@
+ 
+ PyFile_FromFile:PyObject*::+1:
+ PyFile_FromFile:FILE*:fp::
+-PyFile_FromFile:char*:name::
+-PyFile_FromFile:char*:mode::
++PyFile_FromFile:const char*:name::
++PyFile_FromFile:const char*:mode::
+ PyFile_FromFile:int(*:close)::
+ 
+ PyFile_FromFileEx:PyObject*::+1:
+ PyFile_FromFileEx:FILE*:fp::
+-PyFile_FromFileEx:char*:name::
+-PyFile_FromFileEx:char*:mode::
++PyFile_FromFileEx:const char*:name::
++PyFile_FromFileEx:const char*:mode::
+ PyFile_FromFileEx:int(*:close)::
+ PyFile_FromFileEx:int:buffering::
+-PyFile_FromFileEx:char*:encoding::
+-PyFile_FromFileEx:char*:newline::
++PyFile_FromFileEx:const char*:encoding::
++PyFile_FromFileEx:const char*:newline::
+ 
+ PyFile_FromString:PyObject*::+1:
+-PyFile_FromString:char*:name::
+-PyFile_FromString:char*:mode::
++PyFile_FromString:const char*:name::
++PyFile_FromString:const char*:mode::
+ 
+ PyFile_GetLine:PyObject*::+1:
+ PyFile_GetLine:PyObject*:p::
+@@ -482,23 +482,23 @@
+ PyGen_New:PyFrameObject*:frame:0:
+ 
+ Py_InitModule:PyObject*::0:
+-Py_InitModule:char*:name::
++Py_InitModule:const char*:name::
+ Py_InitModule:PyMethodDef[]:methods::
+ 
+ Py_InitModule3:PyObject*::0:
+-Py_InitModule3:char*:name::
++Py_InitModule3:const char*:name::
+ Py_InitModule3:PyMethodDef[]:methods::
+-Py_InitModule3:char*:doc::
++Py_InitModule3:const char*:doc::
+ 
+ Py_InitModule4:PyObject*::0:
+-Py_InitModule4:char*:name::
++Py_InitModule4:const char*:name::
+ Py_InitModule4:PyMethodDef[]:methods::
+-Py_InitModule4:char*:doc::
++Py_InitModule4:const char*:doc::
+ Py_InitModule4:PyObject*:self::
+ Py_InitModule4:int:apiver::usually provided by Py_InitModule or Py_InitModule3
+ 
+ PyImport_AddModule:PyObject*::0:reference borrowed from sys.modules
+-PyImport_AddModule:char*:name::
++PyImport_AddModule:const char*:name::
+ 
+ PyImport_Cleanup:void:::
+ 
+@@ -522,16 +522,16 @@
+ PyImport_ImportFrozenModule:char*:::
+ 
+ PyImport_ImportModule:PyObject*::+1:
+-PyImport_ImportModule:char*:name::
++PyImport_ImportModule:const char*:name::
+ 
+ PyImport_ImportModuleEx:PyObject*::+1:
+-PyImport_ImportModuleEx:char*:name::
++PyImport_ImportModuleEx:const char*:name::
+ PyImport_ImportModuleEx:PyObject*:globals:0:???
+ PyImport_ImportModuleEx:PyObject*:locals:0:???
+ PyImport_ImportModuleEx:PyObject*:fromlist:0:???
+ 
+ PyImport_ImportModuleLevel:PyObject*::+1:
+-PyImport_ImportModuleLevel:char*:name::
++PyImport_ImportModuleLevel:const char*:name::
+ PyImport_ImportModuleLevel:PyObject*:globals:0:???
+ PyImport_ImportModuleLevel:PyObject*:locals:0:???
+ PyImport_ImportModuleLevel:PyObject*:fromlist:0:???
+@@ -692,7 +692,7 @@
+ 
+ PyMapping_DelItemString:int:::
+ PyMapping_DelItemString:PyObject*:o:0:
+-PyMapping_DelItemString:char*:key::
++PyMapping_DelItemString:const char*:key::
+ 
+ PyMapping_GetItemString:PyObject*::+1:
+ PyMapping_GetItemString:PyObject*:o:0:
+@@ -762,10 +762,10 @@
+ PyModule_GetDict:PyObject*::0:
+ PyModule_GetDict::PyObject* module:0:
+ 
+-PyModule_GetFilename:char*:::
++PyModule_GetFilename:const char*:::
+ PyModule_GetFilename:PyObject*:module:0:
+ 
+-PyModule_GetName:char*:::
++PyModule_GetName:const char*:::
+ PyModule_GetName:PyObject*:module:0:
+ 
+ PyModule_New:PyObject*::+1:
+@@ -927,7 +927,7 @@
+ 
+ PyObject_CallMethodObjArgs:PyObject*::+1:
+ PyObject_CallMethodObjArgs:PyObject*:o:0:
+-PyObject_CallMethodObjArgs:char*:name::
++PyObject_CallMethodObjArgs:PyObject*:name:0:
+ PyObject_CallMethodObjArgs::...::
+ 
+ PyObject_CallObject:PyObject*::+1:
+@@ -949,7 +949,7 @@
+ 
+ PyObject_DelAttrString:int:::
+ PyObject_DelAttrString:PyObject*:o:0:
+-PyObject_DelAttrString:char*:attr_name::
++PyObject_DelAttrString:const char*:attr_name::
+ 
+ PyObject_DelItem:int:::
+ PyObject_DelItem:PyObject*:o:0:
+@@ -964,7 +964,7 @@
+ 
+ PyObject_GetAttrString:PyObject*::+1:
+ PyObject_GetAttrString:PyObject*:o:0:
+-PyObject_GetAttrString:char*:attr_name::
++PyObject_GetAttrString:const char*:attr_name::
+ 
+ PyObject_GetItem:PyObject*::+1:
+ PyObject_GetItem:PyObject*:o:0:
+@@ -979,7 +979,7 @@
+ 
+ PyObject_HasAttrString:int:::
+ PyObject_HasAttrString:PyObject*:o:0:
+-PyObject_HasAttrString:char*:attr_name:0:
++PyObject_HasAttrString:const char*:attr_name:0:
+ 
+ PyObject_Hash:int:::
+ PyObject_Hash:PyObject*:o:0:
+@@ -1029,7 +1029,7 @@
+ 
+ PyObject_SetAttrString:int:::
+ PyObject_SetAttrString:PyObject*:o:0:
+-PyObject_SetAttrString:char*:attr_name::
++PyObject_SetAttrString:const char*:attr_name::
+ PyObject_SetAttrString:PyObject*:v:+1:
+ 
+ PyObject_SetItem:int:::
+@@ -1048,27 +1048,27 @@
+ 
+ PyParser_SimpleParseFile:struct _node*:::
+ PyParser_SimpleParseFile:FILE*:fp::
+-PyParser_SimpleParseFile:char*:filename::
++PyParser_SimpleParseFile:const char*:filename::
+ PyParser_SimpleParseFile:int:start::
+ 
+ PyParser_SimpleParseString:struct _node*:::
+-PyParser_SimpleParseString:char*:str::
++PyParser_SimpleParseString:const char*:str::
+ PyParser_SimpleParseString:int:start::
+ 
+ PyRun_AnyFile:int:::
+ PyRun_AnyFile:FILE*:fp::
+-PyRun_AnyFile:char*:filename::
++PyRun_AnyFile:const char*:filename::
+ 
+ PyRun_File:PyObject*::+1:??? -- same as eval_code2()
+ PyRun_File:FILE*:fp::
+-PyRun_File:char*:filename::
++PyRun_File:const char*:filename::
+ PyRun_File:int:start::
+ PyRun_File:PyObject*:globals:0:
+ PyRun_File:PyObject*:locals:0:
+ 
+ PyRun_FileEx:PyObject*::+1:??? -- same as eval_code2()
+ PyRun_FileEx:FILE*:fp::
+-PyRun_FileEx:char*:filename::
++PyRun_FileEx:const char*:filename::
+ PyRun_FileEx:int:start::
+ PyRun_FileEx:PyObject*:globals:0:
+ PyRun_FileEx:PyObject*:locals:0:
+@@ -1076,7 +1076,7 @@
+ 
+ PyRun_FileFlags:PyObject*::+1:??? -- same as eval_code2()
+ PyRun_FileFlags:FILE*:fp::
+-PyRun_FileFlags:char*:filename::
++PyRun_FileFlags:const char*:filename::
+ PyRun_FileFlags:int:start::
+ PyRun_FileFlags:PyObject*:globals:0:
+ PyRun_FileFlags:PyObject*:locals:0:
+@@ -1084,7 +1084,7 @@
+ 
+ PyRun_FileExFlags:PyObject*::+1:??? -- same as eval_code2()
+ PyRun_FileExFlags:FILE*:fp::
+-PyRun_FileExFlags:char*:filename::
++PyRun_FileExFlags:const char*:filename::
+ PyRun_FileExFlags:int:start::
+ PyRun_FileExFlags:PyObject*:globals:0:
+ PyRun_FileExFlags:PyObject*:locals:0:
+@@ -1093,27 +1093,27 @@
+ 
+ PyRun_InteractiveLoop:int:::
+ PyRun_InteractiveLoop:FILE*:fp::
+-PyRun_InteractiveLoop:char*:filename::
++PyRun_InteractiveLoop:const char*:filename::
+ 
+ PyRun_InteractiveOne:int:::
+ PyRun_InteractiveOne:FILE*:fp::
+-PyRun_InteractiveOne:char*:filename::
++PyRun_InteractiveOne:const char*:filename::
+ 
+ PyRun_SimpleFile:int:::
+ PyRun_SimpleFile:FILE*:fp::
+-PyRun_SimpleFile:char*:filename::
++PyRun_SimpleFile:const char*:filename::
+ 
+ PyRun_SimpleString:int:::
+-PyRun_SimpleString:char*:command::
++PyRun_SimpleString:const char*:command::
+ 
+ PyRun_String:PyObject*::+1:??? -- same as eval_code2()
+-PyRun_String:char*:str::
++PyRun_String:const char*:str::
+ PyRun_String:int:start::
+ PyRun_String:PyObject*:globals:0:
+ PyRun_String:PyObject*:locals:0:
+ 
+ PyRun_StringFlags:PyObject*::+1:??? -- same as eval_code2()
+-PyRun_StringFlags:char*:str::
++PyRun_StringFlags:const char*:str::
+ PyRun_StringFlags:int:start::
+ PyRun_StringFlags:PyObject*:globals:0:
+ PyRun_StringFlags:PyObject*:locals:0:
+@@ -1229,7 +1229,7 @@
+ PySlice_New:PyObject*:stop:0:
+ PySlice_New:PyObject*:step:0:
+ 
+-PyString_AS_STRING:char*:::
++PyString_AS_STRING:const char*:::
+ PyString_AS_STRING:PyObject*:string:0:
+ 
+ PyString_AsDecodedObject:PyObject*::+1:
+@@ -1242,7 +1242,7 @@
+ PyString_AsEncodedObject:const char*:encoding::
+ PyString_AsEncodedObject:const char*:errors::
+ 
+-PyString_AsString:char*:::
++PyString_AsString:const char*:::
+ PyString_AsString:PyObject*:string:0:
+ 
+ PyString_AsStringAndSize:int:::
+@@ -1310,13 +1310,13 @@
+ PyString_AsEncodedString:const char*:errors::
+ 
+ PySys_AddWarnOption:void:::
+-PySys_AddWarnOption:char*:s::
++PySys_AddWarnOption:const char*:s::
+ 
+ PySys_AddXOption:void:::
+ PySys_AddXOption:const wchar_t*:s::
+ 
+ PySys_GetObject:PyObject*::0:
+-PySys_GetObject:char*:name::
++PySys_GetObject:const char*:name::
+ 
+ PySys_GetXOptions:PyObject*::0:
+ 
+@@ -1325,16 +1325,16 @@
+ PySys_SetArgv:char**:argv::
+ 
+ PySys_SetObject:int:::
+-PySys_SetObject:char*:name::
++PySys_SetObject:const char*:name::
+ PySys_SetObject:PyObject*:v:+1:
+ 
+ PySys_ResetWarnOptions:void:::
+ 
+ PySys_WriteStdout:void:::
+-PySys_WriteStdout:char*:format::
++PySys_WriteStdout:const char*:format::
+ 
+ PySys_WriteStderr:void:::
+-PySys_WriteStderr:char*:format::
++PySys_WriteStderr:const char*:format::
+ 
+ PyThreadState_Clear:void:::
+ PyThreadState_Clear:PyThreadState*:tstate::
+@@ -1714,16 +1714,16 @@
+ Py_AtExit:void (*)():func::
+ 
+ Py_BuildValue:PyObject*::+1:
+-Py_BuildValue:char*:format::
++Py_BuildValue:const char*:format::
+ 
+ Py_CompileString:PyObject*::+1:
+-Py_CompileString:char*:str::
+-Py_CompileString:char*:filename::
++Py_CompileString:const char*:str::
++Py_CompileString:const char*:filename::
+ Py_CompileString:int:start::
+ 
+ Py_CompileStringFlags:PyObject*::+1:
+-Py_CompileStringFlags:char*:str::
+-Py_CompileStringFlags:char*:filename::
++Py_CompileStringFlags:const char*:str::
++Py_CompileStringFlags:const char*:filename::
+ Py_CompileStringFlags:int:start::
+ Py_CompileStringFlags:PyCompilerFlags*:flags::
+ 
+@@ -1737,33 +1737,33 @@
+ Py_Exit:int:status::
+ 
+ Py_FatalError:void:::
+-Py_FatalError:char*:message::
++Py_FatalError:const char*:message::
+ 
+ Py_FdIsInteractive:int:::
+ Py_FdIsInteractive:FILE*:fp::
+-Py_FdIsInteractive:char*:filename::
++Py_FdIsInteractive:const char*:filename::
+ 
+ Py_Finalize:void:::
+ 
+-Py_GetBuildInfoconst:char*:::
++Py_GetBuildInfoconst:const char*:::
+ 
+-Py_GetCompilerconst:char*:::
++Py_GetCompilerconst:const char*:::
+ 
+-Py_GetCopyrightconst:char*:::
++Py_GetCopyrightconst:const char*:::
+ 
+-Py_GetExecPrefix:char*:::
++Py_GetExecPrefix:const char*:::
+ 
+-Py_GetPath:char*:::
++Py_GetPath:const char*:::
+ 
+-Py_GetPlatformconst:char*:::
++Py_GetPlatformconst:const char*:::
+ 
+-Py_GetPrefix:char*:::
++Py_GetPrefix:const char*:::
+ 
+-Py_GetProgramFullPath:char*:::
++Py_GetProgramFullPath:const char*:::
+ 
+-Py_GetProgramName:char*:::
++Py_GetProgramName:const char*:::
+ 
+-Py_GetVersionconst:char*:::
++Py_GetVersionconst:const char*:::
+ 
+ Py_INCREF:void:::
+ Py_INCREF:PyObject*:o:+1:
+@@ -1775,7 +1775,7 @@
+ Py_NewInterpreter:PyThreadState*:::
+ 
+ Py_SetProgramName:void:::
+-Py_SetProgramName:char*:name::
++Py_SetProgramName:const char*:name::
+ 
+ Py_XDECREF:void:::
+ Py_XDECREF:PyObject*:o:-1:if o is not NULL
+@@ -1784,14 +1784,14 @@
+ Py_XINCREF:PyObject*:o:+1:if o is not NULL
+ 
+ _PyImport_FindExtension:PyObject*::0:??? see PyImport_AddModule
+-_PyImport_FindExtension:char*:::
+-_PyImport_FindExtension:char*:::
++_PyImport_FindExtension:const char*:::
++_PyImport_FindExtension:const char*:::
+ 
+ _PyImport_Fini:void:::
+ 
+ _PyImport_FixupExtension:PyObject*:::???
+-_PyImport_FixupExtension:char*:::
+-_PyImport_FixupExtension:char*:::
++_PyImport_FixupExtension:const char*:::
++_PyImport_FixupExtension:const char*:::
+ 
+ _PyImport_Init:void:::
+ 
 diff -r d047928ae3f6 Doc/extending/embedding.rst
 --- a/Doc/extending/embedding.rst
 +++ b/Doc/extending/embedding.rst
@@ -24,10 +1274,456 @@
  
  .. note::
     To avoid confusion between several Python installations (and especially
+@@ -307,11 +307,13 @@
+ to find its location) and compilation
+ options.  In this case, the :mod:`sysconfig` module is a useful tool to
+ programmatically extract the configuration values that you will want to
+-combine together:
++combine together.  For example:
+ 
+ .. code-block:: python
+ 
+    >>> import sysconfig
++   >>> sysconfig.get_config_var('LIBS')
++   '-lpthread -ldl  -lutil'
+    >>> sysconfig.get_config_var('LINKFORSHARED')
+    '-Xlinker -export-dynamic'
+ 
+diff -r d047928ae3f6 Doc/extending/newtypes.rst
+--- a/Doc/extending/newtypes.rst
++++ b/Doc/extending/newtypes.rst
+@@ -135,11 +135,11 @@
+ .. note::
+ 
+    If you want your type to be subclassable from Python, and your type has the same
+-   :attr:`tp_basicsize` as its base type, you may have problems with multiple
++   :c:member:`~PyTypeObject.tp_basicsize` as its base type, you may have problems with multiple
+    inheritance.  A Python subclass of your type will have to list your type first
+    in its :attr:`__bases__`, or else it will not be able to call your type's
+    :meth:`__new__` method without getting an error.  You can avoid this problem by
+-   ensuring that your type has a larger value for :attr:`tp_basicsize` than its
++   ensuring that your type has a larger value for :c:member:`~PyTypeObject.tp_basicsize` than its
+    base type does.  Most of the time, this will be true anyway, because either your
+    base type will be :class:`object`, or else you will be adding data members to
+    your base type, and therefore increasing its size.
+@@ -159,7 +159,7 @@
+ All types should include this constant in their flags.  It enables all of the
+ members defined by the current version of Python.
+ 
+-We provide a doc string for the type in :attr:`tp_doc`. ::
++We provide a doc string for the type in :c:member:`~PyTypeObject.tp_doc`. ::
+ 
+    "Noddy objects",           /* tp_doc */
+ 
+@@ -168,12 +168,12 @@
+ the module.  We'll expand this example later to have more interesting behavior.
+ 
+ For now, all we want to be able to do is to create new :class:`Noddy` objects.
+-To enable object creation, we have to provide a :attr:`tp_new` implementation.
++To enable object creation, we have to provide a :c:member:`~PyTypeObject.tp_new` implementation.
+ In this case, we can just use the default implementation provided by the API
+ function :c:func:`PyType_GenericNew`.  We'd like to just assign this to the
+-:attr:`tp_new` slot, but we can't, for portability sake, On some platforms or
++:c:member:`~PyTypeObject.tp_new` slot, but we can't, for portability sake, On some platforms or
+ compilers, we can't statically initialize a structure member with a function
+-defined in another C module, so, instead, we'll assign the :attr:`tp_new` slot
++defined in another C module, so, instead, we'll assign the :c:member:`~PyTypeObject.tp_new` slot
+ in the module initialization function just before calling
+ :c:func:`PyType_Ready`::
+ 
+@@ -268,13 +268,13 @@
+        Py_TYPE(self)->tp_free((PyObject*)self);
+    }
+ 
+-which is assigned to the :attr:`tp_dealloc` member::
++which is assigned to the :c:member:`~PyTypeObject.tp_dealloc` member::
+ 
+    (destructor)Noddy_dealloc, /*tp_dealloc*/
+ 
+ This method decrements the reference counts of the two Python attributes. We use
+ :c:func:`Py_XDECREF` here because the :attr:`first` and :attr:`last` members
+-could be *NULL*.  It then calls the :attr:`tp_free` member of the object's type
++could be *NULL*.  It then calls the :c:member:`~PyTypeObject.tp_free` member of the object's type
+ to free the object's memory.  Note that the object's type might not be
+ :class:`NoddyType`, because the object may be an instance of a subclass.
+ 
+@@ -306,7 +306,7 @@
+        return (PyObject *)self;
+    }
+ 
+-and install it in the :attr:`tp_new` member::
++and install it in the :c:member:`~PyTypeObject.tp_new` member::
+ 
+    Noddy_new,                 /* tp_new */
+ 
+@@ -326,17 +326,17 @@
+ created. New methods always accept positional and keyword arguments, but they
+ often ignore the arguments, leaving the argument handling to initializer
+ methods. Note that if the type supports subclassing, the type passed may not be
+-the type being defined.  The new method calls the :attr:`tp_alloc` slot to
+-allocate memory. We don't fill the :attr:`tp_alloc` slot ourselves. Rather
++the type being defined.  The new method calls the :c:member:`~PyTypeObject.tp_alloc` slot to
++allocate memory. We don't fill the :c:member:`~PyTypeObject.tp_alloc` slot ourselves. Rather
+ :c:func:`PyType_Ready` fills it for us by inheriting it from our base class,
+ which is :class:`object` by default.  Most types use the default allocation.
+ 
+ .. note::
+ 
+-   If you are creating a co-operative :attr:`tp_new` (one that calls a base type's
+-   :attr:`tp_new` or :meth:`__new__`), you must *not* try to determine what method
++   If you are creating a co-operative :c:member:`~PyTypeObject.tp_new` (one that calls a base type's
++   :c:member:`~PyTypeObject.tp_new` or :meth:`__new__`), you must *not* try to determine what method
+    to call using method resolution order at runtime.  Always statically determine
+-   what type you are going to call, and call its :attr:`tp_new` directly, or via
++   what type you are going to call, and call its :c:member:`~PyTypeObject.tp_new` directly, or via
+    ``type->tp_base->tp_new``.  If you do not do this, Python subclasses of your
+    type that also inherit from other Python-defined classes may not work correctly.
+    (Specifically, you may not be able to create instances of such subclasses
+@@ -373,11 +373,11 @@
+        return 0;
+    }
+ 
+-by filling the :attr:`tp_init` slot. ::
++by filling the :c:member:`~PyTypeObject.tp_init` slot. ::
+ 
+    (initproc)Noddy_init,         /* tp_init */
+ 
+-The :attr:`tp_init` slot is exposed in Python as the :meth:`__init__` method. It
++The :c:member:`~PyTypeObject.tp_init` slot is exposed in Python as the :meth:`__init__` method. It
+ is used to initialize an object after it's created. Unlike the new method, we
+ can't guarantee that the initializer is called.  The initializer isn't called
+ when unpickling objects and it can be overridden.  Our initializer accepts
+@@ -407,7 +407,7 @@
+ * when we know that deallocation of the object [#]_ will not cause any calls
+   back into our type's code
+ 
+-* when decrementing a reference count in a :attr:`tp_dealloc` handler when
++* when decrementing a reference count in a :c:member:`~PyTypeObject.tp_dealloc` handler when
+   garbage-collections is not supported [#]_
+ 
+ We want to expose our instance variables as attributes. There are a
+@@ -423,7 +423,7 @@
+        {NULL}  /* Sentinel */
+    };
+ 
+-and put the definitions in the :attr:`tp_members` slot::
++and put the definitions in the :c:member:`~PyTypeObject.tp_members` slot::
+ 
+    Noddy_members,             /* tp_members */
+ 
+@@ -483,7 +483,7 @@
+        {NULL}  /* Sentinel */
+    };
+ 
+-and assign them to the :attr:`tp_methods` slot::
++and assign them to the :c:member:`~PyTypeObject.tp_methods` slot::
+ 
+    Noddy_methods,             /* tp_methods */
+ 
+@@ -578,7 +578,7 @@
+        {NULL}  /* Sentinel */
+    };
+ 
+-and register it in the :attr:`tp_getset` slot::
++and register it in the :c:member:`~PyTypeObject.tp_getset` slot::
+ 
+    Noddy_getseters,           /* tp_getset */
+ 
+@@ -595,7 +595,7 @@
+        {NULL}  /* Sentinel */
+    };
+ 
+-We also need to update the :attr:`tp_init` handler to only allow strings [#]_ to
++We also need to update the :c:member:`~PyTypeObject.tp_init` handler to only allow strings [#]_ to
+ be passed::
+ 
+    static int
+@@ -713,7 +713,7 @@
+ 
+ .. note::
+ 
+-   Note that the :attr:`tp_traverse` implementation must name its arguments exactly
++   Note that the :c:member:`~PyTypeObject.tp_traverse` implementation must name its arguments exactly
+    *visit* and *arg* in order to use :c:func:`Py_VISIT`.  This is to encourage
+    uniformity across these boring implementations.
+ 
+@@ -750,7 +750,7 @@
+ reference count drops to zero, we might cause code to run that calls back into
+ the object.  In addition, because we now support garbage collection, we also
+ have to worry about code being run that triggers garbage collection.  If garbage
+-collection is run, our :attr:`tp_traverse` handler could get called. We can't
++collection is run, our :c:member:`~PyTypeObject.tp_traverse` handler could get called. We can't
+ take a chance of having :c:func:`Noddy_traverse` called when a member's reference
+ count has dropped to zero and its value hasn't been set to *NULL*.
+ 
+@@ -770,8 +770,8 @@
+ 
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, /* tp_flags */
+ 
+-That's pretty much it.  If we had written custom :attr:`tp_alloc` or
+-:attr:`tp_free` slots, we'd need to modify them for cyclic-garbage collection.
++That's pretty much it.  If we had written custom :c:member:`~PyTypeObject.tp_alloc` or
++:c:member:`~PyTypeObject.tp_free` slots, we'd need to modify them for cyclic-garbage collection.
+ Most extensions will use the versions automatically provided.
+ 
+ 
+@@ -830,8 +830,8 @@
+ 
+ This pattern is important when writing a type with custom :attr:`new` and
+ :attr:`dealloc` methods. The :attr:`new` method should not actually create the
+-memory for the object with :attr:`tp_alloc`, that will be handled by the base
+-class when calling its :attr:`tp_new`.
++memory for the object with :c:member:`~PyTypeObject.tp_alloc`, that will be handled by the base
++class when calling its :c:member:`~PyTypeObject.tp_new`.
+ 
+ When filling out the :c:func:`PyTypeObject` for the :class:`Shoddy` type, you see
+ a slot for :c:func:`tp_base`. Due to cross platform compiler issues, you can't
+@@ -857,8 +857,8 @@
+    }
+ 
+ Before calling :c:func:`PyType_Ready`, the type structure must have the
+-:attr:`tp_base` slot filled in. When we are deriving a new type, it is not
+-necessary to fill out the :attr:`tp_alloc` slot with :c:func:`PyType_GenericNew`
++:c:member:`~PyTypeObject.tp_base` slot filled in. When we are deriving a new type, it is not
++necessary to fill out the :c:member:`~PyTypeObject.tp_alloc` slot with :c:func:`PyType_GenericNew`
+ -- the allocate function from the base type will be inherited.
+ 
+ After that, calling :c:func:`PyType_Ready` and adding the type object to the
+@@ -901,7 +901,7 @@
+ 
+ These fields tell the runtime how much memory to allocate when new objects of
+ this type are created.  Python has some built-in support for variable length
+-structures (think: strings, lists) which is where the :attr:`tp_itemsize` field
++structures (think: strings, lists) which is where the :c:member:`~PyTypeObject.tp_itemsize` field
+ comes in.  This will be dealt with later. ::
+ 
+    char *tp_doc;
+@@ -962,10 +962,9 @@
+ 
+        if (self->my_callback != NULL) {
+            PyObject *err_type, *err_value, *err_traceback;
+-           int have_error = PyErr_Occurred() ? 1 : 0;
+ 
+-           if (have_error)
+-               PyErr_Fetch(&err_type, &err_value, &err_traceback);
++           /* This saves the current exception state */
++           PyErr_Fetch(&err_type, &err_value, &err_traceback);
+ 
+            cbresult = PyObject_CallObject(self->my_callback, NULL);
+            if (cbresult == NULL)
+@@ -973,8 +972,8 @@
+            else
+                Py_DECREF(cbresult);
+ 
+-           if (have_error)
+-               PyErr_Restore(err_type, err_value, err_traceback);
++           /* This restores the saved exception state */
++           PyErr_Restore(err_type, err_value, err_traceback);
+ 
+            Py_DECREF(self->my_callback);
+        }
+@@ -998,7 +997,7 @@
+    reprfunc tp_repr;
+    reprfunc tp_str;
+ 
+-The :attr:`tp_repr` handler should return a string object containing a
++The :c:member:`~PyTypeObject.tp_repr` handler should return a string object containing a
+ representation of the instance for which it is called.  Here is a simple
+ example::
+ 
+@@ -1009,15 +1008,15 @@
+                                    obj->obj_UnderlyingDatatypePtr->size);
+    }
+ 
+-If no :attr:`tp_repr` handler is specified, the interpreter will supply a
+-representation that uses the type's :attr:`tp_name` and a uniquely-identifying
++If no :c:member:`~PyTypeObject.tp_repr` handler is specified, the interpreter will supply a
++representation that uses the type's :c:member:`~PyTypeObject.tp_name` and a uniquely-identifying
+ value for the object.
+ 
+-The :attr:`tp_str` handler is to :func:`str` what the :attr:`tp_repr` handler
++The :c:member:`~PyTypeObject.tp_str` handler is to :func:`str` what the :c:member:`~PyTypeObject.tp_repr` handler
+ described above is to :func:`repr`; that is, it is called when Python code calls
+ :func:`str` on an instance of your object.  Its implementation is very similar
+-to the :attr:`tp_repr` function, but the resulting string is intended for human
+-consumption.  If :attr:`tp_str` is not specified, the :attr:`tp_repr` handler is
++to the :c:member:`~PyTypeObject.tp_repr` function, but the resulting string is intended for human
++consumption.  If :c:member:`~PyTypeObject.tp_str` is not specified, the :c:member:`~PyTypeObject.tp_repr` handler is
+ used instead.
+ 
+ Here is a simple example::
+@@ -1082,7 +1081,7 @@
+ type object.  Each descriptor controls access to one attribute of the instance
+ object.  Each of the tables is optional; if all three are *NULL*, instances of
+ the type will only have attributes that are inherited from their base type, and
+-should leave the :attr:`tp_getattro` and :attr:`tp_setattro` fields *NULL* as
++should leave the :c:member:`~PyTypeObject.tp_getattro` and :c:member:`~PyTypeObject.tp_setattro` fields *NULL* as
+ well, allowing the base type to handle attributes.
+ 
+ The tables are declared as three fields of the type object::
+@@ -1091,7 +1090,7 @@
+    struct PyMemberDef *tp_members;
+    struct PyGetSetDef *tp_getset;
+ 
+-If :attr:`tp_methods` is not *NULL*, it must refer to an array of
++If :c:member:`~PyTypeObject.tp_methods` is not *NULL*, it must refer to an array of
+ :c:type:`PyMethodDef` structures.  Each entry in the table is an instance of this
+ structure::
+ 
+@@ -1147,13 +1146,13 @@
+    single: WRITE_RESTRICTED
+    single: RESTRICTED
+ 
+-An interesting advantage of using the :attr:`tp_members` table to build
++An interesting advantage of using the :c:member:`~PyTypeObject.tp_members` table to build
+ descriptors that are used at runtime is that any attribute defined this way can
+ have an associated doc string simply by providing the text in the table.  An
+ application can use the introspection API to retrieve the descriptor from the
+ class object, and get the doc string using its :attr:`__doc__` attribute.
+ 
+-As with the :attr:`tp_methods` table, a sentinel entry with a :attr:`name` value
++As with the :c:member:`~PyTypeObject.tp_methods` table, a sentinel entry with a :attr:`name` value
+ of *NULL* is required.
+ 
+ .. XXX Descriptors need to be explained in more detail somewhere, but not here.
+@@ -1177,7 +1176,7 @@
+ called, so that if you do need to extend their functionality, you'll understand
+ what needs to be done.
+ 
+-The :attr:`tp_getattr` handler is called when the object requires an attribute
++The :c:member:`~PyTypeObject.tp_getattr` handler is called when the object requires an attribute
+ look-up.  It is called in the same situations where the :meth:`__getattr__`
+ method of a class would be called.
+ 
+@@ -1197,11 +1196,11 @@
+        return NULL;
+    }
+ 
+-The :attr:`tp_setattr` handler is called when the :meth:`__setattr__` or
++The :c:member:`~PyTypeObject.tp_setattr` handler is called when the :meth:`__setattr__` or
+ :meth:`__delattr__` method of a class instance would be called.  When an
+ attribute should be deleted, the third parameter will be *NULL*.  Here is an
+ example that simply raises an exception; if this were really all you wanted, the
+-:attr:`tp_setattr` handler should be set to *NULL*. ::
++:c:member:`~PyTypeObject.tp_setattr` handler should be set to *NULL*. ::
+ 
+    static int
+    newdatatype_setattr(newdatatypeobject *obj, char *name, PyObject *v)
+@@ -1217,7 +1216,7 @@
+ 
+    richcmpfunc tp_richcompare;
+ 
+-The :attr:`tp_richcompare` handler is called when comparisons are needed.  It is
++The :c:member:`~PyTypeObject.tp_richcompare` handler is called when comparisons are needed.  It is
+ analogous to the :ref:`rich comparison methods <richcmpfuncs>`, like
+ :meth:`__lt__`, and also called by :c:func:`PyObject_RichCompare` and
+ :c:func:`PyObject_RichCompareBool`.
+@@ -1308,7 +1307,7 @@
+ 
+ This function is called when an instance of your data type is "called", for
+ example, if ``obj1`` is an instance of your data type and the Python script
+-contains ``obj1('hello')``, the :attr:`tp_call` handler is invoked.
++contains ``obj1('hello')``, the :c:member:`~PyTypeObject.tp_call` handler is invoked.
+ 
+ This function takes three arguments:
+ 
+@@ -1395,7 +1394,7 @@
+ For an object to be weakly referencable, the extension must include a
+ :c:type:`PyObject\*` field in the instance structure for the use of the weak
+ reference mechanism; it must be initialized to *NULL* by the object's
+-constructor.  It must also set the :attr:`tp_weaklistoffset` field of the
++constructor.  It must also set the :c:member:`~PyTypeObject.tp_weaklistoffset` field of the
+ corresponding type object to the offset of the field. For example, the instance
+ type is defined with the following structure::
+ 
+@@ -1481,7 +1480,7 @@
+ .. [#] This is true when we know that the object is a basic type, like a string or a
+    float.
+ 
+-.. [#] We relied on this in the :attr:`tp_dealloc` handler in this example, because our
++.. [#] We relied on this in the :c:member:`~PyTypeObject.tp_dealloc` handler in this example, because our
+    type doesn't support garbage collection. Even if a type supports garbage
+    collection, there are calls that can be made to "untrack" the object from
+    garbage collection, however, these calls are advanced and not covered here.
 diff -r d047928ae3f6 Doc/faq/programming.rst
 --- a/Doc/faq/programming.rst
 +++ b/Doc/faq/programming.rst
-@@ -1103,6 +1103,92 @@
+@@ -214,9 +214,9 @@
+ Assume you use a for loop to define a few different lambdas (or even plain
+ functions), e.g.::
+ 
+-   squares = []
+-   for x in range(5):
+-      squares.append(lambda: x**2)
++   >>> squares = []
++   >>> for x in range(5):
++   ...    squares.append(lambda: x**2)
+ 
+ This gives you a list that contains 5 lambdas that calculate ``x**2``.  You
+ might expect that, when called, they would return, respectively, ``0``, ``1``,
+@@ -241,9 +241,9 @@
+ In order to avoid this, you need to save the values in variables local to the
+ lambdas, so that they don't rely on the value of the global ``x``::
+ 
+-   squares = []
+-   for x in range(5):
+-      squares.append(lambda n=x: n**2)
++   >>> squares = []
++   >>> for x in range(5):
++   ...    squares.append(lambda n=x: n**2)
+ 
+ Here, ``n=x`` creates a new variable ``n`` local to the lambda and computed
+ when the lambda is defined so that it has the same value that ``x`` had at
+@@ -592,11 +592,11 @@
+ Since the comma is not an operator, but a separator between expressions the
+ above is evaluated as if you had entered::
+ 
+-    >>> ("a" in "b"), "a"
++    ("a" in "b"), "a"
+ 
+ not::
+ 
+-    >>> "a" in ("b", "a")
++    "a" in ("b", "a")
+ 
+ The same is true of the various assignment operators (``=``, ``+=`` etc).  They
+ are not truly operators but syntactic delimiters in assignment statements.
+@@ -744,6 +744,7 @@
+ unicode data, try using a :class:`io.StringIO` object or the :mod:`array`
+ module::
+ 
++   >>> import io
+    >>> s = "Hello, world"
+    >>> sio = io.StringIO(s)
+    >>> sio.getvalue()
+@@ -761,7 +762,7 @@
+    array('u', 'Hello, world')
+    >>> a[0] = 'y'
+    >>> print(a)
+-   array('u', 'yello world')
++   array('u', 'yello, world')
+    >>> a.tounicode()
+    'yello, world'
+ 
+@@ -1060,7 +1061,7 @@
+ 
+ You probably tried to make a multidimensional array like this::
+ 
+-   A = [[None] * 2] * 3
++   >>> A = [[None] * 2] * 3
+ 
+ This looks correct if you print it::
+ 
+@@ -1092,7 +1093,7 @@
+    A = [[None] * w for i in range(h)]
+ 
+ Or, you can use an extension that provides a matrix datatype; `Numeric Python
+-<http://numpy.scipy.org/>`_ is the best known.
++<http://www.numpy.org/>`_ is the best known.
+ 
+ 
+ How do I apply a method to a sequence of objects?
+@@ -1103,6 +1104,92 @@
     result = [obj.method() for obj in mylist]
  
  
@@ -120,10 +1816,586 @@
  Dictionaries
  ============
  
+@@ -1529,13 +1616,13 @@
+ (permissions, free space, etc...) to write the compiled module back to the
+ directory.
+ 
+-Running Python on a top level script is not considered an import and no ``.pyc``
+-will be created.  For example, if you have a top-level module ``abc.py`` that
+-imports another module ``xyz.py``, when you run abc, ``xyz.pyc`` will be created
+-since xyz is imported, but no ``abc.pyc`` file will be created since ``abc.py``
+-isn't being imported.
++Running Python on a top level script is not considered an import and no
++``.pyc`` will be created.  For example, if you have a top-level module
++``foo.py`` that imports another module ``xyz.py``, when you run ``foo``,
++``xyz.pyc`` will be created since ``xyz`` is imported, but no ``foo.pyc`` file
++will be created since ``foo.py`` isn't being imported.
+ 
+-If you need to create abc.pyc -- that is, to create a .pyc file for a module
++If you need to create ``foo.pyc`` -- that is, to create a ``.pyc`` file for a module
+ that is not imported -- you can, using the :mod:`py_compile` and
+ :mod:`compileall` modules.
+ 
+@@ -1543,9 +1630,9 @@
+ the ``compile()`` function in that module interactively::
+ 
+    >>> import py_compile
+-   >>> py_compile.compile('abc.py')
++   >>> py_compile.compile('foo.py')                 # doctest: +SKIP
+ 
+-This will write the ``.pyc`` to the same location as ``abc.py`` (or you can
++This will write the ``.pyc`` to the same location as ``foo.py`` (or you can
+ override that with the optional parameter ``cfile``).
+ 
+ You can also automatically compile all files in a directory or directories using
+diff -r d047928ae3f6 Doc/howto/argparse.rst
+--- a/Doc/howto/argparse.rst
++++ b/Doc/howto/argparse.rst
+@@ -468,7 +468,7 @@
+        print(answer)
+ 
+ We have introduced another action, "count",
+-to count the number of occurences of a specific optional arguments:
++to count the number of occurrences of a specific optional arguments:
+ 
+ .. code-block:: sh
+ 
+diff -r d047928ae3f6 Doc/howto/logging-cookbook.rst
+--- a/Doc/howto/logging-cookbook.rst
++++ b/Doc/howto/logging-cookbook.rst
+@@ -524,69 +524,31 @@
+ the keys of the dict-like object. If you need a different method, e.g. if you
+ want to prepend or append the contextual information to the message string,
+ you just need to subclass :class:`LoggerAdapter` and override :meth:`process`
+-to do what you need. Here's an example script which uses this class, which
+-also illustrates what dict-like behaviour is needed from an arbitrary
+-'dict-like' object for use in the constructor::
++to do what you need. Here is a simple example::
+ 
+-   import logging
++    class CustomAdapter(logging.LoggerAdapter):
++        """
++        This example adapter expects the passed in dict-like object to have a
++        'connid' key, whose value in brackets is prepended to the log message.
++        """
++        def process(self, msg, kwargs):
++            return '[%s] %s' % (self.extra['connid'], msg), kwargs
+ 
+-   class ConnInfo:
+-       """
+-       An example class which shows how an arbitrary class can be used as
+-       the 'extra' context information repository passed to a LoggerAdapter.
+-       """
++which you can use like this::
+ 
+-       def __getitem__(self, name):
+-           """
+-           To allow this instance to look like a dict.
+-           """
+-           from random import choice
+-           if name == 'ip':
+-               result = choice(['127.0.0.1', '192.168.0.1'])
+-           elif name == 'user':
+-               result = choice(['jim', 'fred', 'sheila'])
+-           else:
+-               result = self.__dict__.get(name, '?')
+-           return result
++    logger = logging.getLogger(__name__)
++    adapter = CustomAdapter(logger, {'connid': some_conn_id})
+ 
+-       def __iter__(self):
+-           """
+-           To allow iteration over keys, which will be merged into
+-           the LogRecord dict before formatting and output.
+-           """
+-           keys = ['ip', 'user']
+-           keys.extend(self.__dict__.keys())
+-           return keys.__iter__()
++Then any events that you log to the adapter will have the value of
++``some_conn_id`` prepended to the log messages.
+ 
+-   if __name__ == '__main__':
+-       from random import choice
+-       levels = (logging.DEBUG, logging.INFO, logging.WARNING, logging.ERROR, logging.CRITICAL)
+-       a1 = logging.LoggerAdapter(logging.getLogger('a.b.c'),
+-                                  { 'ip' : '123.231.231.123', 'user' : 'sheila' })
+-       logging.basicConfig(level=logging.DEBUG,
+-                           format='%(asctime)-15s %(name)-5s %(levelname)-8s IP: %(ip)-15s User: %(user)-8s %(message)s')
+-       a1.debug('A debug message')
+-       a1.info('An info message with %s', 'some parameters')
+-       a2 = logging.LoggerAdapter(logging.getLogger('d.e.f'), ConnInfo())
+-       for x in range(10):
+-           lvl = choice(levels)
+-           lvlname = logging.getLevelName(lvl)
+-           a2.log(lvl, 'A message at %s level with %d %s', lvlname, 2, 'parameters')
++Using objects other than dicts to pass contextual information
++~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ 
+-When this script is run, the output should look something like this::
+-
+-   2008-01-18 14:49:54,023 a.b.c DEBUG    IP: 123.231.231.123 User: sheila   A debug message
+-   2008-01-18 14:49:54,023 a.b.c INFO     IP: 123.231.231.123 User: sheila   An info message with some parameters
+-   2008-01-18 14:49:54,023 d.e.f CRITICAL IP: 192.168.0.1     User: jim      A message at CRITICAL level with 2 parameters
+-   2008-01-18 14:49:54,033 d.e.f INFO     IP: 192.168.0.1     User: jim      A message at INFO level with 2 parameters
+-   2008-01-18 14:49:54,033 d.e.f WARNING  IP: 192.168.0.1     User: sheila   A message at WARNING level with 2 parameters
+-   2008-01-18 14:49:54,033 d.e.f ERROR    IP: 127.0.0.1       User: fred     A message at ERROR level with 2 parameters
+-   2008-01-18 14:49:54,033 d.e.f ERROR    IP: 127.0.0.1       User: sheila   A message at ERROR level with 2 parameters
+-   2008-01-18 14:49:54,033 d.e.f WARNING  IP: 192.168.0.1     User: sheila   A message at WARNING level with 2 parameters
+-   2008-01-18 14:49:54,033 d.e.f WARNING  IP: 192.168.0.1     User: jim      A message at WARNING level with 2 parameters
+-   2008-01-18 14:49:54,033 d.e.f INFO     IP: 192.168.0.1     User: fred     A message at INFO level with 2 parameters
+-   2008-01-18 14:49:54,033 d.e.f WARNING  IP: 192.168.0.1     User: sheila   A message at WARNING level with 2 parameters
+-   2008-01-18 14:49:54,033 d.e.f WARNING  IP: 127.0.0.1       User: jim      A message at WARNING level with 2 parameters
++You don't need to pass an actual dict to a :class:`LoggerAdapter` - you could
++pass an instance of a class which implements ``__getitem__`` and ``__iter__`` so
++that it looks like a dict to logging. This would be useful if you want to
++generate values dynamically (whereas the values in a dict would be constant).
+ 
+ 
+ .. _filters-contextual:
+diff -r d047928ae3f6 Doc/howto/sockets.rst
+--- a/Doc/howto/sockets.rst
++++ b/Doc/howto/sockets.rst
+@@ -19,12 +19,6 @@
+ Sockets
+ =======
+ 
+-Sockets are used nearly everywhere, but are one of the most severely
+-misunderstood technologies around. This is a 10,000 foot overview of sockets.
+-It's not really a tutorial - you'll still have work to do in getting things
+-working. It doesn't cover the fine points (and there are a lot of them), but I
+-hope it will give you enough background to begin using them decently.
+-
+ I'm only going to talk about INET (i.e. IPv4) sockets, but they account for at least 99% of
+ the sockets in use. And I'll only talk about STREAM (i.e. TCP) sockets - unless you really
+ know what you're doing (in which case this HOWTO isn't for you!), you'll get
+diff -r d047928ae3f6 Doc/howto/unicode.rst
+--- a/Doc/howto/unicode.rst
++++ b/Doc/howto/unicode.rst
+@@ -28,15 +28,15 @@
+ as 'naïve' and 'café', and some publications have house styles which require
+ spellings such as 'coöperate'.)
+ 
+-For a while people just wrote programs that didn't display accents.  I remember
+-looking at Apple ][ BASIC programs, published in French-language publications in
+-the mid-1980s, that had lines like these::
++For a while people just wrote programs that didn't display accents.
++In the mid-1980s an Apple II BASIC program written by a French speaker
++might have lines like these::
+ 
+    PRINT "FICHIER EST COMPLETE."
+    PRINT "CARACTERE NON ACCEPTE."
+ 
+-Those messages should contain accents, and they just look wrong to someone who
+-can read French.
++Those messages should contain accents (completé, caractère, accepté),
++and they just look wrong to someone who can read French.
+ 
+ In the 1980s, almost all personal computers were 8-bit, meaning that bytes could
+ hold values ranging from 0 to 255.  ASCII codes only went up to 127, so some
+@@ -69,9 +69,12 @@
+ originally separate efforts, but the specifications were merged with the 1.1
+ revision of Unicode.
+ 
+-(This discussion of Unicode's history is highly simplified.  I don't think the
+-average Python programmer needs to worry about the historical details; consult
+-the Unicode consortium site listed in the References for more information.)
++(This discussion of Unicode's history is highly simplified.  The
++precise historical details aren't necessary for understanding how to
++use Unicode effectively, but if you're curious, consult the Unicode
++consortium site listed in the References or
++the `Wikipedia entry for Unicode <http://en.wikipedia.org/wiki/Unicode#History>`_
++for more information.)
+ 
+ 
+ Definitions
+@@ -216,10 +219,8 @@
+ 
+ Another `good introductory article <http://www.joelonsoftware.com/articles/Unicode.html>`_
+ was written by Joel Spolsky.
+-If this introduction didn't make things clear to you, you should try reading this
+-alternate article before continuing.
+-
+-.. Jason Orendorff XXX http://www.jorendorff.com/articles/unicode/ is broken
++If this introduction didn't make things clear to you, you should try
++reading this alternate article before continuing.
+ 
+ Wikipedia entries are often helpful; see the entries for "`character encoding
+ <http://en.wikipedia.org/wiki/Character_encoding>`_" and `UTF-8
+@@ -239,8 +240,31 @@
+ characters, meaning any string created using ``"unicode rocks!"``, ``'unicode
+ rocks!'``, or the triple-quoted string syntax is stored as Unicode.
+ 
+-To insert a non-ASCII Unicode character, e.g., any letters with
+-accents, one can use escape sequences in their string literals as such::
++The default encoding for Python source code is UTF-8, so you can simply
++include a Unicode character in a string literal::
++
++   try:
++       with open('/tmp/input.txt', 'r') as f:
++           ...
++   except IOError:
++       # 'File not found' error message.
++       print("Fichier non trouvé")
++
++You can use a different encoding from UTF-8 by putting a specially-formatted
++comment as the first or second line of the source code::
++
++   # -*- coding: <encoding name> -*-
++
++Side note: Python 3 also supports using Unicode characters in identifiers::
++
++   répertoire = "/tmp/records.log"
++   with open(répertoire, "w") as f:
++       f.write("test\n")
++
++If you can't enter a particular character in your editor or want to
++keep the source code ASCII-only for some reason, you can also use
++escape sequences in string literals. (Depending on your system,
++you may see the actual capital-delta glyph instead of a \u escape.) ::
+ 
+    >>> "\N{GREEK CAPITAL LETTER DELTA}"  # Using the character name
+    '\u0394'
+@@ -251,7 +275,7 @@
+ 
+ In addition, one can create a string using the :func:`~bytes.decode` method of
+ :class:`bytes`.  This method takes an *encoding* argument, such as ``UTF-8``,
+-and optionally, an *errors* argument.
++and optionally an *errors* argument.
+ 
+ The *errors* argument specifies the response when the input string can't be
+ converted according to the encoding's rules.  Legal values for this argument are
+@@ -295,11 +319,15 @@
+ 
+ The opposite method of :meth:`bytes.decode` is :meth:`str.encode`,
+ which returns a :class:`bytes` representation of the Unicode string, encoded in the
+-requested *encoding*.  The *errors* parameter is the same as the parameter of
+-the :meth:`~bytes.decode` method, with one additional possibility; as well as
+-``'strict'``, ``'ignore'``, and ``'replace'`` (which in this case inserts a
+-question mark instead of the unencodable character), you can also pass
+-``'xmlcharrefreplace'`` which uses XML's character references.
++requested *encoding*.
++
++The *errors* parameter is the same as the parameter of the
++:meth:`~bytes.decode` method but supports a few more possible handlers. As well as
++``'strict'``, ``'ignore'``, and ``'replace'`` (which in this case
++inserts a question mark instead of the unencodable character), there is
++also ``'xmlcharrefreplace'`` (inserts an XML character reference) and
++``backslashreplace`` (inserts a ``\uNNNN`` escape sequence).
++
+ The following example shows the different results::
+ 
+     >>> u = chr(40960) + 'abcd' + chr(1972)
+@@ -316,16 +344,15 @@
+     b'?abcd?'
+     >>> u.encode('ascii', 'xmlcharrefreplace')
+     b'&#40960;abcd&#1972;'
++    >>> u.encode('ascii', 'backslashreplace')
++    b'\\ua000abcd\\u07b4'
+ 
+-.. XXX mention the surrogate* error handlers
+-
+-The low-level routines for registering and accessing the available encodings are
+-found in the :mod:`codecs` module.  However, the encoding and decoding functions
+-returned by this module are usually more low-level than is comfortable, so I'm
+-not going to describe the :mod:`codecs` module here.  If you need to implement a
+-completely new encoding, you'll need to learn about the :mod:`codecs` module
+-interfaces, but implementing encodings is a specialized task that also won't be
+-covered here.  Consult the Python documentation to learn more about this module.
++The low-level routines for registering and accessing the available
++encodings are found in the :mod:`codecs` module.  Implementing new
++encodings also requires understanding the :mod:`codecs` module.
++However, the encoding and decoding functions returned by this module
++are usually more low-level than is comfortable, and writing new encodings
++is a specialized task, so the module won't be covered in this HOWTO.
+ 
+ 
+ Unicode Literals in Python Source Code
+@@ -415,12 +442,50 @@
+ from the above output, ``'Ll'`` means 'Letter, lowercase', ``'No'`` means
+ "Number, other", ``'Mn'`` is "Mark, nonspacing", and ``'So'`` is "Symbol,
+ other".  See
+-<http://www.unicode.org/reports/tr44/#General_Category_Values> for a
++`the General Category Values section of the Unicode Character Database documentation <http://www.unicode.org/reports/tr44/#General_Category_Values>`_ for a
+ list of category codes.
+ 
++
++Unicode Regular Expressions
++---------------------------
++
++The regular expressions supported by the :mod:`re` module can be provided
++either as bytes or strings.  Some of the special character sequences such as
++``\d`` and ``\w`` have different meanings depending on whether
++the pattern is supplied as bytes or a string.  For example,
++``\d`` will match the characters ``[0-9]`` in bytes but
++in strings will match any character that's in the ``'Nd'`` category.
++
++The string in this example has the number 57 written in both Thai and
++Arabic numerals::
++
++   import re
++   p = re.compile('\d+')
++
++   s = "Over \u0e55\u0e57 57 flavours"
++   m = p.search(s)
++   print(repr(m.group()))
++
++When executed, ``\d+`` will match the Thai numerals and print them
++out.  If you supply the :const:`re.ASCII` flag to
++:func:`~re.compile`, ``\d+`` will match the substring "57" instead.
++
++Similarly, ``\w`` matches a wide variety of Unicode characters but
++only ``[a-zA-Z0-9_]`` in bytes or if :const:`re.ASCII` is supplied,
++and ``\s`` will match either Unicode whitespace characters or
++``[ \t\n\r\f\v]``.
++
++
+ References
+ ----------
+ 
++.. comment should these be mentioned earlier, e.g. at the start of the "introduction to Unicode" first section?
++
++Some good alternative discussions of Python's Unicode support are:
++
++* `Processing Text Files in Python 3 <http://python-notes.curiousefficiency.org/en/latest/python3/text_file_processing.html>`_, by Nick Coghlan.
++* `Pragmatic Unicode <http://nedbatchelder.com/text/unipain.html>`_, a PyCon 2012 presentation by Ned Batchelder.
++
+ The :class:`str` type is described in the Python library reference at
+ :ref:`textseq`.
+ 
+@@ -428,12 +493,10 @@
+ 
+ The documentation for the :mod:`codecs` module.
+ 
+-Marc-André Lemburg gave a presentation at EuroPython 2002 titled "Python and
+-Unicode".  A PDF version of his slides is available at
+-<http://downloads.egenix.com/python/Unicode-EPC2002-Talk.pdf>, and is an
+-excellent overview of the design of Python's Unicode features (based on Python
+-2, where the Unicode string type is called ``unicode`` and literals start with
+-``u``).
++Marc-André Lemburg gave `a presentation titled "Python and Unicode" (PDF slides) <http://downloads.egenix.com/python/Unicode-EPC2002-Talk.pdf>`_ at
++EuroPython 2002.  The slides are an excellent overview of the design
++of Python 2's Unicode features (where the Unicode string type is
++called ``unicode`` and literals start with ``u``).
+ 
+ 
+ Reading and Writing Unicode Data
+@@ -512,7 +575,7 @@
+ Windows, Python uses the name "mbcs" to refer to whatever the currently
+ configured encoding is.  On Unix systems, there will only be a filesystem
+ encoding if you've set the ``LANG`` or ``LC_CTYPE`` environment variables; if
+-you haven't, the default encoding is ASCII.
++you haven't, the default encoding is UTF-8.
+ 
+ The :func:`sys.getfilesystemencoding` function returns the encoding to use on
+ your current system, in case you want to do the encoding manually, but there's
+@@ -527,13 +590,13 @@
+ Functions in the :mod:`os` module such as :func:`os.stat` will also accept Unicode
+ filenames.
+ 
+-Function :func:`os.listdir`, which returns filenames, raises an issue: should it return
++The :func:`os.listdir` function returns filenames and raises an issue: should it return
+ the Unicode version of filenames, or should it return bytes containing
+ the encoded versions?  :func:`os.listdir` will do both, depending on whether you
+ provided the directory path as bytes or a Unicode string.  If you pass a
+ Unicode string as the path, filenames will be decoded using the filesystem's
+ encoding and a list of Unicode strings will be returned, while passing a byte
+-path will return the bytes versions of the filenames.  For example,
++path will return the filenames as bytes.  For example,
+ assuming the default filesystem encoding is UTF-8, running the following
+ program::
+ 
+@@ -548,13 +611,13 @@
+ will produce the following output::
+ 
+    amk:~$ python t.py
+-   [b'.svn', b'filename\xe4\x94\x80abc', ...]
+-   ['.svn', 'filename\u4500abc', ...]
++   [b'filename\xe4\x94\x80abc', ...]
++   ['filename\u4500abc', ...]
+ 
+ The first list contains UTF-8-encoded filenames, and the second list contains
+ the Unicode versions.
+ 
+-Note that in most occasions, the Unicode APIs should be used.  The bytes APIs
++Note that on most occasions, the Unicode APIs should be used.  The bytes APIs
+ should only be used on systems where undecodable file names can be present,
+ i.e. Unix systems.
+ 
+@@ -585,65 +648,69 @@
+ clever way to hide malicious text in the encoded bytestream.
+ 
+ 
++Converting Between File Encodings
++'''''''''''''''''''''''''''''''''
++
++The :class:`~codecs.StreamRecoder` class can transparently convert between
++encodings, taking a stream that returns data in encoding #1
++and behaving like a stream returning data in encoding #2.
++
++For example, if you have an input file *f* that's in Latin-1, you
++can wrap it with a :class:`StreamRecoder` to return bytes encoded in UTF-8::
++
++    new_f = codecs.StreamRecoder(f,
++        # en/decoder: used by read() to encode its results and
++        # by write() to decode its input.
++        codecs.getencoder('utf-8'), codecs.getdecoder('utf-8'),
++
++        # reader/writer: used to read and write to the stream.
++        codecs.getreader('latin-1'), codecs.getwriter('latin-1') )
++
++
++Files in an Unknown Encoding
++''''''''''''''''''''''''''''
++
++What can you do if you need to make a change to a file, but don't know
++the file's encoding?  If you know the encoding is ASCII-compatible and
++only want to examine or modify the ASCII parts, you can open the file
++with the ``surrogateescape`` error handler::
++
++   with open(fname, 'r', encoding="ascii", errors="surrogateescape") as f:
++       data = f.read()
++
++   # make changes to the string 'data'
++
++   with open(fname + '.new', 'w',
++              encoding="ascii", errors="surrogateescape") as f:
++       f.write(data)
++
++The ``surrogateescape`` error handler will decode any non-ASCII bytes
++as code points in the Unicode Private Use Area ranging from U+DC80 to
++U+DCFF.  These private code points will then be turned back into the
++same bytes when the ``surrogateescape`` error handler is used when
++encoding the data and writing it back out.
++
++
+ References
+ ----------
+ 
+-The PDF slides for Marc-André Lemburg's presentation "Writing Unicode-aware
+-Applications in Python" are available at
+-<http://downloads.egenix.com/python/LSM2005-Developing-Unicode-aware-applications-in-Python.pdf>
+-and discuss questions of character encodings as well as how to internationalize
++One section of `Mastering Python 3 Input/Output <http://pyvideo.org/video/289/pycon-2010--mastering-python-3-i-o>`_,  a PyCon 2010 talk by David Beazley, discusses text processing and binary data handling.
++
++The `PDF slides for Marc-André Lemburg's presentation "Writing Unicode-aware Applications in Python" <http://downloads.egenix.com/python/LSM2005-Developing-Unicode-aware-applications-in-Python.pdf>`_
++discuss questions of character encodings as well as how to internationalize
+ and localize an application.  These slides cover Python 2.x only.
+ 
++`The Guts of Unicode in Python <http://pyvideo.org/video/1768/the-guts-of-unicode-in-python>`_ is a PyCon 2013 talk by Benjamin Peterson that discusses the internal Unicode representation in Python 3.3.
++
+ 
+ Acknowledgements
+ ================
+ 
+-Thanks to the following people who have noted errors or offered suggestions on
+-this article: Nicholas Bastin, Marius Gedminas, Kent Johnson, Ken Krugler,
+-Marc-André Lemburg, Martin von Löwis, Chad Whitacre.
++The initial draft of this document was written by Andrew Kuchling.
++It has since been revised further by Alexander Belopolsky, Georg Brandl,
++Andrew Kuchling, and Ezio Melotti.
+ 
+-.. comment
+-   Revision History
+-
+-   Version 1.0: posted August 5 2005.
+-
+-   Version 1.01: posted August 7 2005.  Corrects factual and markup errors; adds
+-   several links.
+-
+-   Version 1.02: posted August 16 2005.  Corrects factual errors.
+-
+-   Version 1.1: Feb-Nov 2008.  Updates the document with respect to Python 3 changes.
+-
+-   Version 1.11: posted June 20 2010.  Notes that Python 3.x is not covered,
+-   and that the HOWTO only covers 2.x.
+-
+-.. comment Describe Python 3.x support (new section? new document?)
+-.. comment Describe use of codecs.StreamRecoder and StreamReaderWriter
+-
+-.. comment
+-   Original outline:
+-
+-   - [ ] Unicode introduction
+-       - [ ] ASCII
+-       - [ ] Terms
+-           - [ ] Character
+-           - [ ] Code point
+-         - [ ] Encodings
+-            - [ ] Common encodings: ASCII, Latin-1, UTF-8
+-       - [ ] Unicode Python type
+-           - [ ] Writing unicode literals
+-               - [ ] Obscurity: -U switch
+-           - [ ] Built-ins
+-               - [ ] unichr()
+-               - [ ] ord()
+-               - [ ] unicode() constructor
+-           - [ ] Unicode type
+-               - [ ] encode(), decode() methods
+-       - [ ] Unicodedata module for character properties
+-       - [ ] I/O
+-           - [ ] Reading/writing Unicode data into files
+-               - [ ] Byte-order marks
+-           - [ ] Unicode filenames
+-       - [ ] Writing Unicode programs
+-           - [ ] Do everything in Unicode
+-           - [ ] Declaring source code encodings (PEP 263)
++Thanks to the following people who have noted errors or offered
++suggestions on this article: Éric Araujo, Nicholas Bastin, Nick
++Coghlan, Marius Gedminas, Kent Johnson, Ken Krugler, Marc-André
++Lemburg, Martin von Löwis, Terry J. Reedy, Chad Whitacre.
+diff -r d047928ae3f6 Doc/library/array.rst
+--- a/Doc/library/array.rst
++++ b/Doc/library/array.rst
+@@ -271,9 +271,7 @@
+       Packing and unpacking of External Data Representation (XDR) data as used in some
+       remote procedure call systems.
+ 
+-   `The Numerical Python Manual <http://numpy.sourceforge.net/numdoc/HTML/numdoc.htm>`_
++   `The Numerical Python Documentation <http://docs.scipy.org/doc/>`_
+       The Numeric Python extension (NumPy) defines another array type; see
+-      http://numpy.sourceforge.net/ for further information about Numerical Python.
+-      (A PDF version of the NumPy manual is available at
+-      http://numpy.sourceforge.net/numdoc/numdoc.pdf).
++      http://www.numpy.org/ for further information about Numerical Python.
+ 
+diff -r d047928ae3f6 Doc/library/base64.rst
+--- a/Doc/library/base64.rst
++++ b/Doc/library/base64.rst
+@@ -103,7 +103,7 @@
+    digit 0 is always mapped to the letter O).  For security purposes the default is
+    ``None``, so that 0 and 1 are not allowed in the input.
+ 
+-   The decoded byte string is returned.  A :exc:`TypeError` is raised if *s* were
++   The decoded byte string is returned.  A :exc:`binascii.Error` is raised if *s* were
+    incorrectly padded or if there are non-alphabet characters present in the
+    string.
+ 
 diff -r d047928ae3f6 Doc/library/codecs.rst
 --- a/Doc/library/codecs.rst
 +++ b/Doc/library/codecs.rst
-@@ -1142,7 +1142,19 @@
+@@ -78,7 +78,11 @@
+      reference (for encoding only)
+    * ``'backslashreplace'``: replace with backslashed escape sequences (for
+      encoding only)
+-   * ``'surrogateescape'``: replace with surrogate U+DCxx, see :pep:`383`
++   * ``'surrogateescape'``: on decoding, replace with code points in the Unicode
++     Private Use Area ranging from U+DC80 to U+DCFF.  These private code
++     points will then be turned back into the same bytes when the
++     ``surrogateescape`` error handler is used when encoding the data.
++     (See :pep:`383` for more.)
+ 
+    as well as any other error handling name defined via :func:`register_error`.
+ 
+@@ -690,7 +694,7 @@
+       Read one line from the input stream and return the decoded data.
+ 
+       *size*, if given, is passed as size argument to the stream's
+-      :meth:`readline` method.
++      :meth:`read` method.
+ 
+       If *keepends* is false line-endings will be stripped from the lines
+       returned.
+@@ -1142,7 +1146,19 @@
  | utf_8_sig       |                                | all languages                  |
  +-----------------+--------------------------------+--------------------------------+
  
@@ -144,7 +2416,7 @@
  
  .. tabularcolumns:: |l|p{0.3\linewidth}|p{0.3\linewidth}|
  
-@@ -1186,37 +1198,45 @@
+@@ -1186,37 +1202,45 @@
  |                    |         | .. deprecated:: 3.3       |
  +--------------------+---------+---------------------------+
  
@@ -218,7 +2490,7 @@
  
  .. tabularcolumns:: |l|L|
  
-@@ -1228,7 +1248,7 @@
+@@ -1228,7 +1252,7 @@
  +--------------------+---------------------------+
  
  .. versionadded:: 3.2
@@ -227,6 +2499,18 @@
  
  
  :mod:`encodings.idna` --- Internationalized Domain Names in Applications
+diff -r d047928ae3f6 Doc/library/configparser.rst
+--- a/Doc/library/configparser.rst
++++ b/Doc/library/configparser.rst
+@@ -539,7 +539,7 @@
+ * *delimiters*, default value: ``('=', ':')``
+ 
+   Delimiters are substrings that delimit keys from values within a section. The
+-  first occurence of a delimiting substring on a line is considered a delimiter.
++  first occurrence of a delimiting substring on a line is considered a delimiter.
+   This means values (but not keys) can contain the delimiters.
+ 
+   See also the *space_around_delimiters* argument to
 diff -r d047928ae3f6 Doc/library/ctypes.rst
 --- a/Doc/library/ctypes.rst
 +++ b/Doc/library/ctypes.rst
@@ -239,6 +2523,305 @@
  module instead of using :func:`find_library` to locate the library at runtime.
  
  
+diff -r d047928ae3f6 Doc/library/difflib.rst
+--- a/Doc/library/difflib.rst
++++ b/Doc/library/difflib.rst
+@@ -752,7 +752,7 @@
+        # we're passing these as arguments to the diff function
+        fromdate = time.ctime(os.stat(fromfile).st_mtime)
+        todate = time.ctime(os.stat(tofile).st_mtime)
+-       with open(fromlines) as fromf, open(tofile) as tof:
++       with open(fromfile) as fromf, open(tofile) as tof:
+            fromlines, tolines = list(fromf), list(tof)
+ 
+        if options.u:
+diff -r d047928ae3f6 Doc/library/email.iterators.rst
+--- a/Doc/library/email.iterators.rst
++++ b/Doc/library/email.iterators.rst
+@@ -33,14 +33,22 @@
+    Thus, by default :func:`typed_subpart_iterator` returns each subpart that has a
+    MIME type of :mimetype:`text/\*`.
+ 
++
+ The following function has been added as a useful debugging tool.  It should
+ *not* be considered part of the supported public interface for the package.
+ 
+-
+ .. function:: _structure(msg, fp=None, level=0, include_default=False)
+ 
+    Prints an indented representation of the content types of the message object
+-   structure.  For example::
++   structure.  For example:
++
++   .. testsetup::
++
++      >>> import email
++      >>> from email.iterators import _structure
++      >>> somefile = open('Lib/test/test_email/data/msg_02.txt')
++
++   .. doctest::
+ 
+       >>> msg = email.message_from_file(somefile)
+       >>> _structure(msg)
+@@ -60,6 +68,10 @@
+                   text/plain
+           text/plain
+ 
++   .. testsetup::
++
++      >>> somefile.close()
++
+    Optional *fp* is a file-like object to print the output to.  It must be
+    suitable for Python's :func:`print` function.  *level* is used internally.
+    *include_default*, if true, prints the default type as well.
+diff -r d047928ae3f6 Doc/library/email.message.rst
+--- a/Doc/library/email.message.rst
++++ b/Doc/library/email.message.rst
+@@ -513,16 +513,25 @@
+       iterator in a ``for`` loop; each iteration returns the next subpart.
+ 
+       Here's an example that prints the MIME type of every part of a multipart
+-      message structure::
++      message structure:
+ 
+-        >>> for part in msg.walk():
+-        ...     print(part.get_content_type())
+-        multipart/report
+-        text/plain
+-        message/delivery-status
+-        text/plain
+-        text/plain
+-        message/rfc822
++       .. testsetup::
++
++            >>> from email import message_from_binary_file
++            >>> with open('Lib/test/test_email/data/msg_16.txt', 'rb') as f:
++            ...     msg = message_from_binary_file(f)
++
++       .. doctest::
++
++            >>> for part in msg.walk():
++            ...     print(part.get_content_type())
++            multipart/report
++            text/plain
++            message/delivery-status
++            text/plain
++            text/plain
++            message/rfc822
++            text/plain
+ 
+    :class:`Message` objects can also optionally contain two instance attributes,
+    which can be used when generating the plain text of a MIME message.
+diff -r d047928ae3f6 Doc/library/email.policy.rst
+--- a/Doc/library/email.policy.rst
++++ b/Doc/library/email.policy.rst
+@@ -56,19 +56,42 @@
+ attributes values changed.
+ 
+ As an example, the following code could be used to read an email message from a
+-file on disk and pass it to the system ``sendmail`` program on a Unix system::
++file on disk and pass it to the system ``sendmail`` program on a Unix system:
+ 
+-   >>> from email import msg_from_binary_file
++.. testsetup::
++
++   >>> from unittest import mock
++   >>> mocker = mock.patch('subprocess.Popen')
++   >>> m = mocker.start()
++   >>> proc = mock.MagicMock()
++   >>> m.return_value = proc
++   >>> proc.stdin.close.return_value = None
++   >>> mymsg = open('mymsg.txt', 'w')
++   >>> mymsg.write('To: [e-mail]\n\n')
++   17
++   >>> mymsg.flush()
++
++.. doctest::
++
++   >>> from email import message_from_binary_file
+    >>> from email.generator import BytesGenerator
++   >>> from email import policy
+    >>> from subprocess import Popen, PIPE
+-   >>> with open('mymsg.txt', 'b') as f:
+-   ...     msg = msg_from_binary_file(f)
+-   >>> p = Popen(['sendmail', msg['To'][0].address], stdin=PIPE)
++   >>> with open('mymsg.txt', 'rb') as f:
++   ...     msg = message_from_binary_file(f, policy=policy.default)
++   >>> p = Popen(['sendmail', msg['To'].addresses[0]], stdin=PIPE)
+    >>> g = BytesGenerator(p.stdin, policy=msg.policy.clone(linesep='\r\n'))
+    >>> g.flatten(msg)
+    >>> p.stdin.close()
+    >>> rc = p.wait()
+ 
++.. testsetup::
++
++   >>> mymsg.close()
++   >>> mocker.stop()
++   >>> import os
++   >>> os.remove('mymsg.txt')
++
+ Here we are telling :class:`~email.generator.BytesGenerator` to use the RFC
+ correct line separator characters when creating the binary string to feed into
+ ``sendmail's`` ``stdin``, where the default policy would use ``\n`` line
+@@ -82,22 +105,22 @@
+ 
+    >>> import os
+    >>> with open('converted.txt', 'wb') as f:
+-   ...     f.write(msg.as_string(policy=msg.policy.clone(linesep=os.linesep))
++   ...     f.write(msg.as_string(policy=msg.policy.clone(linesep=os.linesep)))
+ 
+ Policy objects can also be combined using the addition operator, producing a
+ policy object whose settings are a combination of the non-default values of the
+ summed objects::
+ 
+-   >>> compat_SMTP = email.policy.clone(linesep='\r\n')
+-   >>> compat_strict = email.policy.clone(raise_on_defect=True)
++   >>> compat_SMTP = policy.compat32.clone(linesep='\r\n')
++   >>> compat_strict = policy.compat32.clone(raise_on_defect=True)
+    >>> compat_strict_SMTP = compat_SMTP + compat_strict
+ 
+ This operation is not commutative; that is, the order in which the objects are
+ added matters.  To illustrate::
+ 
+-   >>> policy100 = compat32.clone(max_line_length=100)
+-   >>> policy80 = compat32.clone(max_line_length=80)
+-   >>> apolicy = policy100 + Policy80
++   >>> policy100 = policy.compat32.clone(max_line_length=100)
++   >>> policy80 = policy.compat32.clone(max_line_length=80)
++   >>> apolicy = policy100 + policy80
+    >>> apolicy.max_line_length
+    80
+    >>> apolicy = policy80 + policy100
+diff -r d047928ae3f6 Doc/library/functions.rst
+--- a/Doc/library/functions.rst
++++ b/Doc/library/functions.rst
+@@ -583,11 +583,16 @@
+ 
+ .. function:: hash(object)
+ 
+-   Return the hash value of the object (if it has one).  Hash values are integers.
+-   They are used to quickly compare dictionary keys during a dictionary lookup.
+-   Numeric values that compare equal have the same hash value (even if they are of
+-   different types, as is the case for 1 and 1.0).
++   Return the hash value of the object (if it has one).  Hash values are
++   integers.  They are used to quickly compare dictionary keys during a
++   dictionary lookup.  Numeric values that compare equal have the same hash
++   value (even if they are of different types, as is the case for 1 and 1.0).
+ 
++  .. note::
++
++    For object's with custom :meth:`__hash__` methods, note that :func:`hash`
++    truncates the return value based on the bit width of the host machine.
++    See :meth:`__hash__` for details.
+ 
+ .. function:: help([object])
+ 
+@@ -895,16 +900,36 @@
+    the list of supported encodings.
+ 
+    *errors* is an optional string that specifies how encoding and decoding
+-   errors are to be handled--this cannot be used in binary mode.  Pass
+-   ``'strict'`` to raise a :exc:`ValueError` exception if there is an encoding
+-   error (the default of ``None`` has the same effect), or pass ``'ignore'`` to
+-   ignore errors.  (Note that ignoring encoding errors can lead to data loss.)
+-   ``'replace'`` causes a replacement marker (such as ``'?'``) to be inserted
+-   where there is malformed data.  When writing, ``'xmlcharrefreplace'``
+-   (replace with the appropriate XML character reference) or
+-   ``'backslashreplace'`` (replace with backslashed escape sequences) can be
+-   used.  Any other error handling name that has been registered with
+-   :func:`codecs.register_error` is also valid.
++   errors are to be handled--this cannot be used in binary mode.
++   A variety of standard error handlers are available, though any
++   error handling name that has been registered with
++   :func:`codecs.register_error` is also valid.  The standard names
++   are:
++
++   * ``'strict'`` to raise a :exc:`ValueError` exception if there is
++     an encoding error.  The default value of ``None`` has the same
++     effect.
++
++   * ``'ignore'`` ignores errors.  Note that ignoring encoding errors
++     can lead to data loss.
++
++   * ``'replace'`` causes a replacement marker (such as ``'?'``) to be inserted
++     where there is malformed data.
++
++   * ``'surrogateescape'`` will represent any incorrect bytes as code
++     points in the Unicode Private Use Area ranging from U+DC80 to
++     U+DCFF.  These private code points will then be turned back into
++     the same bytes when the ``surrogateescape`` error handler is used
++     when writing data.  This is useful for processing files in an
++     unknown encoding.
++
++   * ``'xmlcharrefreplace'`` is only supported when writing to a file.
++     Characters not supported by the encoding are replaced with the
++     appropriate XML character reference ``&#nnn;``.
++
++   * ``'backslashreplace'`` (also only supported when writing)
++     replaces unsupported characters with Python's backslashed escape
++     sequences.
+ 
+    .. index::
+       single: universal newlines; open() built-in function
+@@ -1355,14 +1380,18 @@
+ 
+ .. function:: vars([object])
+ 
+-   Without an argument, act like :func:`locals`.
++   Return the :attr:`__dict__` attribute for a module, class, instance,
++   or any other object with a :attr:`__dict__` attribute.
+ 
+-   With a module, class or class instance object as argument (or anything else that
+-   has a :attr:`__dict__` attribute), return that attribute.
++   Objects such as modules and instances have an updateable :attr:`__dict__`
++   attribute; however, other objects may have write restrictions on their
++   :attr:`__dict__` attributes (for example, classes use a
++   dictproxy to prevent direct dictionary updates).
+ 
+-   .. note::
+-      The returned dictionary should not be modified:
+-      the effects on the corresponding symbol table are undefined. [#]_
++   Without an argument, :func:`vars` acts like :func:`locals`.  Note, the
++   locals dictionary is only useful for reads since updates to the locals
++   dictionary are ignored.
++
+ 
+ .. function:: zip(*iterables)
+ 
+@@ -1481,7 +1510,3 @@
+ .. [#] Note that the parser only accepts the Unix-style end of line convention.
+    If you are reading the code from a file, make sure to use newline conversion
+    mode to convert Windows or Mac-style newlines.
+-
+-.. [#] In the current implementation, local variable bindings cannot normally be
+-   affected this way, but variables retrieved from other scopes (such as modules)
+-   can be.  This may change.
+diff -r d047928ae3f6 Doc/library/gc.rst
+--- a/Doc/library/gc.rst
++++ b/Doc/library/gc.rst
+@@ -121,8 +121,8 @@
+ 
+    Return a list of objects directly referred to by any of the arguments. The
+    referents returned are those objects visited by the arguments' C-level
+-   :attr:`tp_traverse` methods (if any), and may not be all objects actually
+-   directly reachable.  :attr:`tp_traverse` methods are supported only by objects
++   :c:member:`~PyTypeObject.tp_traverse` methods (if any), and may not be all objects actually
++   directly reachable.  :c:member:`~PyTypeObject.tp_traverse` methods are supported only by objects
+    that support garbage collection, and are only required to visit objects that may
+    be involved in a cycle.  So, for example, if an integer is directly reachable
+    from an argument, that integer object may or may not appear in the result list.
+diff -r d047928ae3f6 Doc/library/heapq.rst
+--- a/Doc/library/heapq.rst
++++ b/Doc/library/heapq.rst
+@@ -246,7 +246,7 @@
+ the sort is going on, provided that the inserted items are not "better" than the
+ last 0'th element you extracted.  This is especially useful in simulation
+ contexts, where the tree holds all incoming events, and the "win" condition
+-means the smallest scheduled time.  When an event schedule other events for
++means the smallest scheduled time.  When an event schedules other events for
+ execution, they are scheduled into the future, so they can easily go into the
+ heap.  So, a heap is a good structure for implementing schedulers (this is what
+ I used for my MIDI sequencer :-).
 diff -r d047928ae3f6 Doc/library/http.cookiejar.rst
 --- a/Doc/library/http.cookiejar.rst
 +++ b/Doc/library/http.cookiejar.rst
@@ -279,6 +2862,32 @@
  
  .. method:: CookieJar.set_policy(policy)
  
+diff -r d047928ae3f6 Doc/library/idle.rst
+--- a/Doc/library/idle.rst
++++ b/Doc/library/idle.rst
+@@ -33,8 +33,8 @@
+ File menu
+ ^^^^^^^^^
+ 
+-New window
+-   create a new editing window
++New file
++   create a new file editing window
+ 
+ Open...
+    open an existing file
+diff -r d047928ae3f6 Doc/library/imp.rst
+--- a/Doc/library/imp.rst
++++ b/Doc/library/imp.rst
+@@ -158,7 +158,7 @@
+           cache = {}
+ 
+    It is legal though generally not very useful to reload built-in or dynamically
+-   loaded modules, except for :mod:`sys`, :mod:`__main__` and :mod:`__builtin__`.
++   loaded modules, except for :mod:`sys`, :mod:`__main__` and :mod:`builtins`.
+    In many cases, however, extension modules are not designed to be initialized
+    more than once, and may fail in arbitrary ways when reloaded.
+ 
 diff -r d047928ae3f6 Doc/library/importlib.rst
 --- a/Doc/library/importlib.rst
 +++ b/Doc/library/importlib.rst
@@ -314,6 +2923,322 @@
       :data:`sys.path_importer_cache`, then :data:`sys.path_hooks` is
       searched for a finder for the path entry and, if found, is stored in
       :data:`sys.path_importer_cache` along with being queried about the
+@@ -692,6 +697,8 @@
+ 
+    The *loader_details* argument is a variable number of 2-item tuples each
+    containing a loader and a sequence of file suffixes the loader recognizes.
++   The loaders are expected to be callables which accept two arguments of
++   the module's name and the path to the file found.
+ 
+    The finder will cache the directory contents as necessary, making stat calls
+    for each module search to verify the cache is not outdated. Because cache
+@@ -709,7 +716,7 @@
+ 
+       The path the finder will search in.
+ 
+-   .. method:: find_module(fullname)
++   .. method:: find_loader(fullname)
+ 
+       Attempt to find the loader to handle *fullname* within :attr:`path`.
+ 
+diff -r d047928ae3f6 Doc/library/itertools.rst
+--- a/Doc/library/itertools.rst
++++ b/Doc/library/itertools.rst
+@@ -278,7 +278,7 @@
+ 
+ .. function:: count(start=0, step=1)
+ 
+-   Make an iterator that returns evenly spaced values starting with *n*. Often
++   Make an iterator that returns evenly spaced values starting with number *start*. Often
+    used as an argument to :func:`map` to generate consecutive data points.
+    Also, used with :func:`zip` to add sequence numbers.  Equivalent to::
+ 
+@@ -762,7 +762,7 @@
+        """ Call a function repeatedly until an exception is raised.
+ 
+        Converts a call-until-exception interface to an iterator interface.
+-       Like __builtin__.iter(func, sentinel) but uses an exception instead
++       Like builtins.iter(func, sentinel) but uses an exception instead
+        of a sentinel to end the loop.
+ 
+        Examples:
+diff -r d047928ae3f6 Doc/library/multiprocessing.rst
+--- a/Doc/library/multiprocessing.rst
++++ b/Doc/library/multiprocessing.rst
+@@ -284,6 +284,9 @@
+            print(result.get(timeout=1))       # prints "100" unless your computer is *very* slow
+            print(pool.map(f, range(10)))      # prints "[0, 1, 4,..., 81]"
+ 
++Note that the methods of a pool should only ever be used by the
++process which created it.
++
+ 
+ Reference
+ ---------
+@@ -443,7 +446,7 @@
+          cause other processes to deadlock.
+ 
+    Note that the :meth:`start`, :meth:`join`, :meth:`is_alive`,
+-   :meth:`terminate` and :attr:`exit_code` methods should only be called by
++   :meth:`terminate` and :attr:`exitcode` methods should only be called by
+    the process that created the process object.
+ 
+    Example usage of some of the methods of :class:`Process`:
+@@ -515,6 +518,24 @@
+    the :mod:`multiprocessing` namespace so you need to import them from
+    :mod:`queue`.
+ 
++.. note::
++
++   When an object is put on a queue, the object is pickled and a
++   background thread later flushes the pickled data to an underlying
++   pipe.  This has some consequences which are a little surprising,
++   but should not cause any practical difficulties -- if they really
++   bother you then you can instead use a queue created with a
++   :ref:`manager <multiprocessing-managers>`.
++
++   (1) After putting an object on an empty queue there may be an
++       infinitesimal delay before the queue's :meth:`~Queue.empty`
++       method returns :const:`False` and :meth:`~Queue.get_nowait` can
++       return without raising :exc:`Queue.Empty`.
++
++   (2) If multiple processes are enqueuing objects, it is possible for
++       the objects to be received at the other end out-of-order.
++       However, objects enqueued by the same process will always be in
++       the expected order with respect to each other.
+ 
+ .. warning::
+ 
+@@ -638,6 +659,13 @@
+       the background thread from being joined automatically when the process
+       exits -- see :meth:`join_thread`.
+ 
++      A better name for this method might be
++      ``allow_exit_without_flush()``.  It is likely to cause enqueued
++      data to lost, and you almost certainly will not need to use it.
++      It is really only there if you need the current process to exit
++      immediately without waiting to flush enqueued data to the
++      underlying pipe, and you don't care about lost data.
++
+ 
+ .. class:: SimpleQueue()
+ 
+@@ -1647,6 +1675,9 @@
+    *initializer* is not ``None`` then each worker process will call
+    ``initializer(*initargs)`` when it starts.
+ 
++   Note that the methods of the pool object should only be called by
++   the process which created the pool.
++
+    .. versionadded:: 3.2
+       *maxtasksperchild* is the number of tasks a worker process can complete
+       before it will exit and be replaced with a fresh worker process, to enable
+diff -r d047928ae3f6 Doc/library/os.path.rst
+--- a/Doc/library/os.path.rst
++++ b/Doc/library/os.path.rst
+@@ -234,8 +234,10 @@
+ 
+ .. function:: relpath(path, start=None)
+ 
+-   Return a relative filepath to *path* either from the current directory or from
+-   an optional *start* point.
++   Return a relative filepath to *path* either from the current directory or
++   from an optional *start* directory.  This is a path computation:  the
++   filesystem is not accessed to confirm the existence or nature of *path* or
++   *start*.
+ 
+    *start* defaults to :attr:`os.curdir`.
+ 
+diff -r d047928ae3f6 Doc/library/os.rst
+--- a/Doc/library/os.rst
++++ b/Doc/library/os.rst
+@@ -2023,9 +2023,10 @@
+    Create a symbolic link pointing to *source* named *link_name*.
+ 
+    On Windows, a symlink represents either a file or a directory, and does not
+-   morph to the target dynamically.  If *target_is_directory* is set to ``True``,
+-   the symlink will be created as a directory symlink, otherwise as a file symlink
+-   (the default).  On non-Window platforms, *target_is_directory* is ignored.
++   morph to the target dynamically.  If the target is present, the type of the
++   symlink will be created to match. Otherwise, the symlink will be created
++   as a directory if *target_is_directory* is ``True`` or a file symlink (the
++   default) otherwise.  On non-Window platforms, *target_is_directory* is ignored.
+ 
+    Symbolic link support was introduced in Windows 6.0 (Vista).  :func:`symlink`
+    will raise a :exc:`NotImplementedError` on Windows versions earlier than 6.0.
+@@ -2041,6 +2042,7 @@
+       to the administrator level. Either obtaining the privilege or running your
+       application as an administrator are ways to successfully create symlinks.
+ 
++
+       :exc:`OSError` is raised when the function is called by an unprivileged
+       user.
+ 
+diff -r d047928ae3f6 Doc/library/smtplib.rst
+--- a/Doc/library/smtplib.rst
++++ b/Doc/library/smtplib.rst
+@@ -24,17 +24,20 @@
+ 
+    A :class:`SMTP` instance encapsulates an SMTP connection.  It has methods
+    that support a full repertoire of SMTP and ESMTP operations. If the optional
+-   host and port parameters are given, the SMTP :meth:`connect` method is called
+-   with those parameters during initialization.  If the :meth:`connect` call
+-   returns anything other than a success code, an :exc:`SMTPConnectError` is
+-   raised. The optional *timeout* parameter specifies a timeout in seconds for
+-   blocking operations like the connection attempt (if not specified, the
+-   global default timeout setting will be used). The optional source_address
+-   parameter allows to bind to some specific source address in a machine with
+-   multiple network interfaces, and/or to some specific source TCP port. It
+-   takes a 2-tuple (host, port), for the socket to bind to as its source
+-   address before connecting. If omitted (or if host or port are ``''`` and/or
+-   0 respectively) the OS default behavior will be used.
++   host and port parameters are given, the SMTP :meth:`connect` method is
++   called with those parameters during initialization.  If specified,
++   *local_hostname* is used as the FQDN of the local host in the HELO/EHLO
++   command.  Otherwise, the local hostname is found using
++   :func:`socket.getfqdn`.  If the :meth:`connect` call returns anything other
++   than a success code, an :exc:`SMTPConnectError` is raised. The optional
++   *timeout* parameter specifies a timeout in seconds for blocking operations
++   like the connection attempt (if not specified, the global default timeout
++   setting will be used). The optional source_address parameter allows to bind
++   to some specific source address in a machine with multiple network
++   interfaces, and/or to some specific source TCP port. It takes a 2-tuple
++   (host, port), for the socket to bind to as its source address before
++   connecting. If omitted (or if host or port are ``''`` and/or 0 respectively)
++   the OS default behavior will be used.
+ 
+    For normal use, you should only require the initialization/connect,
+    :meth:`sendmail`, and :meth:`~smtplib.quit` methods.
+@@ -57,17 +60,21 @@
+    .. versionchanged:: 3.3
+       source_address argument was added.
+ 
+-.. class:: SMTP_SSL(host='', port=0, local_hostname=None, keyfile=None, certfile=None[, timeout], context=None, source_address=None)
++.. class:: SMTP_SSL(host='', port=0, local_hostname=None, keyfile=None, \
++                    certfile=None [, timeout], context=None, \
++                    source_address=None)
+ 
+    A :class:`SMTP_SSL` instance behaves exactly the same as instances of
+    :class:`SMTP`. :class:`SMTP_SSL` should be used for situations where SSL is
+    required from the beginning of the connection and using :meth:`starttls` is
+    not appropriate. If *host* is not specified, the local host is used. If
+-   *port* is zero, the standard SMTP-over-SSL port (465) is used. *keyfile*
+-   and *certfile* are also optional, and can contain a PEM formatted private key
+-   and certificate chain file for the SSL connection. *context* also optional, can contain
+-   a SSLContext, and is an alternative to keyfile and certfile; If it is specified both
+-   keyfile and certfile must be None.  The optional *timeout*
++   *port* is zero, the standard SMTP-over-SSL port (465) is used.  The optional
++   arguments *local_hostname* and *source_address* have the same meaning as
++   they do in the :class:`SMTP` class.  *keyfile* and *certfile* are also
++   optional, and can contain a PEM formatted private key and certificate chain
++   file for the SSL connection. *context* also optional, can contain a
++   SSLContext, and is an alternative to keyfile and certfile; If it is
++   specified both keyfile and certfile must be None.  The optional *timeout*
+    parameter specifies a timeout in seconds for blocking operations like the
+    connection attempt (if not specified, the global default timeout setting
+    will be used). The optional source_address parameter allows to bind to some
+@@ -90,12 +97,12 @@
+    standard SMTP client. It's common to use Unix sockets for LMTP, so our
+    :meth:`connect` method must support that as well as a regular host:port
+    server. The optional arguments local_hostname and source_address have the
+-   same meaning as that of SMTP client. To specify a Unix socket, you must use
+-   an absolute path for *host*, starting with a '/'.
++   same meaning as they do in the :class:`SMTP` class. To specify a Unix
++   socket, you must use an absolute path for *host*, starting with a '/'.
+ 
+-   Authentication is supported, using the regular SMTP mechanism. When using a Unix
+-   socket, LMTP generally don't support or require any authentication, but your
+-   mileage might vary.
++   Authentication is supported, using the regular SMTP mechanism. When using a
++   Unix socket, LMTP generally don't support or require any authentication, but
++   your mileage might vary.
+ 
+ 
+ A nice selection of exceptions is defined as well:
+diff -r d047928ae3f6 Doc/library/ssl.rst
+--- a/Doc/library/ssl.rst
++++ b/Doc/library/ssl.rst
+@@ -773,7 +773,7 @@
+ 
+ .. method:: SSLContext.set_npn_protocols(protocols)
+ 
+-   Specify which protocols the socket should avertise during the SSL/TLS
++   Specify which protocols the socket should advertise during the SSL/TLS
+    handshake. It should be a list of strings, like ``['http/1.1', 'spdy/2']``,
+    ordered by preference. The selection of a protocol will happen during the
+    handshake, and will play out according to the `NPN draft specification
+diff -r d047928ae3f6 Doc/library/stdtypes.rst
+--- a/Doc/library/stdtypes.rst
++++ b/Doc/library/stdtypes.rst
+@@ -751,7 +751,7 @@
+    iterators for those iteration types.  (An example of an object supporting
+    multiple forms of iteration would be a tree structure which supports both
+    breadth-first and depth-first traversal.)  This method corresponds to the
+-   :attr:`tp_iter` slot of the type structure for Python objects in the Python/C
++   :c:member:`~PyTypeObject.tp_iter` slot of the type structure for Python objects in the Python/C
+    API.
+ 
+ The iterator objects themselves are required to support the following two
+@@ -762,7 +762,7 @@
+ 
+    Return the iterator object itself.  This is required to allow both containers
+    and iterators to be used with the :keyword:`for` and :keyword:`in` statements.
+-   This method corresponds to the :attr:`tp_iter` slot of the type structure for
++   This method corresponds to the :c:member:`~PyTypeObject.tp_iter` slot of the type structure for
+    Python objects in the Python/C API.
+ 
+ 
+@@ -770,7 +770,7 @@
+ 
+    Return the next item from the container.  If there are no further items, raise
+    the :exc:`StopIteration` exception.  This method corresponds to the
+-   :attr:`tp_iternext` slot of the type structure for Python objects in the
++   :c:member:`~PyTypeObject.tp_iternext` slot of the type structure for Python objects in the
+    Python/C API.
+ 
+ Python defines several iterator objects to support iteration over general and
+@@ -871,11 +871,11 @@
+ +--------------------------+--------------------------------+----------+
+ | ``max(s)``               | largest item of *s*            |          |
+ +--------------------------+--------------------------------+----------+
+-| ``s.index(x[, i[, j]])`` | index of the first occurence   | \(8)     |
++| ``s.index(x[, i[, j]])`` | index of the first occurrence  | \(8)     |
+ |                          | of *x* in *s* (at or after     |          |
+ |                          | index *i* and before index *j*)|          |
+ +--------------------------+--------------------------------+----------+
+-| ``s.count(x)``           | total number of occurences of  |          |
++| ``s.count(x)``           | total number of occurrences of |          |
+ |                          | *x* in *s*                     |          |
+ +--------------------------+--------------------------------+----------+
+ 
+diff -r d047928ae3f6 Doc/library/subprocess.rst
+--- a/Doc/library/subprocess.rst
++++ b/Doc/library/subprocess.rst
+@@ -290,8 +290,12 @@
+    .. index::
+       single: universal newlines; subprocess module
+ 
+-   If *universal_newlines* is ``True``, the file objects *stdin*, *stdout* and
+-   *stderr* will be opened as text streams in :term:`universal newlines` mode
++   If *universal_newlines* is ``False`` the file objects *stdin*, *stdout* and
++   *stderr* will be opened as binary streams, and no line ending conversion is
++   done.
++
++   If *universal_newlines* is ``True``, these file objects
++   will be opened as text streams in :term:`universal newlines` mode
+    using the encoding returned by :func:`locale.getpreferredencoding(False)
+    <locale.getpreferredencoding>`.  For *stdin*, line ending characters
+    ``'\n'`` in the input will be converted to the default line separator
+@@ -537,7 +541,8 @@
+ 
+    If *universal_newlines* is ``True``, the file objects *stdin*, *stdout*
+    and *stderr* are opened as text streams in universal newlines mode, as
+-   described above in :ref:`frequently-used-arguments`.
++   described above in :ref:`frequently-used-arguments`, otherwise they are
++   opened as binary streams.
+ 
+    If given, *startupinfo* will be a :class:`STARTUPINFO` object, which is
+    passed to the underlying ``CreateProcess`` function.
 diff -r d047928ae3f6 Doc/library/sys.rst
 --- a/Doc/library/sys.rst
 +++ b/Doc/library/sys.rst
@@ -326,6 +3251,90 @@
  
  
  .. data:: path
+diff -r d047928ae3f6 Doc/library/test.rst
+--- a/Doc/library/test.rst
++++ b/Doc/library/test.rst
+@@ -362,31 +362,65 @@
+       New optional arguments *filters* and *quiet*.
+ 
+ 
+-.. function:: captured_stdout()
++.. function:: captured_stdin()
++              captured_stdout()
++              captured_stderr()
+ 
+-   A context manager that runs the :keyword:`with` statement body using a
+-   :class:`io.StringIO` object as sys.stdout.  That object can be retrieved
+-   using the ``as`` clause of the :keyword:`with` statement.
++   A context managers that temporarily replaces the named stream with
++   :class:`io.StringIO` object.
+ 
+-   Example use::
++   Example use with output streams::
+ 
+-      with captured_stdout() as s:
++      with captured_stdout() as stdout, captured_stderr() as stderr:
+           print("hello")
+-      assert s.getvalue() == "hello\n"
++          print("error", file=sys.stderr)
++      assert stdout.getvalue() == "hello\n"
++      assert stderr.getvalue() == "error\n"
+ 
++   Example use with input stream::
+ 
+-.. function:: temp_cwd(name='tempcwd', quiet=False, path=None)
++      with captured_stdin() as stdin:
++          stdin.write('hello\n')
++          stdin.seek(0)
++          # call test code that consumes from sys.stdin
++          captured = input()
++      self.assertEqual(captured, "hello")
++
++
++.. function:: temp_dir(path=None, quiet=False)
++
++   A context manager that creates a temporary directory at *path* and
++   yields the directory.
++
++   If *path* is None, the temporary directory is created using
++   :func:`tempfile.mkdtemp`.  If *quiet* is ``False``, the context manager
++   raises an exception on error.  Otherwise, if *path* is specified and
++   cannot be created, only a warning is issued.
++
++
++.. function:: change_cwd(path, quiet=False)
+ 
+    A context manager that temporarily changes the current working
+-   directory (CWD).
++   directory to *path* and yields the directory.
+ 
+-   An existing path may be provided as *path*, in which case this function
+-   makes no changes to the file system.
++   If *quiet* is ``False``, the context manager raises an exception
++   on error.  Otherwise, it issues only a warning and keeps the current
++   working directory the same.
+ 
+-   Otherwise, the new CWD is created in the current directory and it's named
+-   *name*.  If *quiet* is ``False`` and it's not possible to create or
+-   change the CWD, an error is raised.  If it's ``True``, only a warning
+-   is raised and the original CWD is used.
++
++.. function:: temp_cwd(name='tempcwd', quiet=False)
++
++   A context manager that temporarily creates a new directory and
++   changes the current working directory (CWD).
++
++   The context manager creates a temporary directory in the current
++   directory with name *name* before temporarily changing the current
++   working directory.  If *name* is None, the temporary directory is
++   created using :func:`tempfile.mkdtemp`.
++
++   If *quiet* is ``False`` and it is not possible to create or change
++   the CWD, an error is raised.  Otherwise, only a warning is raised
++   and the original CWD is used.
+ 
+ 
+ .. function:: temp_umask(umask)
 diff -r d047928ae3f6 Doc/library/unittest.mock.rst
 --- a/Doc/library/unittest.mock.rst
 +++ b/Doc/library/unittest.mock.rst
@@ -338,6 +3347,48 @@
  
          An example of a mock that raises an exception (to test exception
          handling of an API):
+diff -r d047928ae3f6 Doc/library/unittest.rst
+--- a/Doc/library/unittest.rst
++++ b/Doc/library/unittest.rst
+@@ -873,7 +873,7 @@
+       a regular expression object or a string containing a regular expression
+       suitable for use by :func:`re.search`.  Examples::
+ 
+-         self.assertRaisesRegex(ValueError, 'invalid literal for.*XYZ$',
++         self.assertRaisesRegex(ValueError, "invalid literal for.*XYZ'$",
+                                 int, 'XYZ')
+ 
+       or::
+@@ -897,25 +897,25 @@
+       Test that a warning is triggered when *callable* is called with any
+       positional or keyword arguments that are also passed to
+       :meth:`assertWarns`.  The test passes if *warning* is triggered and
+-      fails if it isn't.  Also, any unexpected exception is an error.
++      fails if it isn't.  Any exception is an error.
+       To catch any of a group of warnings, a tuple containing the warning
+       classes may be passed as *warnings*.
+ 
+       If only the *warning* and possibly the *msg* arguments are given,
+-      returns a context manager so that the code under test can be written
++      return a context manager so that the code under test can be written
+       inline rather than as a function::
+ 
+          with self.assertWarns(SomeWarning):
+              do_something()
+ 
+-      When used as a context manager, :meth:`assertRaises` accepts the
++      When used as a context manager, :meth:`assertWarns` accepts the
+       additional keyword argument *msg*.
+ 
+       The context manager will store the caught warning object in its
+       :attr:`warning` attribute, and the source line which triggered the
+       warnings in the :attr:`filename` and :attr:`lineno` attributes.
+       This can be useful if the intention is to perform additional checks
+-      on the exception raised::
++      on the warning caught::
+ 
+          with self.assertWarns(SomeWarning) as cm:
+              do_something()
 diff -r d047928ae3f6 Doc/library/urllib.request.rst
 --- a/Doc/library/urllib.request.rst
 +++ b/Doc/library/urllib.request.rst
@@ -350,6 +3401,234 @@
  
     Open the URL *url*, which can be either a string or a
     :class:`Request` object.
+diff -r d047928ae3f6 Doc/library/venv.rst
+--- a/Doc/library/venv.rst
++++ b/Doc/library/venv.rst
+@@ -11,7 +11,7 @@
+ 
+ .. versionadded:: 3.3
+ 
+-**Source code:** :source:`Lib/venv.py`
++**Source code:** :source:`Lib/venv`
+ 
+ --------------
+ 
+@@ -125,11 +125,13 @@
+         :meth:`create_configuration`, :meth:`setup_python`,
+         :meth:`setup_scripts` and :meth:`post_setup` can be overridden.
+ 
+-    .. method:: create_directories(env_dir)
++    .. method:: ensure_directories(env_dir)
+ 
+         Creates the environment directory and all necessary directories, and
+         returns a context object.  This is just a holder for attributes (such as
+-        paths), for use by the other methods.
++        paths), for use by the other methods. The directories are allowed to
++        exist already, as long as either ``clear`` or ``upgrade`` were
++        specified to allow operating on an existing environment directory.
+ 
+     .. method:: create_configuration(context)
+ 
+@@ -138,7 +140,10 @@
+     .. method:: setup_python(context)
+ 
+         Creates a copy of the Python executable (and, under Windows, DLLs) in
+-        the environment.
++        the environment. On a POSIX system, if a specific executable
++        ``python3.x`` was used, symlinks to ``python`` and ``python3`` will be
++        created pointing to that executable, unless files with those names
++        already exist.
+ 
+     .. method:: setup_scripts(context)
+ 
+@@ -175,6 +180,8 @@
+         * ``__VENV_PYTHON__`` is replaced with the absolute path of the
+           environment's executable.
+ 
++        The directories are allowed to exist (for when an existing environment
++        is being upgraded).
+ 
+ There is also a module-level convenience function:
+ 
+@@ -187,7 +194,7 @@
+ --------------------------------------
+ 
+ The following script shows how to extend :class:`EnvBuilder` by implementing a
+-subclass which installs Distribute and pip into a created venv::
++subclass which installs setuptools and pip into a created venv::
+ 
+     import os
+     import os.path
+@@ -198,16 +205,16 @@
+     from urllib.request import urlretrieve
+     import venv
+ 
+-    class DistributeEnvBuilder(venv.EnvBuilder):
++    class ExtendedEnvBuilder(venv.EnvBuilder):
+         """
+-        This builder installs Distribute and pip so that you can pip or
++        This builder installs setuptools and pip so that you can pip or
+         easy_install other packages into the created environment.
+ 
+-        :param nodist: If True, Distribute is not installed into the created
+-                       environment.
++        :param nodist: If True, setuptools and pip are not installed into the
++                       created environment.
+         :param nopip: If True, pip is not installed into the created
+                       environment.
+-        :param progress: If Distribute or pip are installed, the progress of the
++        :param progress: If setuptools or pip are installed, the progress of the
+                          installation can be monitored by passing a progress
+                          callable. If specified, it is called with two
+                          arguments: a string indicating some progress, and a
+@@ -237,9 +244,11 @@
+             :param context: The information for the environment creation request
+                             being processed.
+             """
++            os.environ['VIRTUAL_ENV'] = context.env_dir
+             if not self.nodist:
+-                self.install_distribute(context)
+-            if not self.nopip:
++                self.install_setuptools(context)
++            # Can't install pip without setuptools
++            if not self.nopip and not self.nodist:
+                 self.install_pip(context)
+ 
+         def reader(self, stream, context):
+@@ -260,6 +269,7 @@
+                     else:
+                         sys.stderr.write(s.decode('utf-8'))
+                     sys.stderr.flush()
++            stream.close()
+ 
+         def install_script(self, context, name, url):
+             _, _, path, _, _, _ = urlparse(url)
+@@ -269,10 +279,14 @@
+             # Download script into the env's binaries folder
+             urlretrieve(url, distpath)
+             progress = self.progress
++            if self.verbose:
++                term = '\n'
++            else:
++                term = ''
+             if progress is not None:
+-                progress('Installing %s' %name, 'main')
++                progress('Installing %s ...%s' % (name, term), 'main')
+             else:
+-                sys.stderr.write('Installing %s ' % name)
++                sys.stderr.write('Installing %s ...%s' % (name, term))
+                 sys.stderr.flush()
+             # Install in the env
+             args = [context.env_exe, fn]
+@@ -291,17 +305,17 @@
+             # Clean up - no longer needed
+             os.unlink(distpath)
+ 
+-        def install_distribute(self, context):
++        def install_setuptools(self, context):
+             """
+-            Install Distribute in the environment.
++            Install setuptools in the environment.
+ 
+             :param context: The information for the environment creation request
+                             being processed.
+             """
+-            url = 'http://python-distribute.org/distribute_setup.py'
+-            self.install_script(context, 'distribute', url)
+-            # clear up the distribute archive which gets downloaded
+-            pred = lambda o: o.startswith('distribute-') and o.endswith('.tar.gz')
++            url = 'https://bitbucket.org/pypa/setuptools/downloads/ez_setup.py'
++            self.install_script(context, 'setuptools', url)
++            # clear up the setuptools archive which gets downloaded
++            pred = lambda o: o.startswith('setuptools-') and o.endswith('.tar.gz')
+             files = filter(pred, os.listdir(context.bin_path))
+             for f in files:
+                 f = os.path.join(context.bin_path, f)
+@@ -336,10 +350,10 @@
+                                                          'directories.')
+             parser.add_argument('dirs', metavar='ENV_DIR', nargs='+',
+                                 help='A directory to create the environment in.')
+-            parser.add_argument('--no-distribute', default=False,
++            parser.add_argument('--no-setuptools', default=False,
+                                 action='store_true', dest='nodist',
+-                                help="Don't install Distribute in the virtual "
+-                                     "environment.")
++                                help="Don't install setuptools or pip in the "
++                                     "virtual environment.")
+             parser.add_argument('--no-pip', default=False,
+                                 action='store_true', dest='nopip',
+                                 help="Don't install pip in the virtual "
+@@ -370,11 +384,11 @@
+             parser.add_argument('--verbose', default=False, action='store_true',
+                                 dest='verbose', help='Display the output '
+                                                    'from the scripts which '
+-                                                   'install Distribute and pip.')
++                                                   'install setuptools and pip.')
+             options = parser.parse_args(args)
+             if options.upgrade and options.clear:
+                 raise ValueError('you cannot supply --upgrade and --clear together.')
+-            builder = DistributeEnvBuilder(system_site_packages=options.system_site,
++            builder = ExtendedEnvBuilder(system_site_packages=options.system_site,
+                                            clear=options.clear,
+                                            symlinks=options.symlinks,
+                                            upgrade=options.upgrade,
+@@ -393,5 +407,6 @@
+             print('Error: %s' % e, file=sys.stderr)
+         sys.exit(rc)
+ 
++
+ This script is also available for download `online
+ <https://gist.github.com/4673395>`_.
+diff -r d047928ae3f6 Doc/library/xmlrpc.client.rst
+--- a/Doc/library/xmlrpc.client.rst
++++ b/Doc/library/xmlrpc.client.rst
+@@ -435,7 +435,7 @@
+    is a :term:`generator`; iterating over this generator yields the individual
+    results.
+ 
+-A usage example of this class follows.  The server code ::
++A usage example of this class follows.  The server code::
+ 
+    from xmlrpc.server import SimpleXMLRPCServer
+ 
+@@ -449,7 +449,7 @@
+        return x*y
+ 
+    def divide(x, y):
+-       return x/y
++       return x // y
+ 
+    # A simple server with simple arithmetic functions
+    server = SimpleXMLRPCServer(("localhost", 8000))
+diff -r d047928ae3f6 Doc/reference/datamodel.rst
+--- a/Doc/reference/datamodel.rst
++++ b/Doc/reference/datamodel.rst
+@@ -1264,10 +1264,21 @@
+ 
+    Called by built-in function :func:`hash` and for operations on members of
+    hashed collections including :class:`set`, :class:`frozenset`, and
+-   :class:`dict`.  :meth:`__hash__` should return an integer.  The only required
+-   property is that objects which compare equal have the same hash value; it is
+-   advised to somehow mix together (e.g. using exclusive or) the hash values for
+-   the components of the object that also play a part in comparison of objects.
++   :class:`dict`.  :meth:`__hash__` should return an integer.  The only
++   required property is that objects which compare equal have the same hash
++   value; it is advised to somehow mix together (e.g. using exclusive or) the
++   hash values for the components of the object that also play a part in
++   comparison of objects.
++
++   .. note::
++
++     :func:`hash` truncates the value returned from an object's custom
++     :meth:`__hash__` method to the size of a :c:type:`Py_ssize_t`.  This is
++     typically 8 bytes on 64-bit builds and 4 bytes on 32-bit builds.  If an
++     object's   :meth:`__hash__` must interoperate on builds of different bit
++     sizes, be sure to check the width on all supported builds.  An easy way
++     to do this is with
++     ``python -c "import sys; print(sys.hash_info.width)"``
+ 
+    If a class does not define an :meth:`__eq__` method it should not define a
+    :meth:`__hash__` operation either; if it defines :meth:`__eq__` but not
 diff -r d047928ae3f6 Doc/reference/import.rst
 --- a/Doc/reference/import.rst
 +++ b/Doc/reference/import.rst
@@ -380,6 +3659,33 @@
  More information can be found in the :ref:`old-string-formatting` section.
  
  
+@@ -326,9 +322,11 @@
+    >>> f.write(s)
+    18
+ 
+-``f.tell()`` returns an integer giving the file object's current position in the
+-file, measured in bytes from the beginning of the file.  To change the file
+-object's position, use ``f.seek(offset, from_what)``.  The position is computed
++``f.tell()`` returns an integer giving the file object's current position in the file
++represented as number of bytes from the beginning of the file when in `binary mode` and
++an opaque number when in `text mode`.
++
++To change the file object's position, use ``f.seek(offset, from_what)``.  The position is computed
+ from adding *offset* to a reference point; the reference point is selected by
+ the *from_what* argument.  A *from_what* value of 0 measures from the beginning
+ of the file, 1 uses the current file position, and 2 uses the end of the file as
+@@ -349,7 +347,10 @@
+ 
+ In text files (those opened without a ``b`` in the mode string), only seeks
+ relative to the beginning of the file are allowed (the exception being seeking
+-to the very file end with ``seek(0, 2)``).
++to the very file end with ``seek(0, 2)``) and the only valid *offset* values are
++those returned from the ``f.tell()``, or zero. Any other *offset* value produces
++undefined behaviour.
++
+ 
+ When you're done with a file, call ``f.close()`` to close it and free up any
+ system resources taken up by the open file.  After calling ``f.close()``,
 diff -r d047928ae3f6 Doc/tutorial/introduction.rst
 --- a/Doc/tutorial/introduction.rst
 +++ b/Doc/tutorial/introduction.rst
@@ -763,7 +4069,7 @@
 +
 +   >>> word[0:2]  # characters from position 0 (included) to 2 (excluded)
 +   'Py'
-+   >>> word[2:5]  # characters from position 2 (included) to 4 (excluded)
++   >>> word[2:5]  # characters from position 2 (included) to 5 (excluded)
 +   'tho'
 +
 +Note how the start is always included, and the end always excluded.  This
@@ -1118,9 +4424,9 @@
 +   >>> x = [a, n]
 +   >>> x
 +   [['a', 'b', 'c'], [1, 2, 3]]
-+   >>> p[0]
++   >>> x[0]
 +   ['a', 'b', 'c']
-+   >>> p[0][1]
++   >>> x[0][1]
 +   'b'
  
  .. _tut-firststeps:
@@ -1141,6 +4447,701 @@
 +   same meaning with both single (``'...'``) and double (``"..."``) quotes.
 +   The only difference between the two is that within single quotes you don't
 +   need to escape ``"`` (but you have to escape ``\'``) and vice versa.
+diff -r d047928ae3f6 Doc/using/cmdline.rst
+--- a/Doc/using/cmdline.rst
++++ b/Doc/using/cmdline.rst
+@@ -269,8 +269,8 @@
+ 
+ .. cmdoption:: -u
+ 
+-   Force the binary layer of the stdin, stdout and stderr streams (which is
+-   available as their ``buffer`` attribute) to be unbuffered.  The text I/O
++   Force the binary layer of the stdout and stderr streams (which is
++   available as their ``buffer`` attribute) to be unbuffered. The text I/O
+    layer will still be line-buffered if writing to the console, or
+    block-buffered if redirected to a non-interactive file.
+ 
+@@ -562,6 +562,8 @@
+    Python traceback.  This is equivalent to :option:`-X` ``faulthandler``
+    option.
+ 
++   .. versionadded:: 3.3
++
+ 
+ Debug-mode variables
+ ~~~~~~~~~~~~~~~~~~~~
+diff -r d047928ae3f6 Doc/whatsnew/2.2.rst
+--- a/Doc/whatsnew/2.2.rst
++++ b/Doc/whatsnew/2.2.rst
+@@ -450,9 +450,9 @@
+ Python classes can define an :meth:`__iter__` method, which should create and
+ return a new iterator for the object; if the object is its own iterator, this
+ method can just return ``self``.  In particular, iterators will usually be their
+-own iterators.  Extension types implemented in C can implement a :attr:`tp_iter`
++own iterators.  Extension types implemented in C can implement a :c:member:`~PyTypeObject.tp_iter`
+ function in order to return an iterator, and extension types that want to behave
+-as iterators can define a :attr:`tp_iternext` function.
++as iterators can define a :c:member:`~PyTypeObject.tp_iternext` function.
+ 
+ So, after all this, what do iterators actually do?  They have one required
+ method, :meth:`next`, which takes no arguments and returns the next value.  When
+@@ -478,7 +478,7 @@
+ In 2.2, Python's :keyword:`for` statement no longer expects a sequence; it
+ expects something for which :func:`iter` will return an iterator. For backward
+ compatibility and convenience, an iterator is automatically constructed for
+-sequences that don't implement :meth:`__iter__` or a :attr:`tp_iter` slot, so
++sequences that don't implement :meth:`__iter__` or a :c:member:`~PyTypeObject.tp_iter` slot, so
+ ``for i in [1,2,3]`` will still work.  Wherever the Python interpreter loops
+ over a sequence, it's been changed to use the iterator protocol.  This means you
+ can do things like this::
+diff -r d047928ae3f6 Include/Python-ast.h
+--- a/Include/Python-ast.h
++++ b/Include/Python-ast.h
+@@ -42,25 +42,25 @@
+ enum _mod_kind {Module_kind=1, Interactive_kind=2, Expression_kind=3,
+                  Suite_kind=4};
+ struct _mod {
+-        enum _mod_kind kind;
+-        union {
+-                struct {
+-                        asdl_seq *body;
+-                } Module;
+-                
+-                struct {
+-                        asdl_seq *body;
+-                } Interactive;
+-                
+-                struct {
+-                        expr_ty body;
+-                } Expression;
+-                
+-                struct {
+-                        asdl_seq *body;
+-                } Suite;
+-                
+-        } v;
++    enum _mod_kind kind;
++    union {
++        struct {
++            asdl_seq *body;
++        } Module;
++        
++        struct {
++            asdl_seq *body;
++        } Interactive;
++        
++        struct {
++            expr_ty body;
++        } Expression;
++        
++        struct {
++            asdl_seq *body;
++        } Suite;
++        
++    } v;
+ };
+ 
+ enum _stmt_kind {FunctionDef_kind=1, ClassDef_kind=2, Return_kind=3,
+@@ -70,111 +70,111 @@
+                   ImportFrom_kind=15, Global_kind=16, Nonlocal_kind=17,
+                   Expr_kind=18, Pass_kind=19, Break_kind=20, Continue_kind=21};
+ struct _stmt {
+-        enum _stmt_kind kind;
+-        union {
+-                struct {
+-                        identifier name;
+-                        arguments_ty args;
+-                        asdl_seq *body;
+-                        asdl_seq *decorator_list;
+-                        expr_ty returns;
+-                } FunctionDef;
+-                
+-                struct {
+-                        identifier name;
+-                        asdl_seq *bases;
+-                        asdl_seq *keywords;
+-                        expr_ty starargs;
+-                        expr_ty kwargs;
+-                        asdl_seq *body;
+-                        asdl_seq *decorator_list;
+-                } ClassDef;
+-                
+-                struct {
+-                        expr_ty value;
+-                } Return;
+-                
+-                struct {
+-                        asdl_seq *targets;
+-                } Delete;
+-                
+-                struct {
+-                        asdl_seq *targets;
+-                        expr_ty value;
+-                } Assign;
+-                
+-                struct {
+-                        expr_ty target;
+-                        operator_ty op;
+-                        expr_ty value;
+-                } AugAssign;
+-                
+-                struct {
+-                        expr_ty target;
+-                        expr_ty iter;
+-                        asdl_seq *body;
+-                        asdl_seq *orelse;
+-                } For;
+-                
+-                struct {
+-                        expr_ty test;
+-                        asdl_seq *body;
+-                        asdl_seq *orelse;
+-                } While;
+-                
+-                struct {
+-                        expr_ty test;
+-                        asdl_seq *body;
+-                        asdl_seq *orelse;
+-                } If;
+-                
+-                struct {
+-                        asdl_seq *items;
+-                        asdl_seq *body;
+-                } With;
+-                
+-                struct {
+-                        expr_ty exc;
+-                        expr_ty cause;
+-                } Raise;
+-                
+-                struct {
+-                        asdl_seq *body;
+-                        asdl_seq *handlers;
+-                        asdl_seq *orelse;
+-                        asdl_seq *finalbody;
+-                } Try;
+-                
+-                struct {
+-                        expr_ty test;
+-                        expr_ty msg;
+-                } Assert;
+-                
+-                struct {
+-                        asdl_seq *names;
+-                } Import;
+-                
+-                struct {
+-                        identifier module;
+-                        asdl_seq *names;
+-                        int level;
+-                } ImportFrom;
+-                
+-                struct {
+-                        asdl_seq *names;
+-                } Global;
+-                
+-                struct {
+-                        asdl_seq *names;
+-                } Nonlocal;
+-                
+-                struct {
+-                        expr_ty value;
+-                } Expr;
+-                
+-        } v;
+-        int lineno;
+-        int col_offset;
++    enum _stmt_kind kind;
++    union {
++        struct {
++            identifier name;
++            arguments_ty args;
++            asdl_seq *body;
++            asdl_seq *decorator_list;
++            expr_ty returns;
++        } FunctionDef;
++        
++        struct {
++            identifier name;
++            asdl_seq *bases;
++            asdl_seq *keywords;
++            expr_ty starargs;
++            expr_ty kwargs;
++            asdl_seq *body;
++            asdl_seq *decorator_list;
++        } ClassDef;
++        
++        struct {
++            expr_ty value;
++        } Return;
++        
++        struct {
++            asdl_seq *targets;
++        } Delete;
++        
++        struct {
++            asdl_seq *targets;
++            expr_ty value;
++        } Assign;
++        
++        struct {
++            expr_ty target;
++            operator_ty op;
++            expr_ty value;
++        } AugAssign;
++        
++        struct {
++            expr_ty target;
++            expr_ty iter;
++            asdl_seq *body;
++            asdl_seq *orelse;
++        } For;
++        
++        struct {
++            expr_ty test;
++            asdl_seq *body;
++            asdl_seq *orelse;
++        } While;
++        
++        struct {
++            expr_ty test;
++            asdl_seq *body;
++            asdl_seq *orelse;
++        } If;
++        
++        struct {
++            asdl_seq *items;
++            asdl_seq *body;
++        } With;
++        
++        struct {
++            expr_ty exc;
++            expr_ty cause;
++        } Raise;
++        
++        struct {
++            asdl_seq *body;
++            asdl_seq *handlers;
++            asdl_seq *orelse;
++            asdl_seq *finalbody;
++        } Try;
++        
++        struct {
++            expr_ty test;
++            expr_ty msg;
++        } Assert;
++        
++        struct {
++            asdl_seq *names;
++        } Import;
++        
++        struct {
++            identifier module;
++            asdl_seq *names;
++            int level;
++        } ImportFrom;
++        
++        struct {
++            asdl_seq *names;
++        } Global;
++        
++        struct {
++            asdl_seq *names;
++        } Nonlocal;
++        
++        struct {
++            expr_ty value;
++        } Expr;
++        
++    } v;
++    int lineno;
++    int col_offset;
+ };
+ 
+ enum _expr_kind {BoolOp_kind=1, BinOp_kind=2, UnaryOp_kind=3, Lambda_kind=4,
+@@ -185,207 +185,207 @@
+                   Ellipsis_kind=19, Attribute_kind=20, Subscript_kind=21,
+                   Starred_kind=22, Name_kind=23, List_kind=24, Tuple_kind=25};
+ struct _expr {
+-        enum _expr_kind kind;
+-        union {
+-                struct {
+-                        boolop_ty op;
+-                        asdl_seq *values;
+-                } BoolOp;
+-                
+-                struct {
+-                        expr_ty left;
+-                        operator_ty op;
+-                        expr_ty right;
+-                } BinOp;
+-                
+-                struct {
+-                        unaryop_ty op;
+-                        expr_ty operand;
+-                } UnaryOp;
+-                
+-                struct {
+-                        arguments_ty args;
+-                        expr_ty body;
+-                } Lambda;
+-                
+-                struct {
+-                        expr_ty test;
+-                        expr_ty body;
+-                        expr_ty orelse;
+-                } IfExp;
+-                
+-                struct {
+-                        asdl_seq *keys;
+-                        asdl_seq *values;
+-                } Dict;
+-                
+-                struct {
+-                        asdl_seq *elts;
+-                } Set;
+-                
+-                struct {
+-                        expr_ty elt;
+-                        asdl_seq *generators;
+-                } ListComp;
+-                
+-                struct {
+-                        expr_ty elt;
+-                        asdl_seq *generators;
+-                } SetComp;
+-                
+-                struct {
+-                        expr_ty key;
+-                        expr_ty value;
+-                        asdl_seq *generators;
+-                } DictComp;
+-                
+-                struct {
+-                        expr_ty elt;
+-                        asdl_seq *generators;
+-                } GeneratorExp;
+-                
+-                struct {
+-                        expr_ty value;
+-                } Yield;
+-                
+-                struct {
+-                        expr_ty value;
+-                } YieldFrom;
+-                
+-                struct {
+-                        expr_ty left;
+-                        asdl_int_seq *ops;
+-                        asdl_seq *comparators;
+-                } Compare;
+-                
+-                struct {
+-                        expr_ty func;
+-                        asdl_seq *args;
+-                        asdl_seq *keywords;
+-                        expr_ty starargs;
+-                        expr_ty kwargs;
+-                } Call;
+-                
+-                struct {
+-                        object n;
+-                } Num;
+-                
+-                struct {
+-                        string s;
+-                } Str;
+-                
+-                struct {
+-                        bytes s;
+-                } Bytes;
+-                
+-                struct {
+-                        expr_ty value;
+-                        identifier attr;
+-                        expr_context_ty ctx;
+-                } Attribute;
+-                
+-                struct {
+-                        expr_ty value;
+-                        slice_ty slice;
+-                        expr_context_ty ctx;
+-                } Subscript;
+-                
+-                struct {
+-                        expr_ty value;
+-                        expr_context_ty ctx;
+-                } Starred;
+-                
+-                struct {
+-                        identifier id;
+-                        expr_context_ty ctx;
+-                } Name;
+-                
+-                struct {
+-                        asdl_seq *elts;
+-                        expr_context_ty ctx;
+-                } List;
+-                
+-                struct {
+-                        asdl_seq *elts;
+-                        expr_context_ty ctx;
+-                } Tuple;
+-                
+-        } v;
+-        int lineno;
+-        int col_offset;
++    enum _expr_kind kind;
++    union {
++        struct {
++            boolop_ty op;
++            asdl_seq *values;
++        } BoolOp;
++        
++        struct {
++            expr_ty left;
++            operator_ty op;
++            expr_ty right;
++        } BinOp;
++        
++        struct {
++            unaryop_ty op;
++            expr_ty operand;
++        } UnaryOp;
++        
++        struct {
++            arguments_ty args;
++            expr_ty body;
++        } Lambda;
++        
++        struct {
++            expr_ty test;
++            expr_ty body;
++            expr_ty orelse;
++        } IfExp;
++        
++        struct {
++            asdl_seq *keys;
++            asdl_seq *values;
++        } Dict;
++        
++        struct {
++            asdl_seq *elts;
++        } Set;
++        
++        struct {
++            expr_ty elt;
++            asdl_seq *generators;
++        } ListComp;
++        
++        struct {
++            expr_ty elt;
++            asdl_seq *generators;
++        } SetComp;
++        
++        struct {
++            expr_ty key;
++            expr_ty value;
++            asdl_seq *generators;
++        } DictComp;
++        
++        struct {
++            expr_ty elt;
++            asdl_seq *generators;
++        } GeneratorExp;
++        
++        struct {
++            expr_ty value;
++        } Yield;
++        
++        struct {
++            expr_ty value;
++        } YieldFrom;
++        
++        struct {
++            expr_ty left;
++            asdl_int_seq *ops;
++            asdl_seq *comparators;
++        } Compare;
++        
++        struct {
++            expr_ty func;
++            asdl_seq *args;
++            asdl_seq *keywords;
++            expr_ty starargs;
++            expr_ty kwargs;
++        } Call;
++        
++        struct {
++            object n;
++        } Num;
++        
++        struct {
++            string s;
++        } Str;
++        
++        struct {
++            bytes s;
++        } Bytes;
++        
++        struct {
++            expr_ty value;
++            identifier attr;
++            expr_context_ty ctx;
++        } Attribute;
++        
++        struct {
++            expr_ty value;
++            slice_ty slice;
++            expr_context_ty ctx;
++        } Subscript;
++        
++        struct {
++            expr_ty value;
++            expr_context_ty ctx;
++        } Starred;
++        
++        struct {
++            identifier id;
++            expr_context_ty ctx;
++        } Name;
++        
++        struct {
++            asdl_seq *elts;
++            expr_context_ty ctx;
++        } List;
++        
++        struct {
++            asdl_seq *elts;
++            expr_context_ty ctx;
++        } Tuple;
++        
++    } v;
++    int lineno;
++    int col_offset;
+ };
+ 
+ enum _slice_kind {Slice_kind=1, ExtSlice_kind=2, Index_kind=3};
+ struct _slice {
+-        enum _slice_kind kind;
+-        union {
+-                struct {
+-                        expr_ty lower;
+-                        expr_ty upper;
+-                        expr_ty step;
+-                } Slice;
+-                
+-                struct {
+-                        asdl_seq *dims;
+-                } ExtSlice;
+-                
+-                struct {
+-                        expr_ty value;
+-                } Index;
+-                
+-        } v;
++    enum _slice_kind kind;
++    union {
++        struct {
++            expr_ty lower;
++            expr_ty upper;
++            expr_ty step;
++        } Slice;
++        
++        struct {
++            asdl_seq *dims;
++        } ExtSlice;
++        
++        struct {
++            expr_ty value;
++        } Index;
++        
++    } v;
+ };
+ 
+ struct _comprehension {
+-        expr_ty target;
+-        expr_ty iter;
+-        asdl_seq *ifs;
++    expr_ty target;
++    expr_ty iter;
++    asdl_seq *ifs;
+ };
+ 
+ enum _excepthandler_kind {ExceptHandler_kind=1};
+ struct _excepthandler {
+-        enum _excepthandler_kind kind;
+-        union {
+-                struct {
+-                        expr_ty type;
+-                        identifier name;
+-                        asdl_seq *body;
+-                } ExceptHandler;
+-                
+-        } v;
+-        int lineno;
+-        int col_offset;
++    enum _excepthandler_kind kind;
++    union {
++        struct {
++            expr_ty type;
++            identifier name;
++            asdl_seq *body;
++        } ExceptHandler;
++        
++    } v;
++    int lineno;
++    int col_offset;
+ };
+ 
+ struct _arguments {
+-        asdl_seq *args;
+-        identifier vararg;
+-        expr_ty varargannotation;
+-        asdl_seq *kwonlyargs;
+-        identifier kwarg;
+-        expr_ty kwargannotation;
+-        asdl_seq *defaults;
+-        asdl_seq *kw_defaults;
++    asdl_seq *args;
++    identifier vararg;
++    expr_ty varargannotation;
++    asdl_seq *kwonlyargs;
++    identifier kwarg;
++    expr_ty kwargannotation;
++    asdl_seq *defaults;
++    asdl_seq *kw_defaults;
+ };
+ 
+ struct _arg {
+-        identifier arg;
+-        expr_ty annotation;
++    identifier arg;
++    expr_ty annotation;
+ };
+ 
+ struct _keyword {
+-        identifier arg;
+-        expr_ty value;
++    identifier arg;
++    expr_ty value;
+ };
+ 
+ struct _alias {
+-        identifier name;
+-        identifier asname;
++    identifier name;
++    identifier asname;
+ };
+ 
+ struct _withitem {
+-        expr_ty context_expr;
+-        expr_ty optional_vars;
++    expr_ty context_expr;
++    expr_ty optional_vars;
+ };
+ 
+ 
 diff -r d047928ae3f6 Include/patchlevel.h
 --- a/Include/patchlevel.h
 +++ b/Include/patchlevel.h
@@ -1175,6 +5176,18 @@
      /* always add new stuff to the end! */
  };
  
+diff -r d047928ae3f6 Include/pymacro.h
+--- a/Include/pymacro.h
++++ b/Include/pymacro.h
+@@ -33,7 +33,7 @@
+ 
+    Requires at GCC 3.1+ */
+ #if (defined(__GNUC__) && !defined(__STRICT_ANSI__) && \
+-    ((__GNUC__ == 3) && (__GNU_MINOR__ >= 1)) || (__GNUC__ >= 4))
++    (((__GNUC__ == 3) && (__GNU_MINOR__ >= 1)) || (__GNUC__ >= 4)))
+ /* Two gcc extensions.
+    &a[0] degrades to a pointer: a different type from an array */
+ #define Py_ARRAY_LENGTH(array) \
 diff -r d047928ae3f6 Lib/base64.py
 --- a/Lib/base64.py
 +++ b/Lib/base64.py
@@ -1207,6 +5220,61 @@
  
  
  def b32decode(s, casefold=False, map01=None):
+@@ -245,7 +245,7 @@
+     for c in s:
+         val = _b32rev.get(c)
+         if val is None:
+-            raise TypeError('Non-base32 digit found')
++            raise binascii.Error('Non-base32 digit found')
+         acc += _b32rev[c] << shift
+         shift -= 5
+         if shift < 0:
+diff -r d047928ae3f6 Lib/cgi.py
+--- a/Lib/cgi.py
++++ b/Lib/cgi.py
+@@ -699,7 +699,7 @@
+                          self.encoding, self.errors)
+             self.bytes_read += part.bytes_read
+             self.list.append(part)
+-            if self.bytes_read >= self.length:
++            if part.done or self.bytes_read >= self.length > 0:
+                 break
+         self.skip_lines()
+ 
+@@ -786,6 +786,9 @@
+             if not line:
+                 self.done = -1
+                 break
++            if delim == b"\r":
++                line = delim + line
++                delim = b""
+             if line.startswith(b"--") and last_line_lfend:
+                 strippedline = line.rstrip()
+                 if strippedline == next_boundary:
+@@ -802,6 +805,12 @@
+                 delim = b"\n"
+                 line = line[:-1]
+                 last_line_lfend = True
++            elif line.endswith(b"\r"):
++                # We may interrupt \r\n sequences if they span the 2**16
++                # byte boundary
++                delim = b"\r"
++                line = line[:-1]
++                last_line_lfend = False
+             else:
+                 delim = b""
+                 last_line_lfend = False
+diff -r d047928ae3f6 Lib/codecs.py
+--- a/Lib/codecs.py
++++ b/Lib/codecs.py
+@@ -105,6 +105,7 @@
+                     Python will use the official U+FFFD REPLACEMENT
+                     CHARACTER for the builtin Unicode codecs on
+                     decoding and '?' on encoding.
++         'surrogateescape' - replace with private codepoints U+DCnn.
+          'xmlcharrefreplace' - Replace with the appropriate XML
+                                character reference (only for encoding).
+          'backslashreplace'  - Replace with backslashed escape sequences
 diff -r d047928ae3f6 Lib/collections/__init__.py
 --- a/Lib/collections/__init__.py
 +++ b/Lib/collections/__init__.py
@@ -1279,6 +5347,42 @@
      result = namespace[typename]
      result._source = class_definition
      if verbose:
+diff -r d047928ae3f6 Lib/configparser.py
+--- a/Lib/configparser.py
++++ b/Lib/configparser.py
+@@ -191,7 +191,7 @@
+     def __init__(self, section, source=None, lineno=None):
+         msg = [repr(section), " already exists"]
+         if source is not None:
+-            message = ["While reading from ", source]
++            message = ["While reading from ", repr(source)]
+             if lineno is not None:
+                 message.append(" [line {0:2d}]".format(lineno))
+             message.append(": section ")
+@@ -217,7 +217,7 @@
+         msg = [repr(option), " in section ", repr(section),
+                " already exists"]
+         if source is not None:
+-            message = ["While reading from ", source]
++            message = ["While reading from ", repr(source)]
+             if lineno is not None:
+                 message.append(" [line {0:2d}]".format(lineno))
+             message.append(": option ")
+diff -r d047928ae3f6 Lib/csv.py
+--- a/Lib/csv.py
++++ b/Lib/csv.py
+@@ -264,8 +264,9 @@
+ 
+         # if we see an extra quote between delimiters, we've got a
+         # double quoted format
+-        dq_regexp = re.compile(r"((%(delim)s)|^)\W*%(quote)s[^%(delim)s\n]*%(quote)s[^%(delim)s\n]*%(quote)s\W*((%(delim)s)|$)" % \
+-                               {'delim':delim, 'quote':quotechar}, re.MULTILINE)
++        dq_regexp = re.compile(
++                               r"((%(delim)s)|^)\W*%(quote)s[^%(delim)s\n]*%(quote)s[^%(delim)s\n]*%(quote)s\W*((%(delim)s)|$)" % \
++                               {'delim':re.escape(delim), 'quote':quotechar}, re.MULTILINE)
+ 
+ 
+ 
 diff -r d047928ae3f6 Lib/ctypes/util.py
 --- a/Lib/ctypes/util.py
 +++ b/Lib/ctypes/util.py
@@ -1291,9 +5395,340 @@
          try:
              f = os.popen(cmd)
              try:
+diff -r d047928ae3f6 Lib/dbm/__init__.py
+--- a/Lib/dbm/__init__.py
++++ b/Lib/dbm/__init__.py
+@@ -44,6 +44,11 @@
+ 
+ error = (error, IOError)
+ 
++try:
++    from dbm import ndbm
++except ImportError:
++    ndbm = None
++
+ 
+ def open(file, flag='r', mode=0o666):
+     """Open or create database at path given by *file*.
+diff -r d047928ae3f6 Lib/decimal.py
+--- a/Lib/decimal.py
++++ b/Lib/decimal.py
+@@ -6140,7 +6140,7 @@
+ (?:\.(?P<precision>0|(?!0)\d+))?
+ (?P<type>[eEfFgGn%])?
+ \Z
+-""", re.VERBOSE)
++""", re.VERBOSE|re.DOTALL)
+ 
+ del re
+ 
+diff -r d047928ae3f6 Lib/distutils/sysconfig.py
+--- a/Lib/distutils/sysconfig.py
++++ b/Lib/distutils/sysconfig.py
+@@ -195,9 +195,15 @@
+             get_config_vars('CC', 'CXX', 'OPT', 'CFLAGS',
+                             'CCSHARED', 'LDSHARED', 'SHLIB_SUFFIX', 'AR', 'ARFLAGS')
+ 
+-        newcc = None
+         if 'CC' in os.environ:
+-            cc = os.environ['CC']
++            newcc = os.environ['CC']
++            if (sys.platform == 'darwin'
++                    and 'LDSHARED' not in os.environ
++                    and ldshared.startswith(cc)):
++                # On OS X, if CC is overridden, use that as the default
++                #       command for LDSHARED as well
++                ldshared = newcc + ldshared[len(cc):]
++            cc = newcc
+         if 'CXX' in os.environ:
+             cxx = os.environ['CXX']
+         if 'LDSHARED' in os.environ:
+diff -r d047928ae3f6 Lib/distutils/tests/test_unixccompiler.py
+--- a/Lib/distutils/tests/test_unixccompiler.py
++++ b/Lib/distutils/tests/test_unixccompiler.py
+@@ -1,7 +1,8 @@
+ """Tests for distutils.unixccompiler."""
++import os
+ import sys
+ import unittest
+-from test.support import run_unittest
++from test.support import EnvironmentVarGuard, run_unittest
+ 
+ from distutils import sysconfig
+ from distutils.unixccompiler import UnixCCompiler
+@@ -94,7 +95,6 @@
+         sysconfig.get_config_var = gcv
+         self.assertEqual(self.cc.rpath_foo(), '-Wl,--enable-new-dtags,-R/foo')
+ 
+-
+         # non-GCC GNULD
+         sys.platform = 'bar'
+         def gcv(v):
+@@ -115,6 +115,38 @@
+         sysconfig.get_config_var = gcv
+         self.assertEqual(self.cc.rpath_foo(), '-R/foo')
+ 
++    @unittest.skipUnless(sys.platform == 'darwin', 'test only relevant for OS X')
++    def test_osx_cc_overrides_ldshared(self):
++        # Issue #18080:
++        # ensure that setting CC env variable also changes default linker
++        def gcv(v):
++            if v == 'LDSHARED':
++                return 'gcc-4.2 -bundle -undefined dynamic_lookup '
++            return 'gcc-4.2'
++        sysconfig.get_config_var = gcv
++        with EnvironmentVarGuard() as env:
++            env['CC'] = 'my_cc'
++            del env['LDSHARED']
++            sysconfig.customize_compiler(self.cc)
++        self.assertEqual(self.cc.linker_so[0], 'my_cc')
++
++    @unittest.skipUnless(sys.platform == 'darwin', 'test only relevant for OS X')
++    def test_osx_explict_ldshared(self):
++        # Issue #18080:
++        # ensure that setting CC env variable does not change
++        #   explicit LDSHARED setting for linker
++        def gcv(v):
++            if v == 'LDSHARED':
++                return 'gcc-4.2 -bundle -undefined dynamic_lookup '
++            return 'gcc-4.2'
++        sysconfig.get_config_var = gcv
++        with EnvironmentVarGuard() as env:
++            env['CC'] = 'my_cc'
++            env['LDSHARED'] = 'my_ld -bundle -dynamic'
++            sysconfig.customize_compiler(self.cc)
++        self.assertEqual(self.cc.linker_so[0], 'my_ld')
++
++
+ def test_suite():
+     return unittest.makeSuite(UnixCCompilerTestCase)
+ 
+diff -r d047928ae3f6 Lib/email/_header_value_parser.py
+--- a/Lib/email/_header_value_parser.py
++++ b/Lib/email/_header_value_parser.py
+@@ -69,6 +69,7 @@
+ 
+ import re
+ import urllib   # For urllib.parse.unquote
++from string import hexdigits
+ from collections import namedtuple, OrderedDict
+ from email import _encoded_words as _ew
+ from email import errors
+@@ -392,10 +393,6 @@
+     token_type = 'unstructured'
+ 
+     def _fold(self, folded):
+-        if any(x.token_type=='encoded-word' for x in self):
+-            return self._fold_encoded(folded)
+-        # Here we can have either a pure ASCII string that may or may not
+-        # have surrogateescape encoded bytes, or a unicode string.
+         last_ew = None
+         for part in self.parts:
+             tstr = str(part)
+@@ -1389,35 +1386,6 @@
+         pos = pos + 1
+     return ''.join(vchars), ''.join([fragment[pos:]] + remainder), had_qp
+ 
+-def _decode_ew_run(value):
+-    """ Decode a run of RFC2047 encoded words.
+-
+-        _decode_ew_run(value) -> (text, value, defects)
+-
+-    Scans the supplied value for a run of tokens that look like they are RFC
+-    2047 encoded words, decodes those words into text according to RFC 2047
+-    rules (whitespace between encoded words is discarded), and returns the text
+-    and the remaining value (including any leading whitespace on the remaining
+-    value), as well as a list of any defects encountered while decoding.  The
+-    input value may not have any leading whitespace.
+-
+-    """
+-    res = []
+-    defects = []
+-    last_ws = ''
+-    while value:
+-        try:
+-            tok, ws, value = _wsp_splitter(value, 1)
+-        except ValueError:
+-            tok, ws, value = value, '', ''
+-        if not (tok.startswith('=?') and tok.endswith('?=')):
+-            return ''.join(res), last_ws + tok + ws + value, defects
+-        text, charset, lang, new_defects = _ew.decode(tok)
+-        res.append(text)
+-        defects.extend(new_defects)
+-        last_ws = ws
+-    return ''.join(res), last_ws, defects
+-
+ def get_fws(value):
+     """FWS = 1*WSP
+ 
+@@ -1443,7 +1411,8 @@
+         raise errors.HeaderParseError(
+             "expected encoded word but found {}".format(value))
+     remstr = ''.join(remainder)
+-    if remstr[:2].isdigit():
++    if len(remstr) > 1 and remstr[0] in hexdigits and remstr[1] in hexdigits:
++        # The ? after the CTE was followed by an encoded word escape (=XX).
+         rest, *remainder = remstr.split('?=', 1)
+         tok = tok + '?=' + rest
+     if len(tok.split()) > 1:
+@@ -1491,8 +1460,8 @@
+ 
+     """
+     # XXX: but what about bare CR and LF?  They might signal the start or
+-    # end of an encoded word.  YAGNI for now, since out current parsers
+-    # will never send us strings with bard CR or LF.
++    # end of an encoded word.  YAGNI for now, since our current parsers