Changeset 388 for python/vendor/current/Include

python/vendor/current/Include/Python-ast.h

-              r2
+              r388
 enum _expr_kind {BoolOp_kind=1, BinOp_kind=2, UnaryOp_kind=3, Lambda_kind=4,
                   IfExp_kind=5, Dict_kind=6, ListComp_kind=7,
                   GeneratorExp_kind=8, Yield_kind=9, Compare_kind=10,
                   Call_kind=11, Repr_kind=12, Num_kind=13, Str_kind=14,
                   Attribute_kind=15, Subscript_kind=16, Name_kind=17,
                   List_kind=18, Tuple_kind=19};
+                  IfExp_kind=5, Dict_kind=6, Set_kind=7, ListComp_kind=8,
+                  SetComp_kind=9, DictComp_kind=10, GeneratorExp_kind=11,
+                  Yield_kind=12, Compare_kind=13, Call_kind=14, Repr_kind=15,
+                  Num_kind=16, Str_kind=17, Attribute_kind=18,
+                  Subscript_kind=19, Name_kind=20, List_kind=21, Tuple_kind=22};
 struct _expr {
         enum _expr_kind kind;
 …
                 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 _Py_Dict(asdl_seq * keys, asdl_seq * values, int lineno, int
                  col_offset, PyArena *arena);
+#define Set(a0, a1, a2, a3) _Py_Set(a0, a1, a2, a3)
+expr_ty _Py_Set(asdl_seq * elts, int lineno, int col_offset, PyArena *arena);
 #define ListComp(a0, a1, a2, a3, a4) _Py_ListComp(a0, a1, a2, a3, a4)
 expr_ty _Py_ListComp(expr_ty elt, asdl_seq * generators, int lineno, int
                      col_offset, PyArena *arena);
+#define SetComp(a0, a1, a2, a3, a4) _Py_SetComp(a0, a1, a2, a3, a4)
+expr_ty _Py_SetComp(expr_ty elt, asdl_seq * generators, int lineno, int
+                    col_offset, PyArena *arena);
+#define DictComp(a0, a1, a2, a3, a4, a5) _Py_DictComp(a0, a1, a2, a3, a4, a5)
+expr_ty _Py_DictComp(expr_ty key, expr_ty value, asdl_seq * generators, int
+                     lineno, int col_offset, PyArena *arena);
 #define GeneratorExp(a0, a1, a2, a3, a4) _Py_GeneratorExp(a0, a1, a2, a3, a4)
 expr_ty _Py_GeneratorExp(expr_ty elt, asdl_seq * generators, int lineno, int

python/vendor/current/Include/Python.h

-              r2
+              r388
 #include "rangeobject.h"
 #include "stringobject.h"
+/* #include "memoryobject.h" */
+#include "memoryobject.h"
 #include "bufferobject.h"
 #include "bytesobject.h"
 …
 #include "fileobject.h"
 #include "cobject.h"
+#include "pycapsule.h"
 #include "traceback.h"
 #include "sliceobject.h"
 …
 #include "eval.h"
+#include "pyctype.h"
 #include "pystrtod.h"
 #include "pystrcmp.h"
+#include "dtoa.h"
 /* _Py_Mangle is defined in compile.c */
 …
 #define PyArg_NoArgs(v)         PyArg_Parse(v, "")
+/* Convert a possibly signed character to a nonnegative int */
+/* XXX This assumes characters are 8 bits wide */
+#ifdef __CHAR_UNSIGNED__
+#define Py_CHARMASK(c)          (c)
+#else
+/* Argument must be a char or an int in [-128, 127] or [0, 255]. */
 #define Py_CHARMASK(c)          ((unsigned char)((c) & 0xff))
-#endif
 #include "pyfpe.h"

python/vendor/current/Include/abstract.h

-              r2
+              r388
   If the programmer wants to get an item from another type of object
   that provides sequence behavior, there is no clear way to do it
   correctly.
+  correctly.
   The persistent programmer may peruse object.h and find that the
 …
   differ by the type of object being used.  Unfortunately, these
   semantics are not clearly described in the current include files.
   An abstract interface providing more consistent semantics is needed.
+  An abstract interface providing more consistent semantics is needed.
 Proposal
 …
   From the point of view of Python accessing services provided by C
   modules:
+  modules:
   - "Python module interface": this interface consist of the basic
 …
      int PyObject_Print(PyObject *o, FILE *fp, int flags);
          Print an object, o, on file, fp.  Returns -1 on
          error.  The flags argument is used to enable certain printing
+         options. The only option currently supported is Py_Print_RAW.
          (What should be said about Py_Print_RAW?)
+     Print an object, o, on file, fp.  Returns -1 on
+     error.  The flags argument is used to enable certain printing
+     options. The only option currently supported is Py_Print_RAW.
+     (What should be said about Py_Print_RAW?)
        */
 …
      int PyObject_HasAttrString(PyObject *o, char *attr_name);
          Returns 1 if o has the attribute attr_name, and 0 otherwise.
          This is equivalent to the Python expression:
+         hasattr(o,attr_name).
          This function always succeeds.
+     Returns 1 if o has the attribute attr_name, and 0 otherwise.
+     This is equivalent to the Python expression:
+     hasattr(o,attr_name).
+     This function always succeeds.
        */
 …
      PyObject* PyObject_GetAttrString(PyObject *o, char *attr_name);
          Retrieve an attributed named attr_name form object o.
          Returns the attribute value on success, or NULL on failure.
          This is the equivalent of the Python expression: o.attr_name.
+     Retrieve an attributed named attr_name form object o.
+     Returns the attribute value on success, or NULL on failure.
+     This is the equivalent of the Python expression: o.attr_name.
        */
 …
      int PyObject_HasAttr(PyObject *o, PyObject *attr_name);
          Returns 1 if o has the attribute attr_name, and 0 otherwise.
          This is equivalent to the Python expression:
+         hasattr(o,attr_name).
          This function always succeeds.
+     Returns 1 if o has the attribute attr_name, and 0 otherwise.
+     This is equivalent to the Python expression:
+     hasattr(o,attr_name).
+     This function always succeeds.
        */
 …
      PyObject* PyObject_GetAttr(PyObject *o, PyObject *attr_name);
          Retrieve an attributed named attr_name form object o.
          Returns the attribute value on success, or NULL on failure.
          This is the equivalent of the Python expression: o.attr_name.
+     Retrieve an attributed named attr_name form object o.
+     Returns the attribute value on success, or NULL on failure.
+     This is the equivalent of the Python expression: o.attr_name.
        */
 …
      int PyObject_SetAttrString(PyObject *o, char *attr_name, PyObject *v);
          Set the value of the attribute named attr_name, for object o,
          to the value, v. Returns -1 on failure.  This is
          the equivalent of the Python statement: o.attr_name=v.
+     Set the value of the attribute named attr_name, for object o,
+     to the value, v. Returns -1 on failure.  This is
+     the equivalent of the Python statement: o.attr_name=v.
        */
 …
      int PyObject_SetAttr(PyObject *o, PyObject *attr_name, PyObject *v);
          Set the value of the attribute named attr_name, for object o,
          to the value, v. Returns -1 on failure.  This is
          the equivalent of the Python statement: o.attr_name=v.
+     Set the value of the attribute named attr_name, for object o,
+     to the value, v. Returns -1 on failure.  This is
+     the equivalent of the Python statement: o.attr_name=v.
        */
 …
      int PyObject_DelAttrString(PyObject *o, char *attr_name);
          Delete attribute named attr_name, for object o. Returns
          -1 on failure.  This is the equivalent of the Python
          statement: del o.attr_name.
+     Delete attribute named attr_name, for object o. Returns
+     -1 on failure.  This is the equivalent of the Python
+     statement: del o.attr_name.
        */
 …
      int PyObject_DelAttr(PyObject *o, PyObject *attr_name);
          Delete attribute named attr_name, for object o. Returns -1
          on failure.  This is the equivalent of the Python
          statement: del o.attr_name.
+     Delete attribute named attr_name, for object o. Returns -1
+     on failure.  This is the equivalent of the Python
+     statement: del o.attr_name.
        */
 …
        /*
          Compare the values of o1 and o2 using a routine provided by
          o1, if one exists, otherwise with a routine provided by o2.
          The result of the comparison is returned in result.  Returns
          -1 on failure.  This is the equivalent of the Python
          statement: result=cmp(o1,o2).
+     Compare the values of o1 and o2 using a routine provided by
+     o1, if one exists, otherwise with a routine provided by o2.
+     The result of the comparison is returned in result.  Returns
+     -1 on failure.  This is the equivalent of the Python
+     statement: result=cmp(o1,o2).
        */
 …
      int PyObject_Compare(PyObject *o1, PyObject *o2);
          Compare the values of o1 and o2 using a routine provided by
          o1, if one exists, otherwise with a routine provided by o2.
          Returns the result of the comparison on success.  On error,
          the value returned is undefined. This is equivalent to the
          Python expression: cmp(o1,o2).
+     Compare the values of o1 and o2 using a routine provided by
+     o1, if one exists, otherwise with a routine provided by o2.
+     Returns the result of the comparison on success.  On error,
+     the value returned is undefined. This is equivalent to the
+     Python expression: cmp(o1,o2).
        */
 …
      PyObject *PyObject_Repr(PyObject *o);
          Compute the string representation of object, o.  Returns the
          string representation on success, NULL on failure.  This is
          the equivalent of the Python expression: repr(o).
          Called by the repr() built-in function and by reverse quotes.
+     Compute the string representation of object, o.  Returns the
+     string representation on success, NULL on failure.  This is
+     the equivalent of the Python expression: repr(o).
+     Called by the repr() built-in function and by reverse quotes.
        */
 …
      PyObject *PyObject_Str(PyObject *o);
          Compute the string representation of object, o.  Returns the
          string representation on success, NULL on failure.  This is
          the equivalent of the Python expression: str(o).)
          Called by the str() built-in function and by the print
          statement.
+     Compute the string representation of object, o.  Returns the
+     string representation on success, NULL on failure.  This is
+     the equivalent of the Python expression: str(o).)
+     Called by the str() built-in function and by the print
+     statement.
        */
 …
      PyObject *PyObject_Unicode(PyObject *o);
          Compute the unicode representation of object, o.  Returns the
          unicode representation on success, NULL on failure.  This is
          the equivalent of the Python expression: unistr(o).)
          Called by the unistr() built-in function.
+     Compute the unicode representation of object, o.  Returns the
+     unicode representation on success, NULL on failure.  This is
+     the equivalent of the Python expression: unistr(o).)
+     Called by the unistr() built-in function.
        */
 …
      PyAPI_FUNC(int) PyCallable_Check(PyObject *o);
          Determine if the object, o, is callable.  Return 1 if the
          object is callable and 0 otherwise.
          This function always succeeds.
+     Determine if the object, o, is callable.  Return 1 if the
+     object is callable and 0 otherwise.
+     This function always succeeds.
        */
 …
      PyAPI_FUNC(PyObject *) PyObject_Call(PyObject *callable_object,
                                          PyObject *args, PyObject *kw);
        /*
          Call a callable Python object, callable_object, with
          arguments and keywords arguments.  The 'args' argument can not be
          NULL, but the 'kw' argument can be NULL.
        */
+                                         PyObject *args, PyObject *kw);
+       /*
+     Call a callable Python object, callable_object, with
+     arguments and keywords arguments.  The 'args' argument can not be
+     NULL, but the 'kw' argument can be NULL.
+       */
      PyAPI_FUNC(PyObject *) PyObject_CallObject(PyObject *callable_object,
                                                PyObject *args);
        /*
          Call a callable Python object, callable_object, with
          arguments given by the tuple, args.  If no arguments are
          needed, then args may be NULL.  Returns the result of the
          call on success, or NULL on failure.  This is the equivalent
          of the Python expression: apply(o,args).
+     Call a callable Python object, callable_object, with
+     arguments given by the tuple, args.  If no arguments are
+     needed, then args may be NULL.  Returns the result of the
+     call on success, or NULL on failure.  This is the equivalent
+     of the Python expression: apply(o,args).
        */
 …
        /*
          Call a callable Python object, callable_object, with a
          variable number of C arguments. The C arguments are described
          using a mkvalue-style format string. The format may be NULL,
          indicating that no arguments are provided.  Returns the
          result of the call on success, or NULL on failure.  This is
          the equivalent of the Python expression: apply(o,args).
+     Call a callable Python object, callable_object, with a
+     variable number of C arguments. The C arguments are described
+     using a mkvalue-style format string. The format may be NULL,
+     indicating that no arguments are provided.  Returns the
+     result of the call on success, or NULL on failure.  This is
+     the equivalent of the Python expression: apply(o,args).
        */
 …
        /*
          Call the method named m of object o with a variable number of
          C arguments.  The C arguments are described by a mkvalue
          format string.  The format may be NULL, indicating that no
          arguments are provided. Returns the result of the call on
          success, or NULL on failure.  This is the equivalent of the
          Python expression: o.method(args).
+     Call the method named m of object o with a variable number of
+     C arguments.  The C arguments are described by a mkvalue
+     format string.  The format may be NULL, indicating that no
+     arguments are provided. Returns the result of the call on
+     success, or NULL on failure.  This is the equivalent of the
+     Python expression: o.method(args).
        */
      PyAPI_FUNC(PyObject *) _PyObject_CallFunction_SizeT(PyObject *callable,
                                                          char *format, ...);
+                                                         char *format, ...);
      PyAPI_FUNC(PyObject *) _PyObject_CallMethod_SizeT(PyObject *o,
                                                        char *name,
                                                        char *format, ...);
+                                                       char *name,
+                                                       char *format, ...);
      PyAPI_FUNC(PyObject *) PyObject_CallFunctionObjArgs(PyObject *callable,
 …
        /*
          Call a callable Python object, callable_object, with a
          variable number of C arguments.  The C arguments are provided
          as PyObject * values, terminated by a NULL.  Returns the
          result of the call on success, or NULL on failure.  This is
          the equivalent of the Python expression: apply(o,args).
+     Call a callable Python object, callable_object, with a
+     variable number of C arguments.  The C arguments are provided
+     as PyObject * values, terminated by a NULL.  Returns the
+     result of the call on success, or NULL on failure.  This is
+     the equivalent of the Python expression: apply(o,args).
        */
 …
        /*
          Call the method named m of object o with a variable number of
          C arguments.  The C arguments are provided as PyObject *
          values, terminated by NULL.  Returns the result of the call
          on success, or NULL on failure.  This is the equivalent of
          the Python expression: o.method(args).
+     Call the method named m of object o with a variable number of
+     C arguments.  The C arguments are provided as PyObject *
+     values, terminated by NULL.  Returns the result of the call
+     on success, or NULL on failure.  This is the equivalent of
+     the Python expression: o.method(args).
        */
 …
      long PyObject_Hash(PyObject *o);
          Compute and return the hash, hash_value, of an object, o.  On
          failure, return -1.  This is the equivalent of the Python
          expression: hash(o).
+     Compute and return the hash, hash_value, of an object, o.  On
+     failure, return -1.  This is the equivalent of the Python
+     expression: hash(o).
        */
 …
      int PyObject_IsTrue(PyObject *o);
          Returns 1 if the object, o, is considered to be true, 0 if o is
          considered to be false and -1 on failure. This is equivalent to the
          Python expression: not not o
+     Returns 1 if the object, o, is considered to be true, 0 if o is
+     considered to be false and -1 on failure. This is equivalent to the
+     Python expression: not not o
        */
 …
      int PyObject_Not(PyObject *o);
          Returns 0 if the object, o, is considered to be true, 1 if o is
          considered to be false and -1 on failure. This is equivalent to the
          Python expression: not o
+     Returns 0 if the object, o, is considered to be true, 1 if o is
+     considered to be false and -1 on failure. This is equivalent to the
+     Python expression: not o
        */
 …
        /*
          On success, returns a type object corresponding to the object
          type of object o. On failure, returns NULL.  This is
          equivalent to the Python expression: type(o).
+     On success, returns a type object corresponding to the object
+     type of object o. On failure, returns NULL.  This is
+     equivalent to the Python expression: type(o).
        */
 …
        /*
          Return the size of object o.  If the object, o, provides
          both sequence and mapping protocols, the sequence size is
          returned. On error, -1 is returned.  This is the equivalent
          to the Python expression: len(o).
+     Return the size of object o.  If the object, o, provides
+     both sequence and mapping protocols, the sequence size is
+     returned. On error, -1 is returned.  This is the equivalent
+     to the Python expression: len(o).
        */
 …
        /*
          Guess the size of object o using len(o) or o.__length_hint__().
          If neither of those return a non-negative value, then return the
          default value.  If one of the calls fails, this function returns -1.
+     Guess the size of object o using len(o) or o.__length_hint__().
+     If neither of those return a non-negative value, then return the
+     default value.  If one of the calls fails, this function returns -1.
        */
 …
        /*
          Return element of o corresponding to the object, key, or NULL
          on failure. This is the equivalent of the Python expression:
          o[key].
+     Return element of o corresponding to the object, key, or NULL
+     on failure. This is the equivalent of the Python expression:
+     o[key].
        */
 …
        /*
          Map the object, key, to the value, v.  Returns
          -1 on failure.  This is the equivalent of the Python
          statement: o[key]=v.
+     Map the object, key, to the value, v.  Returns
+     -1 on failure.  This is the equivalent of the Python
+     statement: o[key]=v.
        */
 …
        /*
          Remove the mapping for object, key, from the object *o.
          Returns -1 on failure.  This is equivalent to
          the Python statement: del o[key].
+     Remove the mapping for object, key, from the object *o.
+     Returns -1 on failure.  This is equivalent to
+     the Python statement: del o[key].
        */
 …
        /*
          Delete the mapping for key from *o.  Returns -1 on failure.
          This is the equivalent of the Python statement: del o[key].
+     Delete the mapping for key from *o.  Returns -1 on failure.
+     This is the equivalent of the Python statement: del o[key].
        */
      PyAPI_FUNC(int) PyObject_AsCharBuffer(PyObject *obj,
                                           const char **buffer,
                                           Py_ssize_t *buffer_len);
        /*
           Takes an arbitrary object which must support the (character,
           single segment) buffer interface and returns a pointer to a
           read-only memory location useable as character based input
           for subsequent processing.
 is returned on success.  buffer and buffer_len are only
           set in case no error occurs. Otherwise, -1 is returned and
           an exception set.
+                                          const char **buffer,
+                                          Py_ssize_t *buffer_len);
+       /*
+      Takes an arbitrary object which must support the (character,
+      single segment) buffer interface and returns a pointer to a
+      read-only memory location useable as character based input
+      for subsequent processing.
+is returned on success.  buffer and buffer_len are only
+      set in case no error occurs. Otherwise, -1 is returned and
+      an exception set.
        */
 …
      PyAPI_FUNC(int) PyObject_CheckReadBuffer(PyObject *obj);
       /*
           Checks whether an arbitrary object supports the (character,
           single segment) buffer interface.  Returns 1 on success, 0
           on failure.
+      /*
+      Checks whether an arbitrary object supports the (character,
+      single segment) buffer interface.  Returns 1 on success, 0
+      on failure.
       */
      PyAPI_FUNC(int) PyObject_AsReadBuffer(PyObject *obj,
                                           const void **buffer,
                                           Py_ssize_t *buffer_len);
        /*
           Same as PyObject_AsCharBuffer() except that this API expects
           (readable, single segment) buffer interface and returns a
           pointer to a read-only memory location which can contain
           arbitrary data.
 is returned on success.  buffer and buffer_len are only
           set in case no error occurrs.  Otherwise, -1 is returned and
           an exception set.
+                                          const void **buffer,
+                                          Py_ssize_t *buffer_len);
+       /*
+      Same as PyObject_AsCharBuffer() except that this API expects
+      (readable, single segment) buffer interface and returns a
+      pointer to a read-only memory location which can contain
+      arbitrary data.
+is returned on success.  buffer and buffer_len are only
+      set in case no error occurs.  Otherwise, -1 is returned and
+      an exception set.
        */
      PyAPI_FUNC(int) PyObject_AsWriteBuffer(PyObject *obj,
                                            void **buffer,
                                            Py_ssize_t *buffer_len);
        /*
           Takes an arbitrary object which must support the (writeable,
           single segment) buffer interface and returns a pointer to a
           writeable memory location in buffer of size buffer_len.
 is returned on success.  buffer and buffer_len are only
           set in case no error occurrs. Otherwise, -1 is returned and
           an exception set.
        */
         /* new buffer API */
+                                           void **buffer,
+                                           Py_ssize_t *buffer_len);
+       /*
+      Takes an arbitrary object which must support the (writeable,
+      single segment) buffer interface and returns a pointer to a
+      writeable memory location in buffer of size buffer_len.
+is returned on success.  buffer and buffer_len are only
+      set in case no error occurs. Otherwise, -1 is returned and
+      an exception set.
+       */
+    /* new buffer API */
 #define PyObject_CheckBuffer(obj) \
         (((obj)->ob_type->tp_as_buffer != NULL) &&                      \
          (PyType_HasFeature((obj)->ob_type, Py_TPFLAGS_HAVE_NEWBUFFER)) && \
          ((obj)->ob_type->tp_as_buffer->bf_getbuffer != NULL))
+        /* Return 1 if the getbuffer function is available, otherwise
            return 0 */
      PyAPI_FUNC(int) PyObject_GetBuffer(PyObject *obj, Py_buffer *view,
                                         int flags);
         /* This is a C-API version of the getbuffer function call.  It checks
            to make sure object has the required function pointer and issues the
+           call.  Returns -1 and raises an error on failure and returns 0 on
            success
         */
+    (((obj)->ob_type->tp_as_buffer != NULL) &&                          \
+     (PyType_HasFeature((obj)->ob_type, Py_TPFLAGS_HAVE_NEWBUFFER)) && \
+     ((obj)->ob_type->tp_as_buffer->bf_getbuffer != NULL))
+    /* Return 1 if the getbuffer function is available, otherwise
+       return 0 */
+     PyAPI_FUNC(int) PyObject_GetBuffer(PyObject *obj, Py_buffer *view,
+                                        int flags);
+    /* This is a C-API version of the getbuffer function call.  It checks
+       to make sure object has the required function pointer and issues the
+       call.  Returns -1 and raises an error on failure and returns 0 on
+       success
+    */
      PyAPI_FUNC(void *) PyBuffer_GetPointer(Py_buffer *view, Py_ssize_t *indices);
         /* Get the memory area pointed to by the indices for the buffer given.
            Note that view->ndim is the assumed size of indices
         */
+    /* Get the memory area pointed to by the indices for the buffer given.
+       Note that view->ndim is the assumed size of indices
+    */
      PyAPI_FUNC(int) PyBuffer_SizeFromFormat(const char *);
+        /* Return the implied itemsize of the data-format area from a
            struct-style description */
+    /* Return the implied itemsize of the data-format area from a
+       struct-style description */
      PyAPI_FUNC(int) PyBuffer_ToContiguous(void *buf, Py_buffer *view,
                                            Py_ssize_t len, char fort);
      PyAPI_FUNC(int) PyBuffer_FromContiguous(Py_buffer *view, void *buf,
                                              Py_ssize_t len, char fort);
         /* Copy len bytes of data from the contiguous chunk of memory
            pointed to by buf into the buffer exported by obj.  Return
 on success and return -1 and raise a PyBuffer_Error on
            error (i.e. the object does not have a buffer interface or
            it is not working).
            If fort is 'F' and the object is multi-dimensional,
            then the data will be copied into the array in
            Fortran-style (first dimension varies the fastest).  If
            fort is 'C', then the data will be copied into the array
            in C-style (last dimension varies the fastest).  If fort
            is 'A', then it does not matter and the copy will be made
            in whatever way is more efficient.
         */
+                                           Py_ssize_t len, char fort);
+     PyAPI_FUNC(int) PyBuffer_FromContiguous(Py_buffer *view, void *buf,
+                                             Py_ssize_t len, char fort);
+    /* Copy len bytes of data from the contiguous chunk of memory
+       pointed to by buf into the buffer exported by obj.  Return
+on success and return -1 and raise a PyBuffer_Error on
+       error (i.e. the object does not have a buffer interface or
+       it is not working).
+       If fort is 'F' and the object is multi-dimensional,
+       then the data will be copied into the array in
+       Fortran-style (first dimension varies the fastest).  If
+       fort is 'C', then the data will be copied into the array
+       in C-style (last dimension varies the fastest).  If fort
+       is 'A', then it does not matter and the copy will be made
+       in whatever way is more efficient.
+    */
      PyAPI_FUNC(int) PyObject_CopyData(PyObject *dest, PyObject *src);
         /* Copy the data from the src buffer to the buffer of destination
          */
+    /* Copy the data from the src buffer to the buffer of destination
+     */
      PyAPI_FUNC(int) PyBuffer_IsContiguous(Py_buffer *view, char fort);
      PyAPI_FUNC(void) PyBuffer_FillContiguousStrides(int ndims,
+                                                    Py_ssize_t *shape,
                                                     Py_ssize_t *strides,
                                                     int itemsize,
                                                     char fort);
         /*  Fill the strides array with byte-strides of a contiguous
             (Fortran-style if fort is 'F' or C-style otherwise)
             array of the given shape with the given number of bytes
             per element.
         */
+     PyAPI_FUNC(void) PyBuffer_FillContiguousStrides(int ndims,
+                                                    Py_ssize_t *shape,
+                                                    Py_ssize_t *strides,
+                                                    int itemsize,
+                                                    char fort);
+    /*  Fill the strides array with byte-strides of a contiguous
+        (Fortran-style if fort is 'F' or C-style otherwise)
+        array of the given shape with the given number of bytes
+        per element.
+    */
      PyAPI_FUNC(int) PyBuffer_FillInfo(Py_buffer *view, PyObject *o, void *buf,
                                        Py_ssize_t len, int readonly,
                                        int flags);
         /* Fills in a buffer-info structure correctly for an exporter
            that can only share a contiguous chunk of memory of
            "unsigned bytes" of the given length. Returns 0 on success
            and -1 (with raising an error) on error.
          */
+                                       Py_ssize_t len, int readonly,
+                                       int flags);
+    /* Fills in a buffer-info structure correctly for an exporter
+       that can only share a contiguous chunk of memory of
+       "unsigned bytes" of the given length. Returns 0 on success
+       and -1 (with raising an error) on error.
+     */
      PyAPI_FUNC(void) PyBuffer_Release(Py_buffer *view);
        /* Releases a Py_buffer obtained from getbuffer ParseTuple's s*.
         */
+    */
      PyAPI_FUNC(PyObject *) PyObject_Format(PyObject* obj,
                                             PyObject *format_spec);
        /*
          Takes an arbitrary object and returns the result of
          calling obj.__format__(format_spec).
+                                            PyObject *format_spec);
+       /*
+     Takes an arbitrary object and returns the result of
+     calling obj.__format__(format_spec).
        */
 …
      PyAPI_FUNC(PyObject *) PyObject_GetIter(PyObject *);
      /* Takes an object and returns an iterator for it.
         This is typically a new iterator but if the argument
         is an iterator, this returns itself. */
+    This is typically a new iterator but if the argument
+    is an iterator, this returns itself. */
 #define PyIter_Check(obj) \
     (PyType_HasFeature((obj)->ob_type, Py_TPFLAGS_HAVE_ITER) && \
+     (obj)->ob_type->tp_iternext != NULL)
+     (obj)->ob_type->tp_iternext != NULL && \
+     (obj)->ob_type->tp_iternext != &_PyObject_NextNotImplemented)
      PyAPI_FUNC(PyObject *) PyIter_Next(PyObject *);
      /* Takes an iterator object and calls its tp_iternext slot,
         returning the next value.  If the iterator is exhausted,
         this returns NULL without setting an exception.
         NULL with an exception means an error occurred. */
+    returning the next value.  If the iterator is exhausted,
+    this returns NULL without setting an exception.
+    NULL with an exception means an error occurred. */
 /*  Number Protocol:*/
 …
        /*
          Returns 1 if the object, o, provides numeric protocols, and
+         false otherwise.
          This function always succeeds.
+     Returns 1 if the object, o, provides numeric protocols, and
+     false otherwise.
+     This function always succeeds.
        */
 …
        /*
          Returns the result of adding o1 and o2, or null on failure.
          This is the equivalent of the Python expression: o1+o2.
+     Returns the result of adding o1 and o2, or null on failure.
+     This is the equivalent of the Python expression: o1+o2.
 …
        /*
          Returns the result of subtracting o2 from o1, or null on
          failure.  This is the equivalent of the Python expression:
          o1-o2.
+     Returns the result of subtracting o2 from o1, or null on
+     failure.  This is the equivalent of the Python expression:
+     o1-o2.
        */
 …
        /*
          Returns the result of multiplying o1 and o2, or null on
          failure.  This is the equivalent of the Python expression:
          o1*o2.
+     Returns the result of multiplying o1 and o2, or null on
+     failure.  This is the equivalent of the Python expression:
+     o1*o2.
 …
        /*
          Returns the result of dividing o1 by o2, or null on failure.
          This is the equivalent of the Python expression: o1/o2.
+     Returns the result of dividing o1 by o2, or null on failure.
+     This is the equivalent of the Python expression: o1/o2.
 …
        /*
          Returns the result of dividing o1 by o2 giving an integral result,
          or null on failure.
          This is the equivalent of the Python expression: o1//o2.
+     Returns the result of dividing o1 by o2 giving an integral result,
+     or null on failure.
+     This is the equivalent of the Python expression: o1//o2.
 …
        /*
          Returns the result of dividing o1 by o2 giving a float result,
          or null on failure.
          This is the equivalent of the Python expression: o1/o2.
+     Returns the result of dividing o1 by o2 giving a float result,
+     or null on failure.
+     This is the equivalent of the Python expression: o1/o2.
 …
        /*
          Returns the remainder of dividing o1 by o2, or null on
          failure.  This is the equivalent of the Python expression:
          o1%o2.
+     Returns the remainder of dividing o1 by o2, or null on
+     failure.  This is the equivalent of the Python expression:
+     o1%o2.
 …
        /*
          See the built-in function divmod.  Returns NULL on failure.
          This is the equivalent of the Python expression:
          divmod(o1,o2).
+     See the built-in function divmod.  Returns NULL on failure.
+     This is the equivalent of the Python expression:
+     divmod(o1,o2).
 …
        /*
          See the built-in function pow.  Returns NULL on failure.
          This is the equivalent of the Python expression:
          pow(o1,o2,o3), where o3 is optional.
+     See the built-in function pow.  Returns NULL on failure.
+     This is the equivalent of the Python expression:
+     pow(o1,o2,o3), where o3 is optional.
        */
 …
        /*
          Returns the negation of o on success, or null on failure.
          This is the equivalent of the Python expression: -o.
+     Returns the negation of o on success, or null on failure.
+     This is the equivalent of the Python expression: -o.
        */
 …
        /*
          Returns the (what?) of o on success, or NULL on failure.
          This is the equivalent of the Python expression: +o.
+     Returns the (what?) of o on success, or NULL on failure.
+     This is the equivalent of the Python expression: +o.
        */
 …
        /*
          Returns the absolute value of o, or null on failure.  This is
          the equivalent of the Python expression: abs(o).
+     Returns the absolute value of o, or null on failure.  This is
+     the equivalent of the Python expression: abs(o).
        */
 …
        /*
          Returns the bitwise negation of o on success, or NULL on
          failure.  This is the equivalent of the Python expression:
          ~o.
+     Returns the bitwise negation of o on success, or NULL on
+     failure.  This is the equivalent of the Python expression:
+     ~o.
 …
        /*
          Returns the result of left shifting o1 by o2 on success, or
          NULL on failure.  This is the equivalent of the Python
          expression: o1 << o2.
+     Returns the result of left shifting o1 by o2 on success, or
+     NULL on failure.  This is the equivalent of the Python
+     expression: o1 << o2.
 …
        /*
          Returns the result of right shifting o1 by o2 on success, or
          NULL on failure.  This is the equivalent of the Python
          expression: o1 >> o2.
+     Returns the result of right shifting o1 by o2 on success, or
+     NULL on failure.  This is the equivalent of the Python
+     expression: o1 >> o2.
        */
 …
        /*
          Returns the result of bitwise and of o1 and o2 on success, or
          NULL on failure. This is the equivalent of the Python
          expression: o1&o2.
+     Returns the result of bitwise and of o1 and o2 on success, or
+     NULL on failure. This is the equivalent of the Python
+     expression: o1&o2.
 …
        /*
          Returns the bitwise exclusive or of o1 by o2 on success, or
          NULL on failure.  This is the equivalent of the Python
          expression: o1^o2.
+     Returns the bitwise exclusive or of o1 by o2 on success, or
+     NULL on failure.  This is the equivalent of the Python
+     expression: o1^o2.
 …
        /*
          Returns the result of bitwise or on o1 and o2 on success, or
          NULL on failure.  This is the equivalent of the Python
          expression: o1|o2.
+     Returns the result of bitwise or on o1 and o2 on success, or
+     NULL on failure.  This is the equivalent of the Python
+     expression: o1|o2.
        */
 …
      int PyNumber_Coerce(PyObject **p1, PyObject **p2);
          This function takes the addresses of two variables of type
          PyObject*.
          If the objects pointed to by *p1 and *p2 have the same type,
          increment their reference count and return 0 (success).
          If the objects can be converted to a common numeric type,
          replace *p1 and *p2 by their converted value (with 'new'
          reference counts), and return 0.
          If no conversion is possible, or if some other error occurs,
          return -1 (failure) and don't increment the reference counts.
          The call PyNumber_Coerce(&o1, &o2) is equivalent to the Python
          statement o1, o2 = coerce(o1, o2).
+     This function takes the addresses of two variables of type
+     PyObject*.
+     If the objects pointed to by *p1 and *p2 have the same type,
+     increment their reference count and return 0 (success).
+     If the objects can be converted to a common numeric type,
+     replace *p1 and *p2 by their converted value (with 'new'
+     reference counts), and return 0.
+     If no conversion is possible, or if some other error occurs,
+     return -1 (failure) and don't increment the reference counts.
+     The call PyNumber_Coerce(&o1, &o2) is equivalent to the Python
+     statement o1, o2 = coerce(o1, o2).
        */
 …
     PyType_HasFeature((obj)->ob_type, Py_TPFLAGS_HAVE_INDEX) && \
     (obj)->ob_type->tp_as_number->nb_index != NULL)
      PyAPI_FUNC(PyObject *) PyNumber_Index(PyObject *o);
        /*
          Returns the object converted to a Python long or int
          or NULL with an error raised on failure.
+     Returns the object converted to a Python long or int
+     or NULL with an error raised on failure.
        */
 …
        /*
          Returns the Integral instance converted to an int. The
          instance is expected to be int or long or have an __int__
          method. Steals integral's reference. error_format will be
          used to create the TypeError if integral isn't actually an
          Integral instance. error_format should be a format string
          that can accept a char* naming integral's type.
+     Returns the Integral instance converted to an int. The
+     instance is expected to be int or long or have an __int__
+     method. Steals integral's reference. error_format will be
+     used to create the TypeError if integral isn't actually an
+     Integral instance. error_format should be a format string
+     that can accept a char* naming integral's type.
        */
      PyAPI_FUNC(PyObject *) _PyNumber_ConvertIntegralToInt(
              PyObject *integral,
              const char* error_format);
        /*
         Returns the object converted to Py_ssize_t by going through
         PyNumber_Index first.  If an overflow error occurs while
         converting the int-or-long to Py_ssize_t, then the second argument
         is the error-type to return.  If it is NULL, then the overflow error
         is cleared and the value is clipped.
+         PyObject *integral,
+         const char* error_format);
+       /*
+    Returns the object converted to Py_ssize_t by going through
+    PyNumber_Index first.  If an overflow error occurs while
+    converting the int-or-long to Py_ssize_t, then the second argument
+    is the error-type to return.  If it is NULL, then the overflow error
+    is cleared and the value is clipped.
        */
 …
        /*
          Returns the o converted to an integer object on success, or
          NULL on failure.  This is the equivalent of the Python
          expression: int(o).
+     Returns the o converted to an integer object on success, or
+     NULL on failure.  This is the equivalent of the Python
+     expression: int(o).
        */
 …
        /*
          Returns the o converted to a long integer object on success,
          or NULL on failure.  This is the equivalent of the Python
          expression: long(o).
+     Returns the o converted to a long integer object on success,
+     or NULL on failure.  This is the equivalent of the Python
+     expression: long(o).
        */
 …
        /*
          Returns the o converted to a float object on success, or NULL
          on failure.  This is the equivalent of the Python expression:
          float(o).
        */
+     Returns the o converted to a float object on success, or NULL
+     on failure.  This is the equivalent of the Python expression:
+     float(o).
+       */
 /*  In-place variants of (some of) the above number protocol functions */
 …
        /*
          Returns the result of adding o2 to o1, possibly in-place, or null
          on failure.  This is the equivalent of the Python expression:
          o1 += o2.
+     Returns the result of adding o2 to o1, possibly in-place, or null
+     on failure.  This is the equivalent of the Python expression:
+     o1 += o2.
        */
 …
        /*
          Returns the result of subtracting o2 from o1, possibly in-place or
          null on failure.  This is the equivalent of the Python expression:
          o1 -= o2.
+     Returns the result of subtracting o2 from o1, possibly in-place or
+     null on failure.  This is the equivalent of the Python expression:
+     o1 -= o2.
        */
 …
        /*
          Returns the result of multiplying o1 by o2, possibly in-place, or
          null on failure.  This is the equivalent of the Python expression:
          o1 *= o2.
+     Returns the result of multiplying o1 by o2, possibly in-place, or
+     null on failure.  This is the equivalent of the Python expression:
+     o1 *= o2.
        */
 …
        /*
          Returns the result of dividing o1 by o2, possibly in-place, or null
          on failure.  This is the equivalent of the Python expression:
          o1 /= o2.
+     Returns the result of dividing o1 by o2, possibly in-place, or null
+     on failure.  This is the equivalent of the Python expression:
+     o1 /= o2.
        */
      PyAPI_FUNC(PyObject *) PyNumber_InPlaceFloorDivide(PyObject *o1,
                                                        PyObject *o2);
        /*
          Returns the result of dividing o1 by o2 giving an integral result,
          possibly in-place, or null on failure.
          This is the equivalent of the Python expression:
          o1 /= o2.
+                                                       PyObject *o2);
+       /*
+     Returns the result of dividing o1 by o2 giving an integral result,
+     possibly in-place, or null on failure.
+     This is the equivalent of the Python expression:
+     o1 /= o2.
        */
      PyAPI_FUNC(PyObject *) PyNumber_InPlaceTrueDivide(PyObject *o1,
                                                       PyObject *o2);
        /*
          Returns the result of dividing o1 by o2 giving a float result,
          possibly in-place, or null on failure.
          This is the equivalent of the Python expression:
          o1 /= o2.
+                                                      PyObject *o2);
+       /*
+     Returns the result of dividing o1 by o2 giving a float result,
+     possibly in-place, or null on failure.
+     This is the equivalent of the Python expression:
+     o1 /= o2.
        */
 …
        /*
          Returns the remainder of dividing o1 by o2, possibly in-place, or
          null on failure.  This is the equivalent of the Python expression:
          o1 %= o2.
+     Returns the remainder of dividing o1 by o2, possibly in-place, or
+     null on failure.  This is the equivalent of the Python expression:
+     o1 %= o2.
        */
      PyAPI_FUNC(PyObject *) PyNumber_InPlacePower(PyObject *o1, PyObject *o2,
                                                  PyObject *o3);
        /*
          Returns the result of raising o1 to the power of o2, possibly
          in-place, or null on failure.  This is the equivalent of the Python
          expression: o1 **= o2, or pow(o1, o2, o3) if o3 is present.
+                                                 PyObject *o3);
+       /*
+     Returns the result of raising o1 to the power of o2, possibly
+     in-place, or null on failure.  This is the equivalent of the Python
+     expression: o1 **= o2, or pow(o1, o2, o3) if o3 is present.
        */
 …
        /*
          Returns the result of left shifting o1 by o2, possibly in-place, or
          null on failure.  This is the equivalent of the Python expression:
          o1 <<= o2.
+     Returns the result of left shifting o1 by o2, possibly in-place, or
+     null on failure.  This is the equivalent of the Python expression:
+     o1 <<= o2.
        */
 …
        /*
          Returns the result of right shifting o1 by o2, possibly in-place or
          null on failure.  This is the equivalent of the Python expression:
          o1 >>= o2.
+     Returns the result of right shifting o1 by o2, possibly in-place or
+     null on failure.  This is the equivalent of the Python expression:
+     o1 >>= o2.
        */
 …
        /*
          Returns the result of bitwise and of o1 and o2, possibly in-place,
          or null on failure. This is the equivalent of the Python
          expression: o1 &= o2.
+     Returns the result of bitwise and of o1 and o2, possibly in-place,
+     or null on failure. This is the equivalent of the Python
+     expression: o1 &= o2.
        */
 …
        /*
          Returns the bitwise exclusive or of o1 by o2, possibly in-place, or
          null on failure.  This is the equivalent of the Python expression:
          o1 ^= o2.
+     Returns the bitwise exclusive or of o1 by o2, possibly in-place, or
+     null on failure.  This is the equivalent of the Python expression:
+     o1 ^= o2.
        */
 …
        /*
          Returns the result of bitwise or of o1 and o2, possibly in-place,
          or null on failure.  This is the equivalent of the Python
          expression: o1 |= o2.
+     Returns the result of bitwise or of o1 and o2, possibly in-place,
+     or null on failure.  This is the equivalent of the Python
+     expression: o1 |= o2.
        */
 …
        /*
          Returns the integer n converted to a string with a base, with a base
          marker of 0b, 0o or 0x prefixed if applicable.
          If n is not an int object, it is converted with PyNumber_Index first.
+     Returns the integer n converted to a string with a base, with a base
+     marker of 0b, 0o or 0x prefixed if applicable.
+     If n is not an int object, it is converted with PyNumber_Index first.
        */
 …
        /*
          Return 1 if the object provides sequence protocol, and zero
+         otherwise.
          This function always succeeds.
+     Return 1 if the object provides sequence protocol, and zero
+     otherwise.
+     This function always succeeds.
        */
 …
        /*
          Return the size of sequence object o, or -1 on failure.
+     Return the size of sequence object o, or -1 on failure.
        */
 …
        /*
          Return the concatenation of o1 and o2 on success, and NULL on
          failure.   This is the equivalent of the Python
          expression: o1+o2.
+     Return the concatenation of o1 and o2 on success, and NULL on
+     failure.   This is the equivalent of the Python
+     expression: o1+o2.
        */
 …
        /*
          Return the result of repeating sequence object o count times,
          or NULL on failure.  This is the equivalent of the Python
          expression: o1*count.
+     Return the result of repeating sequence object o count times,
+     or NULL on failure.  This is the equivalent of the Python
+     expression: o1*count.
        */
 …
        /*
          Return the ith element of o, or NULL on failure. This is the
          equivalent of the Python expression: o[i].
+     Return the ith element of o, or NULL on failure. This is the
+     equivalent of the Python expression: o[i].
        */
 …
        /*
          Return the slice of sequence object o between i1 and i2, or
          NULL on failure. This is the equivalent of the Python
          expression: o[i1:i2].
+     Return the slice of sequence object o between i1 and i2, or
+     NULL on failure. This is the equivalent of the Python
+     expression: o[i1:i2].
        */
 …
        /*
          Assign object v to the ith element of o.  Returns
          -1 on failure.  This is the equivalent of the Python
          statement: o[i]=v.
+     Assign object v to the ith element of o.  Returns
+     -1 on failure.  This is the equivalent of the Python
+     statement: o[i]=v.
        */
 …
        /*
          Delete the ith element of object v.  Returns
          -1 on failure.  This is the equivalent of the Python
          statement: del o[i].
+     Delete the ith element of object v.  Returns
+     -1 on failure.  This is the equivalent of the Python
+     statement: del o[i].
        */
 …
        /*
          Assign the sequence object, v, to the slice in sequence
          object, o, from i1 to i2.  Returns -1 on failure. This is the
          equivalent of the Python statement: o[i1:i2]=v.
+     Assign the sequence object, v, to the slice in sequence
+     object, o, from i1 to i2.  Returns -1 on failure. This is the
+     equivalent of the Python statement: o[i1:i2]=v.
        */
 …
        /*
          Delete the slice in sequence object, o, from i1 to i2.
          Returns -1 on failure. This is the equivalent of the Python
          statement: del o[i1:i2].
+     Delete the slice in sequence object, o, from i1 to i2.
+     Returns -1 on failure. This is the equivalent of the Python
+     statement: del o[i1:i2].
        */
 …
        /*
          Returns the sequence, o, as a tuple on success, and NULL on failure.
          This is equivalent to the Python expression: tuple(o)
+     Returns the sequence, o, as a tuple on success, and NULL on failure.
+     This is equivalent to the Python expression: tuple(o)
        */
 …
      PyAPI_FUNC(PyObject *) PySequence_List(PyObject *o);
        /*
          Returns the sequence, o, as a list on success, and NULL on failure.
          This is equivalent to the Python expression: list(o)
+     Returns the sequence, o, as a list on success, and NULL on failure.
+     This is equivalent to the Python expression: list(o)
        */
      PyAPI_FUNC(PyObject *) PySequence_Fast(PyObject *o, const char* m);
        /*
          Returns the sequence, o, as a tuple, unless it's already a
          tuple or list.  Use PySequence_Fast_GET_ITEM to access the
          members of this list, and PySequence_Fast_GET_SIZE to get its length.
          Returns NULL on failure.  If the object does not support iteration,
          raises a TypeError exception with m as the message text.
+     Returns the sequence, o, as a tuple, unless it's already a
+     tuple or list.  Use PySequence_Fast_GET_ITEM to access the
+     members of this list, and PySequence_Fast_GET_SIZE to get its length.
+     Returns NULL on failure.  If the object does not support iteration,
+     raises a TypeError exception with m as the message text.
        */
 #define PySequence_Fast_GET_SIZE(o) \
         (PyList_Check(o) ? PyList_GET_SIZE(o) : PyTuple_GET_SIZE(o))
        /*
          Return the size of o, assuming that o was returned by
          PySequence_Fast and is not NULL.
+    (PyList_Check(o) ? PyList_GET_SIZE(o) : PyTuple_GET_SIZE(o))
+       /*
+     Return the size of o, assuming that o was returned by
+     PySequence_Fast and is not NULL.
        */
 …
      (PyList_Check(o) ? PyList_GET_ITEM(o, i) : PyTuple_GET_ITEM(o, i))
        /*
          Return the ith element of o, assuming that o was returned by
          PySequence_Fast, and that i is within bounds.
+     Return the ith element of o, assuming that o was returned by
+     PySequence_Fast, and that i is within bounds.
        */
 #define PySequence_ITEM(o, i)\
         ( Py_TYPE(o)->tp_as_sequence->sq_item(o, i) )
+    ( Py_TYPE(o)->tp_as_sequence->sq_item(o, i) )
        /* Assume tp_as_sequence and sq_item exist and that i does not
           need to be corrected for a negative index
        */
+      need to be corrected for a negative index
+       */
 #define PySequence_Fast_ITEMS(sf) \
         (PyList_Check(sf) ? ((PyListObject *)(sf))->ob_item \
                           : ((PyTupleObject *)(sf))->ob_item)
         /* Return a pointer to the underlying item array for
            an object retured by PySequence_Fast */
+    (PyList_Check(sf) ? ((PyListObject *)(sf))->ob_item \
+                      : ((PyTupleObject *)(sf))->ob_item)
+    /* Return a pointer to the underlying item array for
+       an object retured by PySequence_Fast */
      PyAPI_FUNC(Py_ssize_t) PySequence_Count(PyObject *o, PyObject *value);
        /*
          Return the number of occurrences on value on o, that is,
          return the number of keys for which o[key]==value.  On
          failure, return -1.  This is equivalent to the Python
          expression: o.count(value).
+     Return the number of occurrences on value on o, that is,
+     return the number of keys for which o[key]==value.  On
+     failure, return -1.  This is equivalent to the Python
+     expression: o.count(value).
        */
      PyAPI_FUNC(int) PySequence_Contains(PyObject *seq, PyObject *ob);
        /*
          Return -1 if error; 1 if ob in seq; 0 if ob not in seq.
          Use __contains__ if possible, else _PySequence_IterSearch().
+     Return -1 if error; 1 if ob in seq; 0 if ob not in seq.
+     Use __contains__ if possible, else _PySequence_IterSearch().
        */
 …
 #define PY_ITERSEARCH_CONTAINS 3
      PyAPI_FUNC(Py_ssize_t) _PySequence_IterSearch(PyObject *seq,
                                         PyObject *obj, int operation);
         /*
           Iterate over seq.  Result depends on the operation:
           PY_ITERSEARCH_COUNT:  return # of times obj appears in seq; -1 if
                 error.
           PY_ITERSEARCH_INDEX:  return 0-based index of first occurrence of
                 obj in seq; set ValueError and return -1 if none found;
                 also return -1 on error.
           PY_ITERSEARCH_CONTAINS:  return 1 if obj in seq, else 0; -1 on
                 error.
         */
+                                        PyObject *obj, int operation);
+    /*
+      Iterate over seq.  Result depends on the operation:
+      PY_ITERSEARCH_COUNT:  return # of times obj appears in seq; -1 if
+        error.
+      PY_ITERSEARCH_INDEX:  return 0-based index of first occurrence of
+        obj in seq; set ValueError and return -1 if none found;
+        also return -1 on error.
+      PY_ITERSEARCH_CONTAINS:  return 1 if obj in seq, else 0; -1 on
+        error.
+    */
 /* For DLL-level backwards compatibility */
 …
        /*
          Determine if o contains value.  If an item in o is equal to
          X, return 1, otherwise return 0.  On error, return -1.  This
          is equivalent to the Python expression: value in o.
+     Determine if o contains value.  If an item in o is equal to
+     X, return 1, otherwise return 0.  On error, return -1.  This
+     is equivalent to the Python expression: value in o.
        */
 …
        /*
          Return the first index for which o[i]=value.  On error,
          return -1.    This is equivalent to the Python
          expression: o.index(value).
+     Return the first index for which o[i]=value.  On error,
+     return -1.    This is equivalent to the Python
+     expression: o.index(value).
        */
 …
        /*
          Append o2 to o1, in-place when possible. Return the resulting
          object, which could be o1, or NULL on failure.  This is the
          equivalent of the Python expression: o1 += o2.
+     Append o2 to o1, in-place when possible. Return the resulting
+     object, which could be o1, or NULL on failure.  This is the
+     equivalent of the Python expression: o1 += o2.
        */
 …
        /*
          Repeat o1 by count, in-place when possible. Return the resulting
          object, which could be o1, or NULL on failure.  This is the
          equivalent of the Python expression: o1 *= count.
+     Repeat o1 by count, in-place when possible. Return the resulting
+     object, which could be o1, or NULL on failure.  This is the
+     equivalent of the Python expression: o1 *= count.
        */
 …
        /*
          Return 1 if the object provides mapping protocol, and zero
+         otherwise.
          This function always succeeds.
+     Return 1 if the object provides mapping protocol, and zero
+     otherwise.
+     This function always succeeds.
        */
 …
        /*
          Returns the number of keys in object o on success, and -1 on
          failure.  For objects that do not provide sequence protocol,
          this is equivalent to the Python expression: len(o).
+     Returns the number of keys in object o on success, and -1 on
+     failure.  For objects that do not provide sequence protocol,
+     this is equivalent to the Python expression: len(o).
        */
 …
      int PyMapping_DelItemString(PyObject *o, char *key);
          Remove the mapping for object, key, from the object *o.
          Returns -1 on failure.  This is equivalent to
          the Python statement: del o[key].
+     Remove the mapping for object, key, from the object *o.
+     Returns -1 on failure.  This is equivalent to
+     the Python statement: del o[key].
        */
 #define PyMapping_DelItemString(O,K) PyObject_DelItemString((O),(K))
 …
      int PyMapping_DelItem(PyObject *o, PyObject *key);
          Remove the mapping for object, key, from the object *o.
          Returns -1 on failure.  This is equivalent to
          the Python statement: del o[key].
+     Remove the mapping for object, key, from the object *o.
+     Returns -1 on failure.  This is equivalent to
+     the Python statement: del o[key].
        */
 #define PyMapping_DelItem(O,K) PyObject_DelItem((O),(K))
 …
        /*
          On success, return 1 if the mapping object has the key, key,
          and 0 otherwise.  This is equivalent to the Python expression:
+         o.has_key(key).
          This function always succeeds.
+     On success, return 1 if the mapping object has the key, key,
+     and 0 otherwise.  This is equivalent to the Python expression:
+     o.has_key(key).
+     This function always succeeds.
        */
 …
        /*
          Return 1 if the mapping object has the key, key,
          and 0 otherwise.  This is equivalent to the Python expression:
+         o.has_key(key).
          This function always succeeds.
+     Return 1 if the mapping object has the key, key,
+     and 0 otherwise.  This is equivalent to the Python expression:
+     o.has_key(key).
+     This function always succeeds.
        */
 …
      PyObject *PyMapping_Keys(PyObject *o);
          On success, return a list of the keys in object o.  On
          failure, return NULL. This is equivalent to the Python
          expression: o.keys().
+     On success, return a list of the keys in object o.  On
+     failure, return NULL. This is equivalent to the Python
+     expression: o.keys().
        */
 #define PyMapping_Keys(O) PyObject_CallMethod(O,"keys",NULL)
 …
      PyObject *PyMapping_Values(PyObject *o);
          On success, return a list of the values in object o.  On
          failure, return NULL. This is equivalent to the Python
          expression: o.values().
+     On success, return a list of the values in object o.  On
+     failure, return NULL. This is equivalent to the Python
+     expression: o.values().
        */
 #define PyMapping_Values(O) PyObject_CallMethod(O,"values",NULL)
 …
      PyObject *PyMapping_Items(PyObject *o);
          On success, return a list of the items in object o, where
          each item is a tuple containing a key-value pair.  On
          failure, return NULL. This is equivalent to the Python
          expression: o.items().
+     On success, return a list of the items in object o, where
+     each item is a tuple containing a key-value pair.  On
+     failure, return NULL. This is equivalent to the Python
+     expression: o.items().
        */
 …
        /*
          Return element of o corresponding to the object, key, or NULL
          on failure. This is the equivalent of the Python expression:
          o[key].
+     Return element of o corresponding to the object, key, or NULL
+     on failure. This is the equivalent of the Python expression:
+     o[key].
        */
 …
        /*
+         Map the object, key, to the value, v.  Returns
          -1 on failure.  This is the equivalent of the Python
          statement: o[key]=v.
+     Map the object, key, to the value, v.  Returns
+     -1 on failure.  This is the equivalent of the Python
+     statement: o[key]=v.
       */
 …
 PyAPI_FUNC(int) _PyObject_RealIsSubclass(PyObject *derived, PyObject *cls);
+/* For internal use by buffer API functions */
+PyAPI_FUNC(void) _Py_add_one_to_index_F(int nd, Py_ssize_t *index,
+                                        const Py_ssize_t *shape);
+PyAPI_FUNC(void) _Py_add_one_to_index_C(int nd, Py_ssize_t *index,
+                                        const Py_ssize_t *shape);

python/vendor/current/Include/bytes_methods.h

-              r2
+              r388
 extern const char _Py_swapcase__doc__[];
+#define FLAG_LOWER  0x01
+#define FLAG_UPPER  0x02
+#define FLAG_ALPHA  (FLAG_LOWER|FLAG_UPPER)
+#define FLAG_DIGIT  0x04
+#define FLAG_ALNUM  (FLAG_ALPHA|FLAG_DIGIT)
+#define FLAG_SPACE  0x08
+#define FLAG_XDIGIT 0x10
+extern const unsigned int _Py_ctype_table[256];
+#define ISLOWER(c) (_Py_ctype_table[Py_CHARMASK(c)] & FLAG_LOWER)
+#define ISUPPER(c) (_Py_ctype_table[Py_CHARMASK(c)] & FLAG_UPPER)
+#define ISALPHA(c) (_Py_ctype_table[Py_CHARMASK(c)] & FLAG_ALPHA)
+#define ISDIGIT(c) (_Py_ctype_table[Py_CHARMASK(c)] & FLAG_DIGIT)
+#define ISXDIGIT(c) (_Py_ctype_table[Py_CHARMASK(c)] & FLAG_XDIGIT)
+#define ISALNUM(c) (_Py_ctype_table[Py_CHARMASK(c)] & FLAG_ALNUM)
+#define ISSPACE(c) (_Py_ctype_table[Py_CHARMASK(c)] & FLAG_SPACE)
+/* These are left in for backward compatibility and will be removed
+   in 2.8/3.2 */
+#define ISLOWER(c)  Py_ISLOWER(c)
+#define ISUPPER(c)  Py_ISUPPER(c)
+#define ISALPHA(c)  Py_ISALPHA(c)
+#define ISDIGIT(c)  Py_ISDIGIT(c)
+#define ISXDIGIT(c) Py_ISXDIGIT(c)
+#define ISALNUM(c)  Py_ISALNUM(c)
+#define ISSPACE(c)  Py_ISSPACE(c)
 #undef islower
 …
 #define isspace(c) undefined_isspace(c)
+extern const unsigned char _Py_ctype_tolower[256];
+extern const unsigned char _Py_ctype_toupper[256];
+#define TOLOWER(c) (_Py_ctype_tolower[Py_CHARMASK(c)])
+#define TOUPPER(c) (_Py_ctype_toupper[Py_CHARMASK(c)])
+/* These are left in for backward compatibility and will be removed
+   in 2.8/3.2 */
+#define TOLOWER(c) Py_TOLOWER(c)
+#define TOUPPER(c) Py_TOUPPER(c)
 #undef tolower

python/vendor/current/Include/bytesobject.h

-              r2
+              r388
 #define PyBytes_DecodeEscape PyString_DecodeEscape
 #define _PyBytes_Join _PyString_Join
-#define PyBytes_Decode PyString_Decode
-#define PyBytes_Encode PyString_Encode
-#define PyBytes_AsEncodedObject PyString_AsEncodedObject
-#define PyBytes_AsEncodedString PyString_AsEncodedString
-#define PyBytes_AsDecodedObject PyString_AsDecodedObject
-#define PyBytes_AsDecodedString PyString_AsDecodedString
 #define PyBytes_AsStringAndSize PyString_AsStringAndSize
 #define _PyBytes_InsertThousandsGrouping _PyString_InsertThousandsGrouping

python/vendor/current/Include/cStringIO.h

-              r2
+              r388
   This header provides access to cStringIO objects from C.
   Functions are provided for calling cStringIO objects and
   macros are provided for testing whether you have cStringIO
+  macros are provided for testing whether you have cStringIO
   objects.
 …
 */
+#define PycStringIO_CAPSULE_NAME "cStringIO.cStringIO_CAPI"
 #define PycString_IMPORT \
   PycStringIO = (struct PycStringIO_CAPI*)PyCObject_Import("cStringIO", \
                                                            "cStringIO_CAPI")
+  PycStringIO = ((struct PycStringIO_CAPI*)PyCapsule_Import(\
+    PycStringIO_CAPSULE_NAME, 0))
 /* Basic functions to manipulate cStringIO objects from C */
 static struct PycStringIO_CAPI {
  /* Read a string from an input object.  If the last argument
     is -1, the remainder will be read.

python/vendor/current/Include/ceval.h

-              r2
+              r388
 PyAPI_FUNC(PyObject *) PyEval_CallObjectWithKeywords(
+        PyObject *, PyObject *, PyObject *);
+/* DLL-level Backwards compatibility: */
+#undef PyEval_CallObject
+PyAPI_FUNC(PyObject *) PyEval_CallObject(PyObject *, PyObject *);
+    PyObject *, PyObject *, PyObject *);
 /* Inline this */
 #define PyEval_CallObject(func,arg) \
         PyEval_CallObjectWithKeywords(func, arg, (PyObject *)NULL)
+    PyEval_CallObjectWithKeywords(func, arg, (PyObject *)NULL)
 PyAPI_FUNC(PyObject *) PyEval_CallFunction(PyObject *obj,
 …
 #define Py_EnterRecursiveCall(where)                                    \
             (_Py_MakeRecCheck(PyThreadState_GET()->recursion_depth) &&  \
              _Py_CheckRecursiveCall(where))
 #define Py_LeaveRecursiveCall()                         \
             (--PyThreadState_GET()->recursion_depth)
+            (_Py_MakeRecCheck(PyThreadState_GET()->recursion_depth) &&  \
+             _Py_CheckRecursiveCall(where))
+#define Py_LeaveRecursiveCall()                         \
+            (--PyThreadState_GET()->recursion_depth)
 PyAPI_FUNC(int) _Py_CheckRecursiveCall(char *where);
 PyAPI_DATA(int) _Py_CheckRecursionLimit;
 …
    threads to run as follows:
         ...preparations here...
         Py_BEGIN_ALLOW_THREADS
         ...blocking system call here...
         Py_END_ALLOW_THREADS
         ...interpret result here...
+    ...preparations here...
+    Py_BEGIN_ALLOW_THREADS
+    ...blocking system call here...
+    Py_END_ALLOW_THREADS
+    ...interpret result here...
    The Py_BEGIN_ALLOW_THREADS/Py_END_ALLOW_THREADS pair expands to a
 …
    a line containing Py_BLOCK_THREADS before the return, e.g.
         if (...premature_exit...) {
                 Py_BLOCK_THREADS
                 PyErr_SetFromErrno(PyExc_IOError);
                 return NULL;
+        }
+    if (...premature_exit...) {
+        Py_BLOCK_THREADS
+        PyErr_SetFromErrno(PyExc_IOError);
+        return NULL;
+    }
    An alternative is:
         Py_BLOCK_THREADS
         if (...premature_exit...) {
                 PyErr_SetFromErrno(PyExc_IOError);
                 return NULL;
+        }
         Py_UNBLOCK_THREADS
+    Py_BLOCK_THREADS
+    if (...premature_exit...) {
+        PyErr_SetFromErrno(PyExc_IOError);
+        return NULL;
+    }
+    Py_UNBLOCK_THREADS
    For convenience, that the value of 'errno' is restored across
 …
 #define Py_BEGIN_ALLOW_THREADS { \
                         PyThreadState *_save; \
                         _save = PyEval_SaveThread();
 #define Py_BLOCK_THREADS        PyEval_RestoreThread(_save);
 #define Py_UNBLOCK_THREADS      _save = PyEval_SaveThread();
 #define Py_END_ALLOW_THREADS    PyEval_RestoreThread(_save); \
+                 }
+                        PyThreadState *_save; \
+                        _save = PyEval_SaveThread();
+#define Py_BLOCK_THREADS        PyEval_RestoreThread(_save);
+#define Py_UNBLOCK_THREADS      _save = PyEval_SaveThread();
+#define Py_END_ALLOW_THREADS    PyEval_RestoreThread(_save); \
+                 }
 #else /* !WITH_THREAD */

python/vendor/current/Include/classobject.h

r2	r388
19	19	PyObject *cl_setattr;
20	20	PyObject *cl_delattr;
	21	PyObject cl_weakreflist; / List of weak references */
21	22	} PyClassObject;
22	23

python/vendor/current/Include/cobject.h

-              r2
+              r388
+/*
+   CObjects are marked Pending Deprecation as of Python 2.7.
+   The full schedule for 2.x is as follows:
+     - CObjects are marked Pending Deprecation in Python 2.7.
+     - CObjects will be marked Deprecated in Python 2.8
+       (if there is one).
+     - CObjects will be removed in Python 2.9 (if there is one).
+   Additionally, for the Python 3.x series:
+     - CObjects were marked Deprecated in Python 3.1.
+     - CObjects will be removed in Python 3.2.
+   You should switch all use of CObjects to capsules.  Capsules
+   have a safer and more consistent API.  For more information,
+   see Include/pycapsule.h, or read the "Capsules" topic in
+   the "Python/C API Reference Manual".
+   Python 2.7 no longer uses CObjects itself; all objects which
+   were formerly CObjects are now capsules.  Note that this change
+   does not by itself break binary compatibility with extensions
+   built for previous versions of Python--PyCObject_AsVoidPtr()
+   has been changed to also understand capsules.
+*/
+/* original file header comment follows: */
 /* C objects to be exported from one extension module to another.

python/vendor/current/Include/code.h

-              r2
+              r388
     PyObject *co_name;          /* string (name, for reference) */
     int co_firstlineno;         /* first source line number */
+    PyObject *co_lnotab;        /* string (encoding addr<->lineno mapping) */
+    PyObject *co_lnotab;        /* string (encoding addr<->lineno mapping) See
+                                   Objects/lnotab_notes.txt for details. */
     void *co_zombieframe;     /* for optimization only (see frameobject.c) */
+    PyObject *co_weakreflist;   /* to support weakrefs to code objects */
 } PyCodeObject;
 …
         PyObject *, PyObject *, PyObject *, PyObject *, int, PyObject *);
         /* same as struct above */
+/* Creates a new empty code object with the specified source location. */
+PyAPI_FUNC(PyCodeObject *)
+PyCode_NewEmpty(const char *filename, const char *funcname, int firstlineno);
+/* Return the line number associated with the specified bytecode index
+   in this code object.  If you just need the line number of a frame,
+   use PyFrame_GetLineNumber() instead. */
 PyAPI_FUNC(int) PyCode_Addr2Line(PyCodeObject *, int);
 …
 } PyAddrPair;
+/* Check whether lasti (an instruction offset) falls outside bounds
+   and whether it is a line number that should be traced.  Returns
+   a line number if it should be traced or -1 if the line should not.
+   If lasti is not within bounds, updates bounds.
+/* Update *bounds to describe the first and one-past-the-last instructions in the
+   same line as lasti.  Return the number of that line.
 */
+PyAPI_FUNC(int) PyCode_CheckLineNumber(PyCodeObject* co,
+                                       int lasti, PyAddrPair *bounds);
+PyAPI_FUNC(int) _PyCode_CheckLineNumber(PyCodeObject* co,
+                                        int lasti, PyAddrPair *bounds);
 PyAPI_FUNC(PyObject*) PyCode_Optimize(PyObject *code, PyObject* consts,

python/vendor/current/Include/codecs.h

-              r2
+              r388
 /* Unicode encoding error handling callback registry API */
 /* Register the error handling callback function error under the name
+/* Register the error handling callback function error under the given
    name. This function will be called by the codec when it encounters
    unencodable characters/undecodable bytes and doesn't know the
 …
 PyAPI_FUNC(int) PyCodec_RegisterError(const char *name, PyObject *error);
 /* Lookup the error handling callback function registered under the
    name error. As a special case NULL can be passed, in which case
+/* Lookup the error handling callback function registered under the given
+   name. As a special case NULL can be passed, in which case
    the error handling callback for "strict" will be returned. */
 PyAPI_FUNC(PyObject *) PyCodec_LookupError(const char *name);
 …
 PyAPI_FUNC(PyObject *) PyCodec_IgnoreErrors(PyObject *exc);
 /* replace the unicode error with ? or U+FFFD */
+/* replace the unicode encode error with ? or U+FFFD */
 PyAPI_FUNC(PyObject *) PyCodec_ReplaceErrors(PyObject *exc);

python/vendor/current/Include/compile.h

r2	r388
34	34	PyAPI_FUNC(PyFutureFeatures ) PyFuture_FromAST(struct _mod , const char *);
35	35
36		~~#define ERR_LATE_FUTURE \~~
37		~~"from __future__ imports must occur at the beginning of the file"~~
38	36
39	37	#ifdef __cplusplus

python/vendor/current/Include/complexobject.h

-              r2
+              r388
 PyAPI_FUNC(Py_complex) PyComplex_AsCComplex(PyObject *op);
+/* Format the object based on the format_spec, as defined in PEP 3101
+   (Advanced String Formatting). */
+PyAPI_FUNC(PyObject *) _PyComplex_FormatAdvanced(PyObject *obj,
+                                                 char *format_spec,
+                                                 Py_ssize_t format_spec_len);
 #ifdef __cplusplus
+}

python/vendor/current/Include/datetime.h

-              r2
+              r388
+ *
  * byte offset
  *  0           year     2 bytes, 1-9999
  *  2           month    1 byte, 1-12
  *  3           day      1 byte, 1-31
  *  4           hour     1 byte, 0-23
  *  5           minute   1 byte, 0-59
  *  6           second   1 byte, 0-59
  *  7           usecond  3 bytes, 0-999999
+ *  0           year     2 bytes, 1-9999
+ *  2           month    1 byte, 1-12
+ *  3           day      1 byte, 1-31
+ *  4           hour     1 byte, 0-23
+ *  5           minute   1 byte, 0-59
+ *  6           second   1 byte, 0-59
+ *  7           usecond  3 bytes, 0-999999
  * 10
  */
 …
 typedef struct
+{
         PyObject_HEAD
         long hashcode;          /* -1 when unknown */
         int days;               /* -MAX_DELTA_DAYS <= days <= MAX_DELTA_DAYS */
         int seconds;            /* 0 <= seconds < 24*3600 is invariant */
         int microseconds;       /* 0 <= microseconds < 1000000 is invariant */
+    PyObject_HEAD
+    long hashcode;              /* -1 when unknown */
+    int days;                   /* -MAX_DELTA_DAYS <= days <= MAX_DELTA_DAYS */
+    int seconds;                /* 0 <= seconds < 24*3600 is invariant */
+    int microseconds;           /* 0 <= microseconds < 1000000 is invariant */
 } PyDateTime_Delta;
 typedef struct
+{
         PyObject_HEAD           /* a pure abstract base clase */
+    PyObject_HEAD               /* a pure abstract base class */
 } PyDateTime_TZInfo;
 …
  * present if and only if hastzinfo is true.
  */
 #define _PyTZINFO_HEAD          \
         PyObject_HEAD           \
         long hashcode;          \
         char hastzinfo;         /* boolean flag */
+#define _PyTZINFO_HEAD          \
+    PyObject_HEAD               \
+    long hashcode;              \
+    char hastzinfo;             /* boolean flag */
 /* No _PyDateTime_BaseTZInfo is allocated; it's just to have something
 …
 typedef struct
+{
         _PyTZINFO_HEAD
+    _PyTZINFO_HEAD
 } _PyDateTime_BaseTZInfo;
 …
  * "without" case.
  */
 #define _PyDateTime_TIMEHEAD    \
         _PyTZINFO_HEAD          \
         unsigned char data[_PyDateTime_TIME_DATASIZE];
 typedef struct
+{
         _PyDateTime_TIMEHEAD
 } _PyDateTime_BaseTime;         /* hastzinfo false */
 typedef struct
+{
         _PyDateTime_TIMEHEAD
         PyObject *tzinfo;
 } PyDateTime_Time;              /* hastzinfo true */
+#define _PyDateTime_TIMEHEAD    \
+    _PyTZINFO_HEAD              \
+    unsigned char data[_PyDateTime_TIME_DATASIZE];
+typedef struct
+{
+    _PyDateTime_TIMEHEAD
+} _PyDateTime_BaseTime;         /* hastzinfo false */
+typedef struct
+{
+    _PyDateTime_TIMEHEAD
+    PyObject *tzinfo;
+} PyDateTime_Time;              /* hastzinfo true */
 …
 typedef struct
+{
         _PyTZINFO_HEAD
         unsigned char data[_PyDateTime_DATE_DATASIZE];
+    _PyTZINFO_HEAD
+    unsigned char data[_PyDateTime_DATE_DATASIZE];
 } PyDateTime_Date;
 #define _PyDateTime_DATETIMEHEAD        \
         _PyTZINFO_HEAD                  \
         unsigned char data[_PyDateTime_DATETIME_DATASIZE];
 typedef struct
+{
         _PyDateTime_DATETIMEHEAD
 } _PyDateTime_BaseDateTime;     /* hastzinfo false */
 typedef struct
+{
         _PyDateTime_DATETIMEHEAD
         PyObject *tzinfo;
 } PyDateTime_DateTime;          /* hastzinfo true */
+#define _PyDateTime_DATETIMEHEAD        \
+    _PyTZINFO_HEAD                      \
+    unsigned char data[_PyDateTime_DATETIME_DATASIZE];
+typedef struct
+{
+    _PyDateTime_DATETIMEHEAD
+} _PyDateTime_BaseDateTime;     /* hastzinfo false */
+typedef struct
+{
+    _PyDateTime_DATETIMEHEAD
+    PyObject *tzinfo;
+} PyDateTime_DateTime;          /* hastzinfo true */
 /* Apply for date and datetime instances. */
 #define PyDateTime_GET_YEAR(o)     ((((PyDateTime_Date*)o)->data[0] << 8) | \
                                      ((PyDateTime_Date*)o)->data[1])
+                     ((PyDateTime_Date*)o)->data[1])
 #define PyDateTime_GET_MONTH(o)    (((PyDateTime_Date*)o)->data[2])
 #define PyDateTime_GET_DAY(o)      (((PyDateTime_Date*)o)->data[3])
 …
 #define PyDateTime_DATE_GET_MINUTE(o)      (((PyDateTime_DateTime*)o)->data[5])
 #define PyDateTime_DATE_GET_SECOND(o)      (((PyDateTime_DateTime*)o)->data[6])
 #define PyDateTime_DATE_GET_MICROSECOND(o)              \
         ((((PyDateTime_DateTime*)o)->data[7] << 16) |   \
          (((PyDateTime_DateTime*)o)->data[8] << 8)  |   \
           ((PyDateTime_DateTime*)o)->data[9])
+#define PyDateTime_DATE_GET_MICROSECOND(o)              \
+    ((((PyDateTime_DateTime*)o)->data[7] << 16) |       \
+     (((PyDateTime_DateTime*)o)->data[8] << 8)  |       \
+      ((PyDateTime_DateTime*)o)->data[9])
 /* Apply for time instances. */
 …
 #define PyDateTime_TIME_GET_MINUTE(o)      (((PyDateTime_Time*)o)->data[1])
 #define PyDateTime_TIME_GET_SECOND(o)      (((PyDateTime_Time*)o)->data[2])
 #define PyDateTime_TIME_GET_MICROSECOND(o)              \
         ((((PyDateTime_Time*)o)->data[3] << 16) |       \
          (((PyDateTime_Time*)o)->data[4] << 8)  |       \
           ((PyDateTime_Time*)o)->data[5])
+#define PyDateTime_TIME_GET_MICROSECOND(o)              \
+    ((((PyDateTime_Time*)o)->data[3] << 16) |           \
+     (((PyDateTime_Time*)o)->data[4] << 8)  |           \
+      ((PyDateTime_Time*)o)->data[5])
 …
     PyObject *(*Date_FromDate)(int, int, int, PyTypeObject*);
     PyObject *(*DateTime_FromDateAndTime)(int, int, int, int, int, int, int,
             PyObject*, PyTypeObject*);
+        PyObject*, PyTypeObject*);
     PyObject *(*Time_FromTime)(int, int, int, int, PyObject*, PyTypeObject*);
     PyObject *(*Delta_FromDelta)(int, int, int, int, PyTypeObject*);
 …
 } PyDateTime_CAPI;
+#define PyDateTime_CAPSULE_NAME "datetime.datetime_CAPI"
 /* "magic" constant used to partially protect against developer mistakes. */
 …
 /* Define global variable for the C API and a macro for setting it. */
 static PyDateTime_CAPI *PyDateTimeAPI;
+static PyDateTime_CAPI *PyDateTimeAPI = NULL;
 #define PyDateTime_IMPORT \
+        PyDateTimeAPI = (PyDateTime_CAPI*) PyCObject_Import("datetime", \
+                                                            "datetime_CAPI")
+/* This macro would be used if PyCObject_ImportEx() was created.
+#define PyDateTime_IMPORT \
+        PyDateTimeAPI = (PyDateTime_CAPI*) PyCObject_ImportEx("datetime", \
+                                                            "datetime_CAPI", \
+                                                            DATETIME_API_MAGIC)
+*/
+    PyDateTimeAPI = (PyDateTime_CAPI *)PyCapsule_Import(PyDateTime_CAPSULE_NAME, 0)
 /* Macros for type checking when not building the Python core. */
 …
 /* Macros for accessing constructors in a simplified fashion. */
 #define PyDate_FromDate(year, month, day) \
         PyDateTimeAPI->Date_FromDate(year, month, day, PyDateTimeAPI->DateType)
+    PyDateTimeAPI->Date_FromDate(year, month, day, PyDateTimeAPI->DateType)
 #define PyDateTime_FromDateAndTime(year, month, day, hour, min, sec, usec) \
         PyDateTimeAPI->DateTime_FromDateAndTime(year, month, day, hour, \
                 min, sec, usec, Py_None, PyDateTimeAPI->DateTimeType)
+    PyDateTimeAPI->DateTime_FromDateAndTime(year, month, day, hour, \
+        min, sec, usec, Py_None, PyDateTimeAPI->DateTimeType)
 #define PyTime_FromTime(hour, minute, second, usecond) \
         PyDateTimeAPI->Time_FromTime(hour, minute, second, usecond, \
                 Py_None, PyDateTimeAPI->TimeType)
+    PyDateTimeAPI->Time_FromTime(hour, minute, second, usecond, \
+        Py_None, PyDateTimeAPI->TimeType)
 #define PyDelta_FromDSU(days, seconds, useconds) \
         PyDateTimeAPI->Delta_FromDelta(days, seconds, useconds, 1, \
                 PyDateTimeAPI->DeltaType)
+    PyDateTimeAPI->Delta_FromDelta(days, seconds, useconds, 1, \
+        PyDateTimeAPI->DeltaType)
 /* Macros supporting the DB API. */
 #define PyDateTime_FromTimestamp(args) \
         PyDateTimeAPI->DateTime_FromTimestamp( \
                 (PyObject*) (PyDateTimeAPI->DateTimeType), args, NULL)
+    PyDateTimeAPI->DateTime_FromTimestamp( \
+        (PyObject*) (PyDateTimeAPI->DateTimeType), args, NULL)
 #define PyDate_FromTimestamp(args) \
         PyDateTimeAPI->Date_FromTimestamp( \
                 (PyObject*) (PyDateTimeAPI->DateType), args)
 #endif  /* Py_BUILD_CORE */
+    PyDateTimeAPI->Date_FromTimestamp( \
+        (PyObject*) (PyDateTimeAPI->DateType), args)
+#endif  /* Py_BUILD_CORE */
 #ifdef __cplusplus

python/vendor/current/Include/descrobject.h

-              r2
+              r388
 typedef struct PyGetSetDef {
         char *name;
         getter get;
         setter set;
         char *doc;
         void *closure;
+    char *name;
+    getter get;
+    setter set;
+    char *doc;
+    void *closure;
 } PyGetSetDef;
 typedef PyObject *(*wrapperfunc)(PyObject *self, PyObject *args,
                                  void *wrapped);
+                                 void *wrapped);
 typedef PyObject *(*wrapperfunc_kwds)(PyObject *self, PyObject *args,
                                       void *wrapped, PyObject *kwds);
+                                      void *wrapped, PyObject *kwds);
 struct wrapperbase {
         char *name;
         int offset;
         void *function;
         wrapperfunc wrapper;
         char *doc;
         int flags;
         PyObject *name_strobj;
+    char *name;
+    int offset;
+    void *function;
+    wrapperfunc wrapper;
+    char *doc;
+    int flags;
+    PyObject *name_strobj;
 };
 …
 #define PyDescr_COMMON \
         PyObject_HEAD \
         PyTypeObject *d_type; \
         PyObject *d_name
+    PyObject_HEAD \
+    PyTypeObject *d_type; \
+    PyObject *d_name
 typedef struct {
         PyDescr_COMMON;
+    PyDescr_COMMON;
 } PyDescrObject;
 typedef struct {
         PyDescr_COMMON;
         PyMethodDef *d_method;
+    PyDescr_COMMON;
+    PyMethodDef *d_method;
 } PyMethodDescrObject;
 typedef struct {
         PyDescr_COMMON;
         struct PyMemberDef *d_member;
+    PyDescr_COMMON;
+    struct PyMemberDef *d_member;
 } PyMemberDescrObject;
 typedef struct {
         PyDescr_COMMON;
         PyGetSetDef *d_getset;
+    PyDescr_COMMON;
+    PyGetSetDef *d_getset;
 } PyGetSetDescrObject;
 typedef struct {
         PyDescr_COMMON;
         struct wrapperbase *d_base;
         void *d_wrapped; /* This can be any function pointer */
+    PyDescr_COMMON;
+    struct wrapperbase *d_base;
+    void *d_wrapped; /* This can be any function pointer */
 } PyWrapperDescrObject;
 …
 PyAPI_FUNC(PyObject *) PyDescr_NewClassMethod(PyTypeObject *, PyMethodDef *);
 PyAPI_FUNC(PyObject *) PyDescr_NewMember(PyTypeObject *,
                                                struct PyMemberDef *);
+                                               struct PyMemberDef *);
 PyAPI_FUNC(PyObject *) PyDescr_NewGetSet(PyTypeObject *,
                                                struct PyGetSetDef *);
+                                               struct PyGetSetDef *);
 PyAPI_FUNC(PyObject *) PyDescr_NewWrapper(PyTypeObject *,
                                                 struct wrapperbase *, void *);
+                                                struct wrapperbase *, void *);
 #define PyDescr_IsData(d) (Py_TYPE(d)->tp_descr_set != NULL)

python/vendor/current/Include/dictobject.h

-              r2
+              r388
 typedef struct {
         /* Cached hash code of me_key.  Note that hash codes are C longs.
          * We have to use Py_ssize_t instead because dict_popitem() abuses
          * me_hash to hold a search finger.
          */
         Py_ssize_t me_hash;
         PyObject *me_key;
         PyObject *me_value;
+    /* Cached hash code of me_key.  Note that hash codes are C longs.
+     * We have to use Py_ssize_t instead because dict_popitem() abuses
+     * me_hash to hold a search finger.
+     */
+    Py_ssize_t me_hash;
+    PyObject *me_key;
+    PyObject *me_value;
 } PyDictEntry;
 …
 typedef struct _dictobject PyDictObject;
 struct _dictobject {
         PyObject_HEAD
         Py_ssize_t ma_fill;  /* # Active + # Dummy */
         Py_ssize_t ma_used;  /* # Active */
+    PyObject_HEAD
+    Py_ssize_t ma_fill;  /* # Active + # Dummy */
+    Py_ssize_t ma_used;  /* # Active */
         /* The table contains ma_mask + 1 slots, and that's a power of 2.
          * We store the mask instead of the size because the mask is more
          * frequently needed.
          */
         Py_ssize_t ma_mask;
+    /* The table contains ma_mask + 1 slots, and that's a power of 2.
+     * We store the mask instead of the size because the mask is more
+     * frequently needed.
+     */
+    Py_ssize_t ma_mask;
         /* ma_table points to ma_smalltable for small tables, else to
          * additional malloc'ed memory.  ma_table is never NULL!  This rule
          * saves repeated runtime null-tests in the workhorse getitem and
          * setitem calls.
          */
         PyDictEntry *ma_table;
         PyDictEntry *(*ma_lookup)(PyDictObject *mp, PyObject *key, long hash);
         PyDictEntry ma_smalltable[PyDict_MINSIZE];
+    /* ma_table points to ma_smalltable for small tables, else to
+     * additional malloc'ed memory.  ma_table is never NULL!  This rule
+     * saves repeated runtime null-tests in the workhorse getitem and
+     * setitem calls.
+     */
+    PyDictEntry *ma_table;
+    PyDictEntry *(*ma_lookup)(PyDictObject *mp, PyObject *key, long hash);
+    PyDictEntry ma_smalltable[PyDict_MINSIZE];
 };
 PyAPI_DATA(PyTypeObject) PyDict_Type;
+PyAPI_DATA(PyTypeObject) PyDictIterKey_Type;
+PyAPI_DATA(PyTypeObject) PyDictIterValue_Type;
+PyAPI_DATA(PyTypeObject) PyDictIterItem_Type;
+PyAPI_DATA(PyTypeObject) PyDictKeys_Type;
+PyAPI_DATA(PyTypeObject) PyDictItems_Type;
+PyAPI_DATA(PyTypeObject) PyDictValues_Type;
 #define PyDict_Check(op) \
                  PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_DICT_SUBCLASS)
 #define PyDict_CheckExact(op) (Py_TYPE(op) == &PyDict_Type)
+#define PyDictKeys_Check(op) (Py_TYPE(op) == &PyDictKeys_Type)
+#define PyDictItems_Check(op) (Py_TYPE(op) == &PyDictItems_Type)
+#define PyDictValues_Check(op) (Py_TYPE(op) == &PyDictValues_Type)
+/* This excludes Values, since they are not sets. */
+# define PyDictViewSet_Check(op) \
+    (PyDictKeys_Check(op) || PyDictItems_Check(op))
 PyAPI_FUNC(PyObject *) PyDict_New(void);
 …
 PyAPI_FUNC(void) PyDict_Clear(PyObject *mp);
 PyAPI_FUNC(int) PyDict_Next(
         PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value);
+    PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value);
 PyAPI_FUNC(int) _PyDict_Next(
         PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value, long *hash);
+    PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value, long *hash);
 PyAPI_FUNC(PyObject *) PyDict_Keys(PyObject *mp);
 PyAPI_FUNC(PyObject *) PyDict_Values(PyObject *mp);
 …
 PyAPI_FUNC(int) _PyDict_Contains(PyObject *mp, PyObject *key, long hash);
 PyAPI_FUNC(PyObject *) _PyDict_NewPresized(Py_ssize_t minused);
+PyAPI_FUNC(void) _PyDict_MaybeUntrack(PyObject *mp);
 /* PyDict_Update(mp, other) is equivalent to PyDict_Merge(mp, other, 1). */
 …
 */
 PyAPI_FUNC(int) PyDict_Merge(PyObject *mp,
                                    PyObject *other,
                                    int override);
+                                   PyObject *other,
+                                   int override);
 /* PyDict_MergeFromSeq2 updates/merges from an iterable object producing
 …
 */
 PyAPI_FUNC(int) PyDict_MergeFromSeq2(PyObject *d,
                                            PyObject *seq2,
                                            int override);
+                                           PyObject *seq2,
+                                           int override);
 PyAPI_FUNC(PyObject *) PyDict_GetItemString(PyObject *dp, const char *key);

python/vendor/current/Include/fileobject.h

-              r2
+              r388
 typedef struct {
         PyObject_HEAD
         FILE *f_fp;
         PyObject *f_name;
         PyObject *f_mode;
         int (*f_close)(FILE *);
         int f_softspace;        /* Flag used by 'print' command */
+        int f_binary;           /* Flag which indicates whether the file is
                                    open in binary (1) or text (0) mode */
         char* f_buf;            /* Allocated readahead buffer */
         char* f_bufend;         /* Points after last occupied position */
         char* f_bufptr;         /* Current buffer position */
         char *f_setbuf;         /* Buffer for setbuf(3) and setvbuf(3) */
         int f_univ_newline;     /* Handle any newline convention */
         int f_newlinetypes;     /* Types of newlines seen */
         int f_skipnextlf;       /* Skip next \n */
         PyObject *f_encoding;
         PyObject *f_errors;
         PyObject *weakreflist; /* List of weak references */
         int unlocked_count;     /* Num. currently running sections of code
                                    using f_fp with the GIL released. */
         int readable;
         int writable;
+    PyObject_HEAD
+    FILE *f_fp;
+    PyObject *f_name;
+    PyObject *f_mode;
+    int (*f_close)(FILE *);
+    int f_softspace;            /* Flag used by 'print' command */
+    int f_binary;               /* Flag which indicates whether the file is
+                               open in binary (1) or text (0) mode */
+    char* f_buf;                /* Allocated readahead buffer */
+    char* f_bufend;             /* Points after last occupied position */
+    char* f_bufptr;             /* Current buffer position */
+    char *f_setbuf;             /* Buffer for setbuf(3) and setvbuf(3) */
+    int f_univ_newline;         /* Handle any newline convention */
+    int f_newlinetypes;         /* Types of newlines seen */
+    int f_skipnextlf;           /* Skip next \n */
+    PyObject *f_encoding;
+    PyObject *f_errors;
+    PyObject *weakreflist; /* List of weak references */
+    int unlocked_count;         /* Num. currently running sections of code
+                               using f_fp with the GIL released. */
+    int readable;
+    int writable;
 } PyFileObject;
 …
 int _PyFile_SanitizeMode(char *mode);
+#if defined _MSC_VER && _MSC_VER >= 1400
+/* A routine to check if a file descriptor is valid on Windows.  Returns 0
+ * and sets errno to EBADF if it isn't.  This is to avoid Assertions
+ * from various functions in the Windows CRT beginning with
+ * Visual Studio 2005
+ */
+int _PyVerify_fd(int fd);
+#elif defined _MSC_VER && _MSC_VER >= 1200
+/* fdopen doesn't set errno EBADF and crashes for large fd on debug build */
+#define _PyVerify_fd(fd) (_get_osfhandle(fd) >= 0)
+#else
+#define _PyVerify_fd(A) (1) /* dummy */
+#endif
+/* A routine to check if a file descriptor can be select()-ed. */
+#ifdef HAVE_SELECT
+ #define _PyIsSelectable_fd(FD) (((FD) >= 0) && ((FD) < FD_SETSIZE))
+#else
+ #define _PyIsSelectable_fd(FD) (1)
+#endif /* HAVE_SELECT */
 #ifdef __cplusplus
+}

python/vendor/current/Include/floatobject.h

-              r2
+              r388
 #define PyFloat_Check(op) PyObject_TypeCheck(op, &PyFloat_Type)
 #define PyFloat_CheckExact(op) (Py_TYPE(op) == &PyFloat_Type)
+/* The str() precision PyFloat_STR_PRECISION is chosen so that in most cases,
+   the rounding noise created by various operations is suppressed, while
+   giving plenty of precision for practical use. */
+#define PyFloat_STR_PRECISION 12
 #ifdef Py_NAN
 …
                                                Py_ssize_t format_spec_len);
+/* Round a C double x to the closest multiple of 10**-ndigits.  Returns a
+   Python float on success, or NULL (with an appropriate exception set) on
+   failure.  Used in builtin_round in bltinmodule.c. */
+PyAPI_FUNC(PyObject *) _Py_double_round(double x, int ndigits);
 #ifdef __cplusplus
+}

python/vendor/current/Include/frameobject.h

-              r2
+              r388
     PyThreadState *f_tstate;
     int f_lasti;                /* Last instruction if called */
+    /* As of 2.3 f_lineno is only valid when tracing is active (i.e. when
+       f_trace is set) -- at other times use PyCode_Addr2Line instead. */
+    /* Call PyFrame_GetLineNumber() instead of reading this field
+       directly.  As of 2.3 f_lineno is only valid when tracing is
+       active (i.e. when f_trace is set).  At other times we use
+       PyCode_Addr2Line to calculate the line from the current
+       bytecode index. */
     int f_lineno;               /* Current line number */
     int f_iblock;               /* index in f_blockstack */
 …
 PyAPI_FUNC(int) PyFrame_ClearFreeList(void);
+/* Return the line of code the frame is currently executing. */
+PyAPI_FUNC(int) PyFrame_GetLineNumber(PyFrameObject *);
 #ifdef __cplusplus
+}

python/vendor/current/Include/graminit.h

-              r2
+              r388
 #define try_stmt 296
 #define with_stmt 297
 #define with_var 298
+#define with_item 298
 #define except_clause 299
 #define suite 300
 …
 #define atom 318
 #define listmaker 319
 #define testlist_gexp 320
+#define testlist_comp 320
 #define lambdef 321
 #define trailer 322
 …
 #define exprlist 326
 #define testlist 327
 #define dictmaker 328
+#define dictorsetmaker 328
 #define classdef 329
 #define arglist 330
 …
 #define list_for 333
 #define list_if 334
 #define gen_iter 335
 #define gen_for 336
 #define gen_if 337
+#define comp_iter 335
+#define comp_for 336
+#define comp_if 337
 #define testlist1 338
 #define encoding_decl 339

python/vendor/current/Include/import.h

r2	r388
52	52	PyAPI_DATA(struct _inittab *) PyImport_Inittab;
53	53
54		PyAPI_FUNC(int) PyImport_AppendInittab(char name, void (initfunc)(void));
	54	PyAPI_FUNC(int) PyImport_AppendInittab(const char name, void (initfunc)(void));
55	55	PyAPI_FUNC(int) PyImport_ExtendInittab(struct _inittab *newtab);
56	56

python/vendor/current/Include/intobject.h

r2	r388
41	41	PyAPI_FUNC(long) PyInt_AsLong(PyObject *);
42	42	PyAPI_FUNC(Py_ssize_t) PyInt_AsSsize_t(PyObject *);
	43	PyAPI_FUNC(int) _PyInt_AsInt(PyObject *);
43	44	PyAPI_FUNC(unsigned long) PyInt_AsUnsignedLongMask(PyObject *);
44	45	#ifdef HAVE_LONG_LONG

python/vendor/current/Include/longintrepr.h

-              r2
+              r388
 /* This is published for the benefit of "friend" marshal.c only. */
+/* Parameters of the long integer representation.
+   These shouldn't have to be changed as C should guarantee that a short
+   contains at least 16 bits, but it's made changeable anyway.
+   Note: 'digit' should be able to hold 2*MASK+1, and 'twodigits'
+   should be able to hold the intermediate results in 'mul'
+   (at most (BASE-1)*(2*BASE+1) == MASK*(2*MASK+3)).
+   Also, x_sub assumes that 'digit' is an unsigned type, and overflow
+   is handled by taking the result mod 2**N for some N > SHIFT.
+   And, at some places it is assumed that MASK fits in an int, as well.
+   long_pow() requires that SHIFT be divisible by 5. */
+/* Parameters of the long integer representation.  There are two different
+   sets of parameters: one set for 30-bit digits, stored in an unsigned 32-bit
+   integer type, and one set for 15-bit digits with each digit stored in an
+   unsigned short.  The value of PYLONG_BITS_IN_DIGIT, defined either at
+   configure time or in pyport.h, is used to decide which digit size to use.
+   Type 'digit' should be able to hold 2*PyLong_BASE-1, and type 'twodigits'
+   should be an unsigned integer type able to hold all integers up to
+   PyLong_BASE*PyLong_BASE-1.  x_sub assumes that 'digit' is an unsigned type,
+   and that overflow is handled by taking the result modulo 2**N for some N >
+   PyLong_SHIFT.  The majority of the code doesn't care about the precise
+   value of PyLong_SHIFT, but there are some notable exceptions:
+   - long_pow() requires that PyLong_SHIFT be divisible by 5
+   - PyLong_{As,From}ByteArray require that PyLong_SHIFT be at least 8
+   - long_hash() requires that PyLong_SHIFT is *strictly* less than the number
+     of bits in an unsigned long, as do the PyLong <-> long (or unsigned long)
+     conversion functions
+   - the long <-> size_t/Py_ssize_t conversion functions expect that
+     PyLong_SHIFT is strictly less than the number of bits in a size_t
+   - the marshal code currently expects that PyLong_SHIFT is a multiple of 15
+  The values 15 and 30 should fit all of the above requirements, on any
+  platform.
+*/
+#if PYLONG_BITS_IN_DIGIT == 30
+#if !(defined HAVE_UINT64_T && defined HAVE_UINT32_T &&          \
+      defined HAVE_INT64_T && defined HAVE_INT32_T)
+#error "30-bit long digits requested, but the necessary types are not available on this platform"
+#endif
+typedef PY_UINT32_T digit;
+typedef PY_INT32_T sdigit; /* signed variant of digit */
+typedef PY_UINT64_T twodigits;
+typedef PY_INT64_T stwodigits; /* signed variant of twodigits */
+#define PyLong_SHIFT    30
+#define _PyLong_DECIMAL_SHIFT   9 /* max(e such that 10**e fits in a digit) */
+#define _PyLong_DECIMAL_BASE    ((digit)1000000000) /* 10 ** DECIMAL_SHIFT */
+#elif PYLONG_BITS_IN_DIGIT == 15
 typedef unsigned short digit;
+typedef unsigned int wdigit; /* digit widened to parameter size */
+#define BASE_TWODIGITS_TYPE long
+typedef unsigned BASE_TWODIGITS_TYPE twodigits;
+typedef BASE_TWODIGITS_TYPE stwodigits; /* signed variant of twodigits */
+#define PyLong_SHIFT    15
+#define PyLong_BASE     ((digit)1 << PyLong_SHIFT)
+#define PyLong_MASK     ((int)(PyLong_BASE - 1))
+typedef short sdigit; /* signed variant of digit */
+typedef unsigned long twodigits;
+typedef long stwodigits; /* signed variant of twodigits */
+#define PyLong_SHIFT    15
+#define _PyLong_DECIMAL_SHIFT   4 /* max(e such that 10**e fits in a digit) */
+#define _PyLong_DECIMAL_BASE    ((digit)10000) /* 10 ** DECIMAL_SHIFT */
+#else
+#error "PYLONG_BITS_IN_DIGIT should be 15 or 30"
+#endif
+#define PyLong_BASE     ((digit)1 << PyLong_SHIFT)
+#define PyLong_MASK     ((digit)(PyLong_BASE - 1))
 /* b/w compatibility with Python 2.5 */

python/vendor/current/Include/longobject.h

-              r2
+              r388
 PyAPI_FUNC(PyObject *) PyLong_FromSsize_t(Py_ssize_t);
 PyAPI_FUNC(long) PyLong_AsLong(PyObject *);
+PyAPI_FUNC(long) PyLong_AsLongAndOverflow(PyObject *, int *);
 PyAPI_FUNC(unsigned long) PyLong_AsUnsignedLong(PyObject *);
 PyAPI_FUNC(unsigned long) PyLong_AsUnsignedLongMask(PyObject *);
 PyAPI_FUNC(Py_ssize_t) PyLong_AsSsize_t(PyObject *);
+PyAPI_FUNC(int) _PyLong_AsInt(PyObject *);
+PyAPI_FUNC(PyObject *) PyLong_GetInfo(void);
 /* For use by intobject.c only */
 …
 PyAPI_DATA(int) _PyLong_DigitValue[256];
 /* _PyLong_AsScaledDouble returns a double x and an exponent e such that
    the true value is approximately equal to x * 2**(SHIFT*e).  e is >= 0.
    x is 0.0 if and only if the input is 0 (in which case, e and x are both
    zeroes).  Overflow is impossible.  Note that the exponent returned must
    be multiplied by SHIFT!  There may not be enough room in an int to store
    e*SHIFT directly. */
 PyAPI_FUNC(double) _PyLong_AsScaledDouble(PyObject *vv, int *e);
+/* _PyLong_Frexp returns a double x and an exponent e such that the
+   true value is approximately equal to x * 2**e.  e is >= 0.  x is
+.0 if and only if the input is 0 (in which case, e and x are both
+   zeroes); otherwise, 0.5 <= abs(x) < 1.0.  On overflow, which is
+   possible if the number of bits doesn't fit into a Py_ssize_t, sets
+   OverflowError and returns -1.0 for x, 0 for e. */
+PyAPI_FUNC(double) _PyLong_Frexp(PyLongObject *a, Py_ssize_t *e);
 PyAPI_FUNC(double) PyLong_AsDouble(PyObject *);
 …
 PyAPI_FUNC(unsigned PY_LONG_LONG) PyLong_AsUnsignedLongLong(PyObject *);
 PyAPI_FUNC(unsigned PY_LONG_LONG) PyLong_AsUnsignedLongLongMask(PyObject *);
+PyAPI_FUNC(PY_LONG_LONG) PyLong_AsLongLongAndOverflow(PyObject *, int *);
 #endif /* HAVE_LONG_LONG */

python/vendor/current/Include/node.h

-              r2
+              r388
                                       char *str, int lineno, int col_offset);
 PyAPI_FUNC(void) PyNode_Free(node *n);
+#ifndef Py_LIMITED_API
+Py_ssize_t _PyNode_SizeOf(node *n);
+#endif
 /* Node access functions */

python/vendor/current/Include/object.h

-              r2
+              r388
 #ifdef Py_TRACE_REFS
 /* Define pointers to support a doubly-linked list of all live heap objects. */
 #define _PyObject_HEAD_EXTRA            \
         struct _object *_ob_next;       \
         struct _object *_ob_prev;
+#define _PyObject_HEAD_EXTRA            \
+    struct _object *_ob_next;           \
+    struct _object *_ob_prev;
 #define _PyObject_EXTRA_INIT 0, 0,
 …
 /* PyObject_HEAD defines the initial segment of every PyObject. */
 #define PyObject_HEAD                   \
         _PyObject_HEAD_EXTRA            \
         Py_ssize_t ob_refcnt;           \
         struct _typeobject *ob_type;
 #define PyObject_HEAD_INIT(type)        \
         _PyObject_EXTRA_INIT            \
 , type,
 #define PyVarObject_HEAD_INIT(type, size)       \
         PyObject_HEAD_INIT(type) size,
+#define PyObject_HEAD                   \
+    _PyObject_HEAD_EXTRA                \
+    Py_ssize_t ob_refcnt;               \
+    struct _typeobject *ob_type;
+#define PyObject_HEAD_INIT(type)        \
+    _PyObject_EXTRA_INIT                \
+, type,
+#define PyVarObject_HEAD_INIT(type, size)       \
+    PyObject_HEAD_INIT(type) size,
 /* PyObject_VAR_HEAD defines the initial segment of all variable-size
 …
  * not necessarily a byte count.
  */
 #define PyObject_VAR_HEAD               \
         PyObject_HEAD                   \
         Py_ssize_t ob_size; /* Number of items in variable part */
+#define PyObject_VAR_HEAD               \
+    PyObject_HEAD                       \
+    Py_ssize_t ob_size; /* Number of items in variable part */
 #define Py_INVALID_SIZE (Py_ssize_t)-1
 …
  */
 typedef struct _object {
         PyObject_HEAD
+    PyObject_HEAD
 } PyObject;
 typedef struct {
         PyObject_VAR_HEAD
+    PyObject_VAR_HEAD
 } PyVarObject;
 #define Py_REFCNT(ob)           (((PyObject*)(ob))->ob_refcnt)
 #define Py_TYPE(ob)             (((PyObject*)(ob))->ob_type)
 #define Py_SIZE(ob)             (((PyVarObject*)(ob))->ob_size)
+#define Py_REFCNT(ob)           (((PyObject*)(ob))->ob_refcnt)
+#define Py_TYPE(ob)             (((PyObject*)(ob))->ob_type)
+#define Py_SIZE(ob)             (((PyVarObject*)(ob))->ob_size)
 /*
 …
 typedef Py_ssize_t (*charbufferproc)(PyObject *, Py_ssize_t, char **);
 /* Py3k buffer interface */
 typedef struct bufferinfo {
+        void *buf;
+        PyObject *obj;        /* borrowed reference */
+        Py_ssize_t len;
+        Py_ssize_t itemsize;  /* This is Py_ssize_t so it can be
+                                 pointed to by strides in simple case.*/
+        int readonly;
+        int ndim;
+        char *format;
+        Py_ssize_t *shape;
+        Py_ssize_t *strides;
+        Py_ssize_t *suboffsets;
+        void *internal;
+    void *buf;
+    PyObject *obj;        /* owned reference */
+    Py_ssize_t len;
+    Py_ssize_t itemsize;  /* This is Py_ssize_t so it can be
+                             pointed to by strides in simple case.*/
+    int readonly;
+    int ndim;
+    char *format;
+    Py_ssize_t *shape;
+    Py_ssize_t *strides;
+    Py_ssize_t *suboffsets;
+    Py_ssize_t smalltable[2];  /* static store for shape and strides of
+                                  mono-dimensional buffers. */
+    void *internal;
 } Py_buffer;
 …
 typedef void (*releasebufferproc)(PyObject *, Py_buffer *);
         /* Flags for getting buffers */
+    /* Flags for getting buffers */
 #define PyBUF_SIMPLE 0
 #define PyBUF_WRITABLE 0x0001
 …
 typedef struct {
         /* For numbers without flag bit Py_TPFLAGS_CHECKTYPES set, all
            arguments are guaranteed to be of the object's type (modulo
            coercion hacks -- i.e. if the type's coercion function
            returns other types, then these are allowed as well).  Numbers that
            have the Py_TPFLAGS_CHECKTYPES flag bit set should check *both*
            arguments for proper type and implement the necessary conversions
            in the slot functions themselves. */
         binaryfunc nb_add;
         binaryfunc nb_subtract;
         binaryfunc nb_multiply;
         binaryfunc nb_divide;
         binaryfunc nb_remainder;
         binaryfunc nb_divmod;
         ternaryfunc nb_power;
         unaryfunc nb_negative;
         unaryfunc nb_positive;
         unaryfunc nb_absolute;
         inquiry nb_nonzero;
         unaryfunc nb_invert;
         binaryfunc nb_lshift;
         binaryfunc nb_rshift;
         binaryfunc nb_and;
         binaryfunc nb_xor;
         binaryfunc nb_or;
         coercion nb_coerce;
         unaryfunc nb_int;
         unaryfunc nb_long;
         unaryfunc nb_float;
         unaryfunc nb_oct;
         unaryfunc nb_hex;
         /* Added in release 2.0 */
         binaryfunc nb_inplace_add;
         binaryfunc nb_inplace_subtract;
         binaryfunc nb_inplace_multiply;
         binaryfunc nb_inplace_divide;
         binaryfunc nb_inplace_remainder;
         ternaryfunc nb_inplace_power;
         binaryfunc nb_inplace_lshift;
         binaryfunc nb_inplace_rshift;
         binaryfunc nb_inplace_and;
         binaryfunc nb_inplace_xor;
         binaryfunc nb_inplace_or;
         /* Added in release 2.2 */
         /* The following require the Py_TPFLAGS_HAVE_CLASS flag */
         binaryfunc nb_floor_divide;
         binaryfunc nb_true_divide;
         binaryfunc nb_inplace_floor_divide;
         binaryfunc nb_inplace_true_divide;
         /* Added in release 2.5 */
         unaryfunc nb_index;
+    /* For numbers without flag bit Py_TPFLAGS_CHECKTYPES set, all
+       arguments are guaranteed to be of the object's type (modulo
+       coercion hacks -- i.e. if the type's coercion function
+       returns other types, then these are allowed as well).  Numbers that
+       have the Py_TPFLAGS_CHECKTYPES flag bit set should check *both*
+       arguments for proper type and implement the necessary conversions
+       in the slot functions themselves. */
+    binaryfunc nb_add;
+    binaryfunc nb_subtract;
+    binaryfunc nb_multiply;
+    binaryfunc nb_divide;
+    binaryfunc nb_remainder;
+    binaryfunc nb_divmod;
+    ternaryfunc nb_power;
+    unaryfunc nb_negative;
+    unaryfunc nb_positive;
+    unaryfunc nb_absolute;
+    inquiry nb_nonzero;
+    unaryfunc nb_invert;
+    binaryfunc nb_lshift;
+    binaryfunc nb_rshift;
+    binaryfunc nb_and;
+    binaryfunc nb_xor;
+    binaryfunc nb_or;
+    coercion nb_coerce;
+    unaryfunc nb_int;
+    unaryfunc nb_long;
+    unaryfunc nb_float;
+    unaryfunc nb_oct;
+    unaryfunc nb_hex;
+    /* Added in release 2.0 */
+    binaryfunc nb_inplace_add;
+    binaryfunc nb_inplace_subtract;
+    binaryfunc nb_inplace_multiply;
+    binaryfunc nb_inplace_divide;
+    binaryfunc nb_inplace_remainder;
+    ternaryfunc nb_inplace_power;
+    binaryfunc nb_inplace_lshift;
+    binaryfunc nb_inplace_rshift;
+    binaryfunc nb_inplace_and;
+    binaryfunc nb_inplace_xor;
+    binaryfunc nb_inplace_or;
+    /* Added in release 2.2 */
+    /* The following require the Py_TPFLAGS_HAVE_CLASS flag */
+    binaryfunc nb_floor_divide;
+    binaryfunc nb_true_divide;
+    binaryfunc nb_inplace_floor_divide;
+    binaryfunc nb_inplace_true_divide;
+    /* Added in release 2.5 */
+    unaryfunc nb_index;
 } PyNumberMethods;
 typedef struct {
         lenfunc sq_length;
         binaryfunc sq_concat;
         ssizeargfunc sq_repeat;
         ssizeargfunc sq_item;
         ssizessizeargfunc sq_slice;
         ssizeobjargproc sq_ass_item;
         ssizessizeobjargproc sq_ass_slice;
         objobjproc sq_contains;
         /* Added in release 2.0 */
         binaryfunc sq_inplace_concat;
         ssizeargfunc sq_inplace_repeat;
+    lenfunc sq_length;
+    binaryfunc sq_concat;
+    ssizeargfunc sq_repeat;
+    ssizeargfunc sq_item;
+    ssizessizeargfunc sq_slice;
+    ssizeobjargproc sq_ass_item;
+    ssizessizeobjargproc sq_ass_slice;
+    objobjproc sq_contains;
+    /* Added in release 2.0 */
+    binaryfunc sq_inplace_concat;
+    ssizeargfunc sq_inplace_repeat;
 } PySequenceMethods;
 typedef struct {
         lenfunc mp_length;
         binaryfunc mp_subscript;
         objobjargproc mp_ass_subscript;
+    lenfunc mp_length;
+    binaryfunc mp_subscript;
+    objobjargproc mp_ass_subscript;
 } PyMappingMethods;
 typedef struct {
         readbufferproc bf_getreadbuffer;
         writebufferproc bf_getwritebuffer;
         segcountproc bf_getsegcount;
         charbufferproc bf_getcharbuffer;
         getbufferproc bf_getbuffer;
         releasebufferproc bf_releasebuffer;
+    readbufferproc bf_getreadbuffer;
+    writebufferproc bf_getwritebuffer;
+    segcountproc bf_getsegcount;
+    charbufferproc bf_getcharbuffer;
+    getbufferproc bf_getbuffer;
+    releasebufferproc bf_releasebuffer;
 } PyBufferProcs;
 …
 typedef struct _typeobject {
         PyObject_VAR_HEAD
         const char *tp_name; /* For printing, in format "<module>.<name>" */
         Py_ssize_t tp_basicsize, tp_itemsize; /* For allocation */
         /* Methods to implement standard operations */
         destructor tp_dealloc;
         printfunc tp_print;
         getattrfunc tp_getattr;
         setattrfunc tp_setattr;
         cmpfunc tp_compare;
         reprfunc tp_repr;
         /* Method suites for standard classes */
         PyNumberMethods *tp_as_number;
         PySequenceMethods *tp_as_sequence;
         PyMappingMethods *tp_as_mapping;
         /* More standard operations (here for binary compatibility) */
         hashfunc tp_hash;
         ternaryfunc tp_call;
         reprfunc tp_str;
         getattrofunc tp_getattro;
         setattrofunc tp_setattro;
         /* Functions to access object as input/output buffer */
         PyBufferProcs *tp_as_buffer;
         /* Flags to define presence of optional/expanded features */
         long tp_flags;
         const char *tp_doc; /* Documentation string */
         /* Assigned meaning in release 2.0 */
         /* call function for all accessible objects */
         traverseproc tp_traverse;
         /* delete references to contained objects */
         inquiry tp_clear;
         /* Assigned meaning in release 2.1 */
         /* rich comparisons */
         richcmpfunc tp_richcompare;
         /* weak reference enabler */
         Py_ssize_t tp_weaklistoffset;
         /* Added in release 2.2 */
         /* Iterators */
         getiterfunc tp_iter;
         iternextfunc tp_iternext;
         /* Attribute descriptor and subclassing stuff */
         struct PyMethodDef *tp_methods;
         struct PyMemberDef *tp_members;
         struct PyGetSetDef *tp_getset;
         struct _typeobject *tp_base;
         PyObject *tp_dict;
         descrgetfunc tp_descr_get;
         descrsetfunc tp_descr_set;
         Py_ssize_t tp_dictoffset;
         initproc tp_init;
         allocfunc tp_alloc;
         newfunc tp_new;
         freefunc tp_free; /* Low-level free-memory routine */
         inquiry tp_is_gc; /* For PyObject_IS_GC */
         PyObject *tp_bases;
         PyObject *tp_mro; /* method resolution order */
         PyObject *tp_cache;
         PyObject *tp_subclasses;
         PyObject *tp_weaklist;
         destructor tp_del;
         /* Type attribute cache version tag. Added in version 2.6 */
         unsigned int tp_version_tag;
+    PyObject_VAR_HEAD
+    const char *tp_name; /* For printing, in format "<module>.<name>" */
+    Py_ssize_t tp_basicsize, tp_itemsize; /* For allocation */
+    /* Methods to implement standard operations */
+    destructor tp_dealloc;
+    printfunc tp_print;
+    getattrfunc tp_getattr;
+    setattrfunc tp_setattr;
+    cmpfunc tp_compare;
+    reprfunc tp_repr;
+    /* Method suites for standard classes */
+    PyNumberMethods *tp_as_number;
+    PySequenceMethods *tp_as_sequence;
+    PyMappingMethods *tp_as_mapping;
+    /* More standard operations (here for binary compatibility) */
+    hashfunc tp_hash;
+    ternaryfunc tp_call;
+    reprfunc tp_str;
+    getattrofunc tp_getattro;
+    setattrofunc tp_setattro;
+    /* Functions to access object as input/output buffer */
+    PyBufferProcs *tp_as_buffer;
+    /* Flags to define presence of optional/expanded features */
+    long tp_flags;
+    const char *tp_doc; /* Documentation string */
+    /* Assigned meaning in release 2.0 */
+    /* call function for all accessible objects */
+    traverseproc tp_traverse;
+    /* delete references to contained objects */
+    inquiry tp_clear;
+    /* Assigned meaning in release 2.1 */
+    /* rich comparisons */
+    richcmpfunc tp_richcompare;
+    /* weak reference enabler */
+    Py_ssize_t tp_weaklistoffset;
+    /* Added in release 2.2 */
+    /* Iterators */
+    getiterfunc tp_iter;
+    iternextfunc tp_iternext;
+    /* Attribute descriptor and subclassing stuff */
+    struct PyMethodDef *tp_methods;
+    struct PyMemberDef *tp_members;
+    struct PyGetSetDef *tp_getset;
+    struct _typeobject *tp_base;
+    PyObject *tp_dict;
+    descrgetfunc tp_descr_get;
+    descrsetfunc tp_descr_set;
+    Py_ssize_t tp_dictoffset;
+    initproc tp_init;
+    allocfunc tp_alloc;
+    newfunc tp_new;
+    freefunc tp_free; /* Low-level free-memory routine */
+    inquiry tp_is_gc; /* For PyObject_IS_GC */
+    PyObject *tp_bases;
+    PyObject *tp_mro; /* method resolution order */
+    PyObject *tp_cache;
+    PyObject *tp_subclasses;
+    PyObject *tp_weaklist;
+    destructor tp_del;
+    /* Type attribute cache version tag. Added in version 2.6 */
+    unsigned int tp_version_tag;
 #ifdef COUNT_ALLOCS
         /* these must be last and never explicitly initialized */
         Py_ssize_t tp_allocs;
         Py_ssize_t tp_frees;
         Py_ssize_t tp_maxalloc;
         struct _typeobject *tp_prev;
         struct _typeobject *tp_next;
+    /* these must be last and never explicitly initialized */
+    Py_ssize_t tp_allocs;
+    Py_ssize_t tp_frees;
+    Py_ssize_t tp_maxalloc;
+    struct _typeobject *tp_prev;
+    struct _typeobject *tp_next;
 #endif
 } PyTypeObject;
 …
 /* The *real* layout of a type object when allocated on the heap */
 typedef struct _heaptypeobject {
         /* Note: there's a dependency on the order of these members
            in slotptr() in typeobject.c . */
         PyTypeObject ht_type;
         PyNumberMethods as_number;
         PyMappingMethods as_mapping;
         PySequenceMethods as_sequence; /* as_sequence comes after as_mapping,
                                           so that the mapping wins when both
                                           the mapping and the sequence define
                                           a given operator (e.g. __getitem__).
                                           see add_operators() in typeobject.c . */
         PyBufferProcs as_buffer;
         PyObject *ht_name, *ht_slots;
         /* here are optional user slots, followed by the members. */
+    /* Note: there's a dependency on the order of these members
+       in slotptr() in typeobject.c . */
+    PyTypeObject ht_type;
+    PyNumberMethods as_number;
+    PyMappingMethods as_mapping;
+    PySequenceMethods as_sequence; /* as_sequence comes after as_mapping,
+                                      so that the mapping wins when both
+                                      the mapping and the sequence define
+                                      a given operator (e.g. __getitem__).
+                                      see add_operators() in typeobject.c . */
+    PyBufferProcs as_buffer;
+    PyObject *ht_name, *ht_slots;
+    /* here are optional user slots, followed by the members. */
 } PyHeapTypeObject;
 …
 PyAPI_FUNC(int) PyType_IsSubtype(PyTypeObject *, PyTypeObject *);
 #define PyObject_TypeCheck(ob, tp) \
         (Py_TYPE(ob) == (tp) || PyType_IsSubtype(Py_TYPE(ob), (tp)))
+    (Py_TYPE(ob) == (tp) || PyType_IsSubtype(Py_TYPE(ob), (tp)))
 PyAPI_DATA(PyTypeObject) PyType_Type; /* built-in 'type' */
 …
 #define PyType_Check(op) \
         PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_TYPE_SUBCLASS)
+    PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_TYPE_SUBCLASS)
 #define PyType_CheckExact(op) (Py_TYPE(op) == &PyType_Type)
 …
 PyAPI_FUNC(PyObject *) PyType_GenericAlloc(PyTypeObject *, Py_ssize_t);
 PyAPI_FUNC(PyObject *) PyType_GenericNew(PyTypeObject *,
                                                PyObject *, PyObject *);
+                                               PyObject *, PyObject *);
 PyAPI_FUNC(PyObject *) _PyType_Lookup(PyTypeObject *, PyObject *);
+PyAPI_FUNC(PyObject *) _PyObject_LookupSpecial(PyObject *, char *, PyObject **);
 PyAPI_FUNC(unsigned int) PyType_ClearCache(void);
 PyAPI_FUNC(void) PyType_Modified(PyTypeObject *);
 …
 PyAPI_FUNC(PyObject **) _PyObject_GetDictPtr(PyObject *);
 PyAPI_FUNC(PyObject *) PyObject_SelfIter(PyObject *);
+PyAPI_FUNC(PyObject *) _PyObject_NextNotImplemented(PyObject *);
 PyAPI_FUNC(PyObject *) PyObject_GenericGetAttr(PyObject *, PyObject *);
 PyAPI_FUNC(int) PyObject_GenericSetAttr(PyObject *,
                                               PyObject *, PyObject *);
+                                              PyObject *, PyObject *);
 PyAPI_FUNC(long) PyObject_Hash(PyObject *);
 PyAPI_FUNC(long) PyObject_HashNotImplemented(PyObject *);
 …
 /* A slot function whose address we need to compare */
 extern int _PyObject_SlotCompare(PyObject *, PyObject *);
+/* Same as PyObject_Generic{Get,Set}Attr, but passing the attributes
+   dict as the last parameter. */
+PyAPI_FUNC(PyObject *)
+_PyObject_GenericGetAttrWithDict(PyObject *, PyObject *, PyObject *);
+PyAPI_FUNC(int)
+_PyObject_GenericSetAttrWithDict(PyObject *, PyObject *,
+                                 PyObject *, PyObject *);
 …
 PyAPI_FUNC(long) _Py_HashPointer(void*);
+typedef struct {
+    long prefix;
+    long suffix;
+} _Py_HashSecret_t;
+PyAPI_DATA(_Py_HashSecret_t) _Py_HashSecret;
+#ifdef Py_DEBUG
+PyAPI_DATA(int) _Py_HashSecret_Initialized;
+#endif
 /* Helper for passing objects to printf and the like */
 #define PyObject_REPR(obj) PyString_AS_STRING(PyObject_Repr(obj))
 /* Flag bits for printing: */
 #define Py_PRINT_RAW    1       /* No string quotes etc. */
+#define Py_PRINT_RAW    1       /* No string quotes etc. */
 /*
 …
 /* These flags are used to determine if a type is a subclass. */
 #define Py_TPFLAGS_INT_SUBCLASS         (1L<<23)
 #define Py_TPFLAGS_LONG_SUBCLASS        (1L<<24)
 #define Py_TPFLAGS_LIST_SUBCLASS        (1L<<25)
 #define Py_TPFLAGS_TUPLE_SUBCLASS       (1L<<26)
 #define Py_TPFLAGS_STRING_SUBCLASS      (1L<<27)
 #define Py_TPFLAGS_UNICODE_SUBCLASS     (1L<<28)
 #define Py_TPFLAGS_DICT_SUBCLASS        (1L<<29)
 #define Py_TPFLAGS_BASE_EXC_SUBCLASS    (1L<<30)
 #define Py_TPFLAGS_TYPE_SUBCLASS        (1L<<31)
+#define Py_TPFLAGS_INT_SUBCLASS         (1L<<23)
+#define Py_TPFLAGS_LONG_SUBCLASS        (1L<<24)
+#define Py_TPFLAGS_LIST_SUBCLASS        (1L<<25)
+#define Py_TPFLAGS_TUPLE_SUBCLASS       (1L<<26)
+#define Py_TPFLAGS_STRING_SUBCLASS      (1L<<27)
+#define Py_TPFLAGS_UNICODE_SUBCLASS     (1L<<28)
+#define Py_TPFLAGS_DICT_SUBCLASS        (1L<<29)
+#define Py_TPFLAGS_BASE_EXC_SUBCLASS    (1L<<30)
+#define Py_TPFLAGS_TYPE_SUBCLASS        (1L<<31)
 #define Py_TPFLAGS_DEFAULT_EXTERNAL ( \
                              Py_TPFLAGS_HAVE_GETCHARBUFFER | \
                              Py_TPFLAGS_HAVE_SEQUENCE_IN | \
                              Py_TPFLAGS_HAVE_INPLACEOPS | \
                              Py_TPFLAGS_HAVE_RICHCOMPARE | \
                              Py_TPFLAGS_HAVE_WEAKREFS | \
                              Py_TPFLAGS_HAVE_ITER | \
                              Py_TPFLAGS_HAVE_CLASS | \
                              Py_TPFLAGS_HAVE_STACKLESS_EXTENSION | \
                              Py_TPFLAGS_HAVE_INDEX | \
 )
+                 Py_TPFLAGS_HAVE_GETCHARBUFFER | \
+                 Py_TPFLAGS_HAVE_SEQUENCE_IN | \
+                 Py_TPFLAGS_HAVE_INPLACEOPS | \
+                 Py_TPFLAGS_HAVE_RICHCOMPARE | \
+                 Py_TPFLAGS_HAVE_WEAKREFS | \
+                 Py_TPFLAGS_HAVE_ITER | \
+                 Py_TPFLAGS_HAVE_CLASS | \
+                 Py_TPFLAGS_HAVE_STACKLESS_EXTENSION | \
+                 Py_TPFLAGS_HAVE_INDEX | \
+)
 #define Py_TPFLAGS_DEFAULT_CORE (Py_TPFLAGS_DEFAULT_EXTERNAL | \
                                  Py_TPFLAGS_HAVE_VERSION_TAG)
+                 Py_TPFLAGS_HAVE_VERSION_TAG)
 #ifdef Py_BUILD_CORE
 …
 PyAPI_DATA(Py_ssize_t) _Py_RefTotal;
 PyAPI_FUNC(void) _Py_NegativeRefcount(const char *fname,
                                             int lineno, PyObject *op);
+                                            int lineno, PyObject *op);
 PyAPI_FUNC(PyObject *) _PyDict_Dummy(void);
 PyAPI_FUNC(PyObject *) _PySet_Dummy(void);
 PyAPI_FUNC(Py_ssize_t) _Py_GetRefTotal(void);
 #define _Py_INC_REFTOTAL        _Py_RefTotal++
 #define _Py_DEC_REFTOTAL        _Py_RefTotal--
 #define _Py_REF_DEBUG_COMMA     ,
 #define _Py_CHECK_REFCNT(OP)                                    \
 {       if (((PyObject*)OP)->ob_refcnt < 0)                             \
                 _Py_NegativeRefcount(__FILE__, __LINE__,        \
                                      (PyObject *)(OP));         \
+#define _Py_INC_REFTOTAL        _Py_RefTotal++
+#define _Py_DEC_REFTOTAL        _Py_RefTotal--
+#define _Py_REF_DEBUG_COMMA     ,
+#define _Py_CHECK_REFCNT(OP)                                    \
+{       if (((PyObject*)OP)->ob_refcnt < 0)                             \
+                _Py_NegativeRefcount(__FILE__, __LINE__,        \
+                                     (PyObject *)(OP));         \
+}
 #else
 …
 #define _Py_DEC_REFTOTAL
 #define _Py_REF_DEBUG_COMMA
 #define _Py_CHECK_REFCNT(OP)    /* a semicolon */;
+#define _Py_CHECK_REFCNT(OP)    /* a semicolon */;
 #endif /* Py_REF_DEBUG */
 …
 PyAPI_FUNC(void) inc_count(PyTypeObject *);
 PyAPI_FUNC(void) dec_count(PyTypeObject *);
 #define _Py_INC_TPALLOCS(OP)    inc_count(Py_TYPE(OP))
 #define _Py_INC_TPFREES(OP)     dec_count(Py_TYPE(OP))
 #define _Py_DEC_TPFREES(OP)     Py_TYPE(OP)->tp_frees--
 #define _Py_COUNT_ALLOCS_COMMA  ,
+#define _Py_INC_TPALLOCS(OP)    inc_count(Py_TYPE(OP))
+#define _Py_INC_TPFREES(OP)     dec_count(Py_TYPE(OP))
+#define _Py_DEC_TPFREES(OP)     Py_TYPE(OP)->tp_frees--
+#define _Py_COUNT_ALLOCS_COMMA  ,
 #else
 #define _Py_INC_TPALLOCS(OP)
 …
  * inline.
  */
 #define _Py_NewReference(op) (                          \
         _Py_INC_TPALLOCS(op) _Py_COUNT_ALLOCS_COMMA     \
         _Py_INC_REFTOTAL  _Py_REF_DEBUG_COMMA           \
         Py_REFCNT(op) = 1)
+#define _Py_NewReference(op) (                          \
+    _Py_INC_TPALLOCS(op) _Py_COUNT_ALLOCS_COMMA         \
+    _Py_INC_REFTOTAL  _Py_REF_DEBUG_COMMA               \
+    Py_REFCNT(op) = 1)
 #define _Py_ForgetReference(op) _Py_INC_TPFREES(op)
 #define _Py_Dealloc(op) (                               \
         _Py_INC_TPFREES(op) _Py_COUNT_ALLOCS_COMMA      \
         (*Py_TYPE(op)->tp_dealloc)((PyObject *)(op)))
+#define _Py_Dealloc(op) (                               \
+    _Py_INC_TPFREES(op) _Py_COUNT_ALLOCS_COMMA          \
+    (*Py_TYPE(op)->tp_dealloc)((PyObject *)(op)))
 #endif /* !Py_TRACE_REFS */
+#define Py_INCREF(op) (                         \
+        _Py_INC_REFTOTAL  _Py_REF_DEBUG_COMMA   \
+        ((PyObject*)(op))->ob_refcnt++)
+#define Py_DECREF(op)                                   \
+        if (_Py_DEC_REFTOTAL  _Py_REF_DEBUG_COMMA       \
+            --((PyObject*)(op))->ob_refcnt != 0)                \
+                _Py_CHECK_REFCNT(op)                    \
+        else                                            \
+                _Py_Dealloc((PyObject *)(op))
+#define Py_INCREF(op) (                         \
+    _Py_INC_REFTOTAL  _Py_REF_DEBUG_COMMA       \
+    ((PyObject*)(op))->ob_refcnt++)
+#define Py_DECREF(op)                                   \
+    do {                                                \
+        if (_Py_DEC_REFTOTAL  _Py_REF_DEBUG_COMMA       \
+        --((PyObject*)(op))->ob_refcnt != 0)            \
+            _Py_CHECK_REFCNT(op)                        \
+        else                                            \
+        _Py_Dealloc((PyObject *)(op));                  \
+    } while (0)
 /* Safely decref `op` and set `op` to NULL, especially useful in tp_clear
 …
  * to use Py_CLEAR() even if you can't think of a reason for why you need to.
  */
 #define Py_CLEAR(op)                            \
         do {                                    \
                 if (op) {                       \
                         PyObject *_py_tmp = (PyObject *)(op);   \
                         (op) = NULL;            \
                         Py_DECREF(_py_tmp);     \
                 }                               \
         } while (0)
+#define Py_CLEAR(op)                            \
+    do {                                        \
+        if (op) {                               \
+            PyObject *_py_tmp = (PyObject *)(op);               \
+            (op) = NULL;                        \
+            Py_DECREF(_py_tmp);                 \
+        }                                       \
+    } while (0)
 /* Macros to use in case the object pointer may be NULL: */
 #define Py_XINCREF(op) if ((op) == NULL) ; else Py_INCREF(op)
 #define Py_XDECREF(op) if ((op) == NULL) ; else Py_DECREF(op)
+#define Py_XINCREF(op) do { if ((op) == NULL) ; else Py_INCREF(op); } while (0)
+#define Py_XDECREF(op) do { if ((op) == NULL) ; else Py_DECREF(op); } while (0)
 /*
 …
 mytype_dealloc(mytype *p)
+{
         ... declarations go here ...
         PyObject_GC_UnTrack(p);    // must untrack first
         Py_TRASHCAN_SAFE_BEGIN(p)
         ... The body of the deallocator goes here, including all calls ...
         ... to Py_DECREF on contained objects.                         ...
         Py_TRASHCAN_SAFE_END(p)
+    ... declarations go here ...
+    PyObject_GC_UnTrack(p);        // must untrack first
+    Py_TRASHCAN_SAFE_BEGIN(p)
+    ... The body of the deallocator goes here, including all calls ...
+    ... to Py_DECREF on contained objects.                         ...
+    Py_TRASHCAN_SAFE_END(p)
+}
 …
 */
+/* This is the old private API, invoked by the macros before 2.7.4.
+   Kept for binary compatibility of extensions. */
 PyAPI_FUNC(void) _PyTrash_deposit_object(PyObject*);
 PyAPI_FUNC(void) _PyTrash_destroy_chain(void);
 …
 PyAPI_DATA(PyObject *) _PyTrash_delete_later;
+/* The new thread-safe private API, invoked by the macros below. */
+PyAPI_FUNC(void) _PyTrash_thread_deposit_object(PyObject*);
+PyAPI_FUNC(void) _PyTrash_thread_destroy_chain(void);
 #define PyTrash_UNWIND_LEVEL 50
+/* Note the workaround for when the thread state is NULL (issue #17703) */
 #define Py_TRASHCAN_SAFE_BEGIN(op) \
+        if (_PyTrash_delete_nesting < PyTrash_UNWIND_LEVEL) { \
+                ++_PyTrash_delete_nesting;
+                /* The body of the deallocator is here. */
+    do { \
+        PyThreadState *_tstate = PyThreadState_GET(); \
+        if (!_tstate || \
+            _tstate->trash_delete_nesting < PyTrash_UNWIND_LEVEL) { \
+            if (_tstate) \
+                ++_tstate->trash_delete_nesting;
+            /* The body of the deallocator is here. */
 #define Py_TRASHCAN_SAFE_END(op) \
+                --_PyTrash_delete_nesting; \
+                if (_PyTrash_delete_later && _PyTrash_delete_nesting <= 0) \
+                        _PyTrash_destroy_chain(); \
+        } \
+        else \
+                _PyTrash_deposit_object((PyObject*)op);
+            if (_tstate) { \
+                --_tstate->trash_delete_nesting; \
+                if (_tstate->trash_delete_later \
+                    && _tstate->trash_delete_nesting <= 0) \
+                    _PyTrash_thread_destroy_chain(); \
+            } \
+        } \
+        else \
+            _PyTrash_thread_deposit_object((PyObject*)op); \
+    } while (0);
 #ifdef __cplusplus

python/vendor/current/Include/objimpl.h

-              r2
+              r388
 /* Macros */
 #ifdef WITH_PYMALLOC
 #ifdef PYMALLOC_DEBUG   /* WITH_PYMALLOC && PYMALLOC_DEBUG */
+#ifdef PYMALLOC_DEBUG   /* WITH_PYMALLOC && PYMALLOC_DEBUG */
 PyAPI_FUNC(void *) _PyObject_DebugMalloc(size_t nbytes);
 PyAPI_FUNC(void *) _PyObject_DebugRealloc(void *p, size_t nbytes);
 …
 PyAPI_FUNC(void) _PyObject_DebugCheckAddress(const void *p);
 PyAPI_FUNC(void) _PyObject_DebugMallocStats(void);
+#define PyObject_MALLOC         _PyObject_DebugMalloc
+#define PyObject_Malloc         _PyObject_DebugMalloc
+#define PyObject_REALLOC        _PyObject_DebugRealloc
+#define PyObject_Realloc        _PyObject_DebugRealloc
+#define PyObject_FREE           _PyObject_DebugFree
+#define PyObject_Free           _PyObject_DebugFree
+#else   /* WITH_PYMALLOC && ! PYMALLOC_DEBUG */
+#define PyObject_MALLOC         PyObject_Malloc
+#define PyObject_REALLOC        PyObject_Realloc
+#define PyObject_FREE           PyObject_Free
+PyAPI_FUNC(void *) _PyObject_DebugMallocApi(char api, size_t nbytes);
+PyAPI_FUNC(void *) _PyObject_DebugReallocApi(char api, void *p, size_t nbytes);
+PyAPI_FUNC(void) _PyObject_DebugFreeApi(char api, void *p);
+PyAPI_FUNC(void) _PyObject_DebugCheckAddressApi(char api, const void *p);
+PyAPI_FUNC(void *) _PyMem_DebugMalloc(size_t nbytes);
+PyAPI_FUNC(void *) _PyMem_DebugRealloc(void *p, size_t nbytes);
+PyAPI_FUNC(void) _PyMem_DebugFree(void *p);
+#define PyObject_MALLOC         _PyObject_DebugMalloc
+#define PyObject_Malloc         _PyObject_DebugMalloc
+#define PyObject_REALLOC        _PyObject_DebugRealloc
+#define PyObject_Realloc        _PyObject_DebugRealloc
+#define PyObject_FREE           _PyObject_DebugFree
+#define PyObject_Free           _PyObject_DebugFree
+#else   /* WITH_PYMALLOC && ! PYMALLOC_DEBUG */
+#define PyObject_MALLOC         PyObject_Malloc
+#define PyObject_REALLOC        PyObject_Realloc
+#define PyObject_FREE           PyObject_Free
 #endif
 #else   /* ! WITH_PYMALLOC */
 #define PyObject_MALLOC         PyMem_MALLOC
 #define PyObject_REALLOC        PyMem_REALLOC
 #define PyObject_FREE           PyMem_FREE
 #endif  /* WITH_PYMALLOC */
 #define PyObject_Del            PyObject_Free
 #define PyObject_DEL            PyObject_FREE
+#else   /* ! WITH_PYMALLOC */
+#define PyObject_MALLOC         PyMem_MALLOC
+#define PyObject_REALLOC        PyMem_REALLOC
+#define PyObject_FREE           PyMem_FREE
+#endif  /* WITH_PYMALLOC */
+#define PyObject_Del            PyObject_Free
+#define PyObject_DEL            PyObject_FREE
 /* for source compatibility with 2.2 */
 #define _PyObject_Del           PyObject_Free
+#define _PyObject_Del           PyObject_Free
 /*
 …
 #define PyObject_New(type, typeobj) \
                 ( (type *) _PyObject_New(typeobj) )
+                ( (type *) _PyObject_New(typeobj) )
 #define PyObject_NewVar(type, typeobj, n) \
                 ( (type *) _PyObject_NewVar((typeobj), (n)) )
+                ( (type *) _PyObject_NewVar((typeobj), (n)) )
 /* Macros trading binary compatibility for speed. See also pymem.h.
    Note that these macros expect non-NULL object pointers.*/
 #define PyObject_INIT(op, typeobj) \
         ( Py_TYPE(op) = (typeobj), _Py_NewReference((PyObject *)(op)), (op) )
+    ( Py_TYPE(op) = (typeobj), _Py_NewReference((PyObject *)(op)), (op) )
 #define PyObject_INIT_VAR(op, typeobj, size) \
         ( Py_SIZE(op) = (size), PyObject_INIT((op), (typeobj)) )
+    ( Py_SIZE(op) = (size), PyObject_INIT((op), (typeobj)) )
 #define _PyObject_SIZE(typeobj) ( (typeobj)->tp_basicsize )
 …
 #endif
 #define _PyObject_VAR_SIZE(typeobj, nitems)     \
         (size_t)                                \
         ( ( (typeobj)->tp_basicsize +           \
             (nitems)*(typeobj)->tp_itemsize +   \
             (SIZEOF_VOID_P - 1)                 \
           ) & ~(SIZEOF_VOID_P - 1)              \
+        )
+#define _PyObject_VAR_SIZE(typeobj, nitems)     \
+    (size_t)                                    \
+    ( ( (typeobj)->tp_basicsize +               \
+        (nitems)*(typeobj)->tp_itemsize +       \
+        (SIZEOF_VOID_P - 1)                     \
+      ) & ~(SIZEOF_VOID_P - 1)                  \
+    )
 #define PyObject_NEW(type, typeobj) \
 ( (type *) PyObject_Init( \
         (PyObject *) PyObject_MALLOC( _PyObject_SIZE(typeobj) ), (typeobj)) )
+    (PyObject *) PyObject_MALLOC( _PyObject_SIZE(typeobj) ), (typeobj)) )
 #define PyObject_NEW_VAR(type, typeobj, n) \
 …
 ) the actual allocation of the object storage;
 ) the initialization of the Python specific fields
           in this storage with PyObject_{Init, InitVar}.
+      in this storage with PyObject_{Init, InitVar}.
    PyObject *
 …
        op = (PyObject *) Your_Allocator(_PyObject_SIZE(YourTypeStruct));
        if (op == NULL)
            return PyErr_NoMemory();
+       return PyErr_NoMemory();
        PyObject_Init(op, &YourTypeStruct);
 …
 /* Test if an object has a GC head */
 #define PyObject_IS_GC(o) (PyType_IS_GC(Py_TYPE(o)) && \
         (Py_TYPE(o)->tp_is_gc == NULL || Py_TYPE(o)->tp_is_gc(o)))
+    (Py_TYPE(o)->tp_is_gc == NULL || Py_TYPE(o)->tp_is_gc(o)))
 PyAPI_FUNC(PyVarObject *) _PyObject_GC_Resize(PyVarObject *, Py_ssize_t);
 #define PyObject_GC_Resize(type, op, n) \
                 ( (type *) _PyObject_GC_Resize((PyVarObject *)(op), (n)) )
+                ( (type *) _PyObject_GC_Resize((PyVarObject *)(op), (n)) )
 /* for source compatibility with 2.2 */
 …
 /* GC information is stored BEFORE the object structure. */
 typedef union _gc_head {
         struct {
                 union _gc_head *gc_next;
                 union _gc_head *gc_prev;
                 Py_ssize_t gc_refs;
         } gc;
         long double dummy;  /* force worst-case alignment */
+    struct {
+        union _gc_head *gc_next;
+        union _gc_head *gc_prev;
+        Py_ssize_t gc_refs;
+    } gc;
+    long double dummy;  /* force worst-case alignment */
 } PyGC_Head;
 …
 #define _Py_AS_GC(o) ((PyGC_Head *)(o)-1)
 #define _PyGC_REFS_UNTRACKED                    (-2)
 #define _PyGC_REFS_REACHABLE                    (-3)
 #define _PyGC_REFS_TENTATIVELY_UNREACHABLE      (-4)
+#define _PyGC_REFS_UNTRACKED                    (-2)
+#define _PyGC_REFS_REACHABLE                    (-3)
+#define _PyGC_REFS_TENTATIVELY_UNREACHABLE      (-4)
 /* Tell the GC to track this object.  NB: While the object is tracked the
  * collector it must be safe to call the ob_traverse method. */
 #define _PyObject_GC_TRACK(o) do { \
         PyGC_Head *g = _Py_AS_GC(o); \
         if (g->gc.gc_refs != _PyGC_REFS_UNTRACKED) \
                 Py_FatalError("GC object already tracked"); \
         g->gc.gc_refs = _PyGC_REFS_REACHABLE; \
         g->gc.gc_next = _PyGC_generation0; \
         g->gc.gc_prev = _PyGC_generation0->gc.gc_prev; \
         g->gc.gc_prev->gc.gc_next = g; \
         _PyGC_generation0->gc.gc_prev = g; \
+    PyGC_Head *g = _Py_AS_GC(o); \
+    if (g->gc.gc_refs != _PyGC_REFS_UNTRACKED) \
+        Py_FatalError("GC object already tracked"); \
+    g->gc.gc_refs = _PyGC_REFS_REACHABLE; \
+    g->gc.gc_next = _PyGC_generation0; \
+    g->gc.gc_prev = _PyGC_generation0->gc.gc_prev; \
+    g->gc.gc_prev->gc.gc_next = g; \
+    _PyGC_generation0->gc.gc_prev = g; \
     } while (0);
 …
  */
 #define _PyObject_GC_UNTRACK(o) do { \
         PyGC_Head *g = _Py_AS_GC(o); \
         assert(g->gc.gc_refs != _PyGC_REFS_UNTRACKED); \
         g->gc.gc_refs = _PyGC_REFS_UNTRACKED; \
         g->gc.gc_prev->gc.gc_next = g->gc.gc_next; \
         g->gc.gc_next->gc.gc_prev = g->gc.gc_prev; \
         g->gc.gc_next = NULL; \
+    PyGC_Head *g = _Py_AS_GC(o); \
+    assert(g->gc.gc_refs != _PyGC_REFS_UNTRACKED); \
+    g->gc.gc_refs = _PyGC_REFS_UNTRACKED; \
+    g->gc.gc_prev->gc.gc_next = g->gc.gc_next; \
+    g->gc.gc_next->gc.gc_prev = g->gc.gc_prev; \
+    g->gc.gc_next = NULL; \
     } while (0);
+/* True if the object is currently tracked by the GC. */
+#define _PyObject_GC_IS_TRACKED(o) \
+    ((_Py_AS_GC(o))->gc.gc_refs != _PyGC_REFS_UNTRACKED)
+/* True if the object may be tracked by the GC in the future, or already is.
+   This can be useful to implement some optimizations. */
+#define _PyObject_GC_MAY_BE_TRACKED(obj) \
+    (PyObject_IS_GC(obj) && \
+        (!PyTuple_CheckExact(obj) || _PyObject_GC_IS_TRACKED(obj)))
 PyAPI_FUNC(PyObject *) _PyObject_GC_Malloc(size_t);
 …
 #define PyObject_GC_New(type, typeobj) \
                 ( (type *) _PyObject_GC_New(typeobj) )
+                ( (type *) _PyObject_GC_New(typeobj) )
 #define PyObject_GC_NewVar(type, typeobj, n) \
                 ( (type *) _PyObject_GC_NewVar((typeobj), (n)) )
+                ( (type *) _PyObject_GC_NewVar((typeobj), (n)) )
 …
  * looking as much alike as possible.
  */
 #define Py_VISIT(op)                                                    \
         do {                                                            \
                 if (op) {                                               \
                         int vret = visit((PyObject *)(op), arg);        \
                         if (vret)                                       \
                                 return vret;                            \
                 }                                                       \
         } while (0)
+#define Py_VISIT(op)                                                    \
+    do {                                                                \
+        if (op) {                                                       \
+            int vret = visit((PyObject *)(op), arg);                    \
+            if (vret)                                                   \
+                return vret;                                            \
+        }                                                               \
+    } while (0)
 /* This is here for the sake of backwards compatibility.  Extensions that
 …
 /* Test if a type supports weak references */
 #define PyType_SUPPORTS_WEAKREFS(t) \
         (PyType_HasFeature((t), Py_TPFLAGS_HAVE_WEAKREFS) \
          && ((t)->tp_weaklistoffset > 0))
+    (PyType_HasFeature((t), Py_TPFLAGS_HAVE_WEAKREFS) \
+     && ((t)->tp_weaklistoffset > 0))
 #define PyObject_GET_WEAKREFS_LISTPTR(o) \
         ((PyObject **) (((char *) (o)) + Py_TYPE(o)->tp_weaklistoffset))
+    ((PyObject **) (((char *) (o)) + Py_TYPE(o)->tp_weaklistoffset))
 #ifdef __cplusplus

python/vendor/current/Include/opcode.h

-              r2
+              r388
 #define UNARY_INVERT    15
-#define LIST_APPEND     18
 #define BINARY_POWER    19
 …
 #define UNPACK_SEQUENCE 92      /* Number of sequence items */
 #define FOR_ITER        93
+#define LIST_APPEND     94
 #define STORE_ATTR      95      /* Index in name list */
 …
 #define BUILD_TUPLE     102     /* Number of tuple items */
 #define BUILD_LIST      103     /* Number of list items */
+#define BUILD_MAP       104     /* Always zero for now */
+#define LOAD_ATTR       105     /* Index in name list */
+#define COMPARE_OP      106     /* Comparison operator */
+#define IMPORT_NAME     107     /* Index in name list */
+#define IMPORT_FROM     108     /* Index in name list */
+#define BUILD_SET       104     /* Number of set items */
+#define BUILD_MAP       105     /* Always zero for now */
+#define LOAD_ATTR       106     /* Index in name list */
+#define COMPARE_OP      107     /* Comparison operator */
+#define IMPORT_NAME     108     /* Index in name list */
+#define IMPORT_FROM     109     /* Index in name list */
+#define JUMP_FORWARD    110     /* Number of bytes to skip */
+#define JUMP_FORWARD    110     /* Number of bytes to skip */
+#define JUMP_IF_FALSE   111     /* "" */
+#define JUMP_IF_TRUE    112     /* "" */
+#define JUMP_ABSOLUTE   113     /* Target byte offset from beginning of code */
+#define JUMP_IF_FALSE_OR_POP 111 /* Target byte offset from beginning
+                                    of code */
+#define JUMP_IF_TRUE_OR_POP 112 /* "" */
+#define JUMP_ABSOLUTE   113     /* "" */
+#define POP_JUMP_IF_FALSE 114   /* "" */
+#define POP_JUMP_IF_TRUE 115    /* "" */
 #define LOAD_GLOBAL     116     /* Index in name list */
 …
 #define CALL_FUNCTION_VAR_KW       142  /* #args + (#kwargs<<8) */
+#define SETUP_WITH 143
 /* Support for opargs more than 16 bits long */
+#define EXTENDED_ARG  143
+#define EXTENDED_ARG  145
+#define SET_ADD         146
+#define MAP_ADD         147

python/vendor/current/Include/osdefs.h

-              r2
+              r388
 /* Max pathname length */
+#ifdef __hpux
+#include <sys/param.h>
+#include <limits.h>
+#ifndef PATH_MAX
+#define PATH_MAX MAXPATHLEN
+#endif
+#endif
 #ifndef MAXPATHLEN
 #if defined(PATH_MAX) && PATH_MAX > 1024

python/vendor/current/Include/patchlevel.h

-              r2
+              r388
    When the major or minor version changes, the VERSION variable in
    configure.in must also be changed.
+   configure.ac must also be changed.
    There is also (independent) API version information in modsupport.h.
 …
 /*--start constants--*/
 #define PY_MAJOR_VERSION        2
 #define PY_MINOR_VERSION        6
 #define PY_MICRO_VERSION        5
+#define PY_MINOR_VERSION        7
+#define PY_MICRO_VERSION        6
 #define PY_RELEASE_LEVEL        PY_RELEASE_LEVEL_FINAL
 #define PY_RELEASE_SERIAL       0
 /* Version as a string */
 #define PY_VERSION              "2.6.5"
+#define PY_VERSION              "2.7.6"
 /*--end constants--*/
+/* Subversion Revision number of this file (not of the repository) */
+#define PY_PATCHLEVEL_REVISION  "$Revision: 79063 $"
+/* Subversion Revision number of this file (not of the repository). Empty
+   since Mercurial migration. */
+#define PY_PATCHLEVEL_REVISION  ""
 /* Version as a single 4-byte hex number, e.g. 0x010502B2 == 1.5.2b2.

python/vendor/current/Include/py_curses.h

-              r2
+              r388
 #define PyCursesWindow_Check(v)  (Py_TYPE(v) == &PyCursesWindow_Type)
+#define PyCurses_CAPSULE_NAME "_curses._C_API"
 #ifdef CURSES_MODULE
 /* This section is used when compiling _cursesmodule.c */
 …
 #define import_curses() \
+{ \
+  PyObject *module = PyImport_ImportModuleNoBlock("_curses"); \
+  if (module != NULL) { \
+    PyObject *module_dict = PyModule_GetDict(module); \
+    PyObject *c_api_object = PyDict_GetItemString(module_dict, "_C_API"); \
+    if (PyCObject_Check(c_api_object)) { \
+      PyCurses_API = (void **)PyCObject_AsVoidPtr(c_api_object); \
+    } \
+  } \
+}
+    PyCurses_API = (void **)PyCapsule_Import(PyCurses_CAPSULE_NAME, 1);
 #endif

python/vendor/current/Include/pydebug.h

r2	r388
27	27	/* Warn about 3.x issues */
28	28	PyAPI_DATA(int) Py_Py3kWarningFlag;
	29	PyAPI_DATA(int) Py_HashRandomizationFlag;
29	30
30	31	/* this is a wrapper around getenv() that pays attention to

python/vendor/current/Include/pyerrors.h

-              r2
+              r388
 /* */
 #define PyExceptionClass_Check(x)                                       \
         (PyClass_Check((x)) || (PyType_Check((x)) &&                    \
           PyType_FastSubclass((PyTypeObject*)(x), Py_TPFLAGS_BASE_EXC_SUBCLASS)))
 #define PyExceptionInstance_Check(x)                    \
         (PyInstance_Check((x)) ||                       \
          PyType_FastSubclass((x)->ob_type, Py_TPFLAGS_BASE_EXC_SUBCLASS))
 #define PyExceptionClass_Name(x)                                   \
         (PyClass_Check((x))                                        \
          ? PyString_AS_STRING(((PyClassObject*)(x))->cl_name)      \
          : (char *)(((PyTypeObject*)(x))->tp_name))
 #define PyExceptionInstance_Class(x)                                    \
         ((PyInstance_Check((x))                                         \
           ? (PyObject*)((PyInstanceObject*)(x))->in_class               \
           : (PyObject*)((x)->ob_type)))
+#define PyExceptionClass_Check(x)                                       \
+    (PyClass_Check((x)) || (PyType_Check((x)) &&                        \
+      PyType_FastSubclass((PyTypeObject*)(x), Py_TPFLAGS_BASE_EXC_SUBCLASS)))
+#define PyExceptionInstance_Check(x)                    \
+    (PyInstance_Check((x)) ||                           \
+     PyType_FastSubclass((x)->ob_type, Py_TPFLAGS_BASE_EXC_SUBCLASS))
+#define PyExceptionClass_Name(x)                                   \
+    (PyClass_Check((x))                                            \
+     ? PyString_AS_STRING(((PyClassObject*)(x))->cl_name)          \
+     : (char *)(((PyTypeObject*)(x))->tp_name))
+#define PyExceptionInstance_Class(x)                                    \
+    ((PyInstance_Check((x))                                             \
+      ? (PyObject*)((PyInstanceObject*)(x))->in_class                   \
+      : (PyObject*)((x)->ob_type)))
 /* Predefined exceptions */
 …
 PyAPI_FUNC(PyObject *) PyErr_SetFromErrno(PyObject *);
 PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithFilenameObject(
+        PyObject *, PyObject *);
+PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithFilename(PyObject *, char *);
+#ifdef Py_WIN_WIDE_FILENAMES
+    PyObject *, PyObject *);
+PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithFilename(
+    PyObject *, const char *);
+#ifdef MS_WINDOWS
 PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithUnicodeFilename(
         PyObject *, Py_UNICODE *);
 #endif /* Py_WIN_WIDE_FILENAMES */
+    PyObject *, const Py_UNICODE *);
+#endif /* MS_WINDOWS */
 PyAPI_FUNC(PyObject *) PyErr_Format(PyObject *, const char *, ...)
                         Py_GCC_ATTRIBUTE((format(printf, 2, 3)));
+                        Py_GCC_ATTRIBUTE((format(printf, 2, 3)));
 #ifdef MS_WINDOWS
 PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithFilenameObject(
         int, const char *);
+    int, const char *);
 PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithFilename(
+        int, const char *);
+#ifdef Py_WIN_WIDE_FILENAMES
+    int, const char *);
 PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithUnicodeFilename(
+        int, const Py_UNICODE *);
+#endif /* Py_WIN_WIDE_FILENAMES */
+    int, const Py_UNICODE *);
 PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErr(int);
 PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilenameObject(
         PyObject *,int, PyObject *);
+    PyObject *,int, PyObject *);
 PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilename(
+        PyObject *,int, const char *);
+#ifdef Py_WIN_WIDE_FILENAMES
+    PyObject *,int, const char *);
 PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithUnicodeFilename(
+        PyObject *,int, const Py_UNICODE *);
+#endif /* Py_WIN_WIDE_FILENAMES */
+    PyObject *,int, const Py_UNICODE *);
 PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErr(PyObject *, int);
 #endif /* MS_WINDOWS */
 …
 /* Function to create a new exception */
+PyAPI_FUNC(PyObject *) PyErr_NewException(char *name, PyObject *base,
+                                         PyObject *dict);
+PyAPI_FUNC(PyObject *) PyErr_NewException(
+    char *name, PyObject *base, PyObject *dict);
+PyAPI_FUNC(PyObject *) PyErr_NewExceptionWithDoc(
+    char *name, char *doc, PyObject *base, PyObject *dict);
 PyAPI_FUNC(void) PyErr_WriteUnraisable(PyObject *);
 …
 /* create a UnicodeDecodeError object */
 PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_Create(
         const char *, const char *, Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *);
+    const char *, const char *, Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *);
 /* create a UnicodeEncodeError object */
 PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_Create(
         const char *, const Py_UNICODE *, Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *);
+    const char *, const Py_UNICODE *, Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *);
 /* create a UnicodeTranslateError object */
 PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_Create(
         const Py_UNICODE *, Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *);
+    const Py_UNICODE *, Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *);
 /* get the encoding attribute */
 …
    return 0 on success, -1 on failure */
 PyAPI_FUNC(int) PyUnicodeEncodeError_SetReason(
         PyObject *, const char *);
+    PyObject *, const char *);
 PyAPI_FUNC(int) PyUnicodeDecodeError_SetReason(
         PyObject *, const char *);
+    PyObject *, const char *);
 PyAPI_FUNC(int) PyUnicodeTranslateError_SetReason(
         PyObject *, const char *);
+    PyObject *, const char *);
 #endif
 …
 #include <stdarg.h>
 PyAPI_FUNC(int) PyOS_snprintf(char *str, size_t size, const char  *format, ...)
                         Py_GCC_ATTRIBUTE((format(printf, 3, 4)));
+                        Py_GCC_ATTRIBUTE((format(printf, 3, 4)));
 PyAPI_FUNC(int) PyOS_vsnprintf(char *str, size_t size, const char  *format, va_list va)
                         Py_GCC_ATTRIBUTE((format(printf, 3, 0)));
+                        Py_GCC_ATTRIBUTE((format(printf, 3, 0)));
 #ifdef __cplusplus

python/vendor/current/Include/pyexpat.h

r2	r388
5	5
6	6	#define PyExpat_CAPI_MAGIC "pyexpat.expat_CAPI 1.0"
	7	#define PyExpat_CAPSULE_NAME "pyexpat.expat_CAPI"
7	8
8	9	struct PyExpat_CAPI

python/vendor/current/Include/pyfpe.h

-              r2
+              r388
 #endif
 /*
      ---------------------------------------------------------------------
     /                       Copyright (c) 1996.                           \
+     ---------------------------------------------------------------------
+    /                       Copyright (c) 1996.                           \
    |          The Regents of the University of California.                 |
    |                        All rights reserved.                           |
 …
    |   reflect those of the United States Government or  the  University   |
    |   of  California,  and shall not be used for advertising or product   |
     \  endorsement purposes.                                              /
      ---------------------------------------------------------------------
+    \  endorsement purposes.                                              /
+     ---------------------------------------------------------------------
 */

python/vendor/current/Include/pygetopt.h

r2	r388
10	10	PyAPI_DATA(char *) _PyOS_optarg;
11	11
	12	PyAPI_FUNC(void) _PyOS_ResetGetOpt(void);
12	13	PyAPI_FUNC(int) _PyOS_GetOpt(int argc, char *argv, char optstring);
13	14

python/vendor/current/Include/pymacconfig.h

-              r2
+              r388
       * when building on MacOSX. This is needed for building 4-way
       * universal binaries and for 64-bit universal binaries because
       * the values redefined below aren't configure-time constant but
+      * the values redefined below aren't configure-time constant but
       * only compile-time constant in these scenarios.
       */
 …
 # undef SIZEOF_VOID_P
 # undef SIZEOF__BOOL
+# undef SIZEOF_UINTPTR_T
+# undef SIZEOF_PTHREAD_T
 # undef WORDS_BIGENDIAN
+# undef DOUBLE_IS_ARM_MIXED_ENDIAN_IEEE754
+# undef DOUBLE_IS_BIG_ENDIAN_IEEE754
+# undef DOUBLE_IS_LITTLE_ENDIAN_IEEE754
+# undef HAVE_GCC_ASM_FOR_X87
 #    undef VA_LIST_IS_ARRAY
 …
 #    undef SIZEOF_LONG
 #    ifdef __LP64__
+#        define SIZEOF__BOOL            1
+#        define SIZEOF__BOOL            1
+#        define SIZEOF_LONG             8
+#        define SIZEOF_PTHREAD_T        8
+#        define SIZEOF_SIZE_T           8
+#        define SIZEOF_TIME_T           8
+#        define SIZEOF_VOID_P           8
+#        define SIZEOF__BOOL            1
+#        define SIZEOF__BOOL            1
+#        define SIZEOF_LONG             8
+#        define SIZEOF_PTHREAD_T        8
+#        define SIZEOF_SIZE_T           8
+#        define SIZEOF_TIME_T           8
+#        define SIZEOF_VOID_P           8
+#        define SIZEOF_UINTPTR_T        8
+#        define SIZEOF_PTHREAD_T        8
 #    else
 #        ifdef __ppc__
 #           define SIZEOF__BOOL         4
+#           define SIZEOF__BOOL         4
 #        else
 #           define SIZEOF__BOOL         1
+#           define SIZEOF__BOOL         1
 #        endif
+#        define SIZEOF_LONG             4
+#        define SIZEOF_PTHREAD_T        4
+#        define SIZEOF_SIZE_T           4
+#        define SIZEOF_TIME_T           4
+#        define SIZEOF_VOID_P           4
+#        define SIZEOF_LONG             4
+#        define SIZEOF_PTHREAD_T        4
+#        define SIZEOF_SIZE_T           4
+#        define SIZEOF_TIME_T           4
+#        define SIZEOF_VOID_P           4
+#        define SIZEOF_UINTPTR_T        4
+#        define SIZEOF_PTHREAD_T        4
 #    endif
 #    if defined(__LP64__)
          /* MacOSX 10.4 (the first release to suppport 64-bit code
+          * at all) only supports 64-bit in the UNIX layer.
           * Therefore surpress the toolbox-glue in 64-bit mode.
           */
+     /* MacOSX 10.4 (the first release to support 64-bit code
+      * at all) only supports 64-bit in the UNIX layer.
+      * Therefore surpress the toolbox-glue in 64-bit mode.
+      */
         /* In 64-bit mode setpgrp always has no argments, in 32-bit
          * mode that depends on the compilation environment
          */
 #       undef SETPGRP_HAVE_ARG
+    /* In 64-bit mode setpgrp always has no argments, in 32-bit
+     * mode that depends on the compilation environment
+     */
+#       undef SETPGRP_HAVE_ARG
 #    endif
 …
 #ifdef __BIG_ENDIAN__
 #define WORDS_BIGENDIAN 1
+#define DOUBLE_IS_BIG_ENDIAN_IEEE754
+#else
+#define DOUBLE_IS_LITTLE_ENDIAN_IEEE754
 #endif /* __BIG_ENDIAN */
+        /*
+         * The definition in pyconfig.h is only valid on the OS release
+         * where configure ran on and not necessarily for all systems where
+         * the executable can be used on.
+         *
+         * Specifically: OSX 10.4 has limited supported for '%zd', while
+         * 10.5 has full support for '%zd'. A binary built on 10.5 won't
+         * work properly on 10.4 unless we surpress the definition
+         * of PY_FORMAT_SIZE_T
+         */
+#undef  PY_FORMAT_SIZE_T
+#ifdef __i386__
+# define HAVE_GCC_ASM_FOR_X87
+#endif
+    /*
+     * The definition in pyconfig.h is only valid on the OS release
+     * where configure ran on and not necessarily for all systems where
+     * the executable can be used on.
+     *
+     * Specifically: OSX 10.4 has limited supported for '%zd', while
+     * 10.5 has full support for '%zd'. A binary built on 10.5 won't
+     * work properly on 10.4 unless we surpress the definition
+     * of PY_FORMAT_SIZE_T
+     */
+#undef  PY_FORMAT_SIZE_T

python/vendor/current/Include/pymath.h

-              r2
+              r388
 #include "pyconfig.h" /* include for defines */
-#ifdef HAVE_STDINT_H
-#include <stdint.h>
-#endif
 /**************************************************************************
 …
 **************************************************************************/
 /* Python provides implementations for copysign, acosh, asinh, atanh,
  * log1p and hypot in Python/pymath.c just in case your math library doesn't
  * provide the functions.
+/* Python provides implementations for copysign, round and hypot in
+ * Python/pymath.c just in case your math library doesn't provide the
+ * functions.
+ *
  *Note: PC/pyconfig.h defines copysign as _copysign
 …
 #endif
+#ifndef HAVE_ACOSH
+extern double acosh(double);
+#endif
+#ifndef HAVE_ASINH
+extern double asinh(double);
+#endif
+#ifndef HAVE_ATANH
+extern double atanh(double);
+#endif
+#ifndef HAVE_LOG1P
+extern double log1p(double);
+#ifndef HAVE_ROUND
+extern double round(double);
 #endif
 …
 #    define Py_FORCE_DOUBLE(X) (X)
 #  endif
+#endif
+#ifdef HAVE_GCC_ASM_FOR_X87
+PyAPI_FUNC(unsigned short) _Py_get_387controlword(void);
+PyAPI_FUNC(void) _Py_set_387controlword(unsigned short);
 #endif

python/vendor/current/Include/pymem.h

-              r2
+              r388
 #ifdef PYMALLOC_DEBUG
 /* Redirect all memory operations to Python's debugging allocator. */
 #define PyMem_MALLOC            PyObject_MALLOC
 #define PyMem_REALLOC           PyObject_REALLOC
 #define PyMem_FREE              PyObject_FREE
+#define PyMem_MALLOC            _PyMem_DebugMalloc
+#define PyMem_REALLOC           _PyMem_DebugRealloc
+#define PyMem_FREE              _PyMem_DebugFree
 #else   /* ! PYMALLOC_DEBUG */
 …
 /* Returns NULL to indicate error if a negative size or size larger than
    Py_ssize_t can represent is supplied.  Helps prevents security holes. */
 #define PyMem_MALLOC(n)         (((n) < 0 || (n) > PY_SSIZE_T_MAX) ? NULL \
+#define PyMem_MALLOC(n)         ((size_t)(n) > (size_t)PY_SSIZE_T_MAX ? NULL \
                                 : malloc((n) ? (n) : 1))
 #define PyMem_REALLOC(p, n)     (((n) < 0 || (n) > PY_SSIZE_T_MAX) ? NULL \
+#define PyMem_REALLOC(p, n)     ((size_t)(n) > (size_t)PY_SSIZE_T_MAX  ? NULL \
                                 : realloc((p), (n) ? (n) : 1))
 #define PyMem_FREE              free

python/vendor/current/Include/pyport.h

-              r2
+              r388
 #include "pyconfig.h" /* include for defines */
+/* Some versions of HP-UX & Solaris need inttypes.h for int32_t,
+   INT32_MAX, etc. */
+#ifdef HAVE_INTTYPES_H
+#include <inttypes.h>
+#endif
 #ifdef HAVE_STDINT_H
 …
 #endif /* HAVE_LONG_LONG */
+/* a build with 30-bit digits for Python long integers needs an exact-width
+ * 32-bit unsigned integer type to store those digits.  (We could just use
+ * type 'unsigned long', but that would be wasteful on a system where longs
+ * are 64-bits.)  On Unix systems, the autoconf macro AC_TYPE_UINT32_T defines
+ * uint32_t to be such a type unless stdint.h or inttypes.h defines uint32_t.
+ * However, it doesn't set HAVE_UINT32_T, so we do that here.
+ */
+#ifdef uint32_t
+#define HAVE_UINT32_T 1
+#endif
+#ifdef HAVE_UINT32_T
+#ifndef PY_UINT32_T
+#define PY_UINT32_T uint32_t
+#endif
+#endif
+/* Macros for a 64-bit unsigned integer type; used for type 'twodigits' in the
+ * long integer implementation, when 30-bit digits are enabled.
+ */
+#ifdef uint64_t
+#define HAVE_UINT64_T 1
+#endif
+#ifdef HAVE_UINT64_T
+#ifndef PY_UINT64_T
+#define PY_UINT64_T uint64_t
+#endif
+#endif
+/* Signed variants of the above */
+#ifdef int32_t
+#define HAVE_INT32_T 1
+#endif
+#ifdef HAVE_INT32_T
+#ifndef PY_INT32_T
+#define PY_INT32_T int32_t
+#endif
+#endif
+#ifdef int64_t
+#define HAVE_INT64_T 1
+#endif
+#ifdef HAVE_INT64_T
+#ifndef PY_INT64_T
+#define PY_INT64_T int64_t
+#endif
+#endif
+/* If PYLONG_BITS_IN_DIGIT is not defined then we'll use 30-bit digits if all
+   the necessary integer types are available, and we're on a 64-bit platform
+   (as determined by SIZEOF_VOID_P); otherwise we use 15-bit digits. */
+#ifndef PYLONG_BITS_IN_DIGIT
+#if (defined HAVE_UINT64_T && defined HAVE_INT64_T && \
+     defined HAVE_UINT32_T && defined HAVE_INT32_T && SIZEOF_VOID_P >= 8)
+#define PYLONG_BITS_IN_DIGIT 30
+#else
+#define PYLONG_BITS_IN_DIGIT 15
+#endif
+#endif
 /* uintptr_t is the C9X name for an unsigned integral type such that a
  * legitimate void* can be cast to uintptr_t and then back to void* again
 …
  */
 #ifdef HAVE_UINTPTR_T
 typedef uintptr_t       Py_uintptr_t;
 typedef intptr_t        Py_intptr_t;
+typedef uintptr_t       Py_uintptr_t;
+typedef intptr_t        Py_intptr_t;
 #elif SIZEOF_VOID_P <= SIZEOF_INT
 typedef unsigned int    Py_uintptr_t;
 typedef int             Py_intptr_t;
+typedef unsigned int    Py_uintptr_t;
+typedef int             Py_intptr_t;
 #elif SIZEOF_VOID_P <= SIZEOF_LONG
 typedef unsigned long   Py_uintptr_t;
 typedef long            Py_intptr_t;
+typedef unsigned long   Py_uintptr_t;
+typedef long            Py_intptr_t;
 #elif defined(HAVE_LONG_LONG) && (SIZEOF_VOID_P <= SIZEOF_LONG_LONG)
 typedef unsigned PY_LONG_LONG   Py_uintptr_t;
 typedef PY_LONG_LONG            Py_intptr_t;
+typedef unsigned PY_LONG_LONG   Py_uintptr_t;
+typedef PY_LONG_LONG            Py_intptr_t;
 #else
 …
  */
 #ifdef HAVE_SSIZE_T
 typedef ssize_t         Py_ssize_t;
+typedef ssize_t         Py_ssize_t;
 #elif SIZEOF_VOID_P == SIZEOF_SIZE_T
 typedef Py_intptr_t     Py_ssize_t;
+typedef Py_intptr_t     Py_ssize_t;
 #else
 #   error "Python needs a typedef for Py_ssize_t in pyport.h."
 …
    SIZE_MAX is part of C99, so it might be defined on some
    platforms. If it is not defined, (size_t)-1 is a portable
    definition for C89, due to the way signed->unsigned
+   definition for C89, due to the way signed->unsigned
    conversion is defined. */
 #ifdef SIZE_MAX
 …
 #endif
+/* PY_FORMAT_LONG_LONG is analogous to PY_FORMAT_SIZE_T above, but for
+ * the long long type instead of the size_t type.  It's only available
+ * when HAVE_LONG_LONG is defined. The "high level" Python format
+ * functions listed above will interpret "lld" or "llu" correctly on
+ * all platforms.
+ */
+#ifdef HAVE_LONG_LONG
+#   ifndef PY_FORMAT_LONG_LONG
+#       if defined(MS_WIN64) || defined(MS_WINDOWS)
+#           define PY_FORMAT_LONG_LONG "I64"
+#       else
+#           error "This platform's pyconfig.h needs to define PY_FORMAT_LONG_LONG"
+#       endif
+#   endif
+#endif
 /* Py_LOCAL can be used instead of static to get the fastest possible calling
  * convention for functions that are local to a given module.
 …
 #pragma optimize("agtw", on)
 #endif
 /* ignore warnings if the compiler decides not to inline a function */
+/* ignore warnings if the compiler decides not to inline a function */
 #pragma warning(disable: 4710)
 /* fastest possible local call under MSVC */
 …
 #if defined(_MSC_VER)
 #define Py_MEMCPY(target, source, length) do {                          \
                 size_t i_, n_ = (length);                               \
                 char *t_ = (void*) (target);                            \
                 const char *s_ = (void*) (source);                      \
                 if (n_ >= 16)                                           \
                         memcpy(t_, s_, n_);                             \
                 else                                                    \
                         for (i_ = 0; i_ < n_; i_++)                     \
                                 t_[i_] = s_[i_];                        \
         } while (0)
+#define Py_MEMCPY(target, source, length) do {                          \
+        size_t i_, n_ = (length);                                       \
+        char *t_ = (void*) (target);                                    \
+        const char *s_ = (void*) (source);                              \
+        if (n_ >= 16)                                                   \
+            memcpy(t_, s_, n_);                                         \
+        else                                                            \
+            for (i_ = 0; i_ < n_; i_++)                                 \
+                t_[i_] = s_[i_];                                        \
+    } while (0)
 #else
 #define Py_MEMCPY memcpy
 …
 #include <stdlib.h>
+#ifdef HAVE_IEEEFP_H
+#include <ieeefp.h>  /* needed for 'finite' declaration on some platforms */
+#endif
 #include <math.h> /* Moved here from the math section, before extern "C" */
 …
  * or zero-fills.  Here a macro to force sign extension:
  * Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J)
+ *    Return I >> J, forcing sign extension.
+ *    Return I >> J, forcing sign extension.  Arithmetically, return the
+ *    floor of I/2**J.
  * Requirements:
+ *    I is of basic signed type TYPE (char, short, int, long, or long long).
+ *    TYPE is one of char, short, int, long, or long long, although long long
+ *    must not be used except on platforms that support it.
+ *    J is an integer >= 0 and strictly less than the number of bits in TYPE
+ *    (because C doesn't define what happens for J outside that range either).
+ *    I should have signed integer type.  In the terminology of C99, this can
+ *    be either one of the five standard signed integer types (signed char,
+ *    short, int, long, long long) or an extended signed integer type.
+ *    J is an integer >= 0 and strictly less than the number of bits in the
+ *    type of I (because C doesn't define what happens for J outside that
+ *    range either).
+ *    TYPE used to specify the type of I, but is now ignored.  It's been left
+ *    in for backwards compatibility with versions <= 2.6 or 3.0.
  * Caution:
  *    I may be evaluated more than once.
 …
 #ifdef SIGNED_RIGHT_SHIFT_ZERO_FILLS
 #define Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J) \
         ((I) < 0 ? ~((~(unsigned TYPE)(I)) >> (J)) : (I) >> (J))
+    ((I) < 0 ? -1-((-1-(I)) >> (J)) : (I) >> (J))
 #else
 #define Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J) ((I) >> (J))
 …
 #ifdef Py_DEBUG
 #define Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW) \
         (assert((WIDE)(NARROW)(VALUE) == (VALUE)), (NARROW)(VALUE))
+    (assert((WIDE)(NARROW)(VALUE) == (VALUE)), (NARROW)(VALUE))
 #else
 #define Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW) (NARROW)(VALUE)
 …
 #endif
 #define Py_SET_ERRNO_ON_MATH_ERROR(X) \
         do { \
                 if (errno == 0) { \
                         if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL) \
                                 errno = ERANGE; \
                         else _Py_SET_EDOM_FOR_NAN(X) \
                 } \
         } while(0)
+    do { \
+        if (errno == 0) { \
+            if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL) \
+                errno = ERANGE; \
+            else _Py_SET_EDOM_FOR_NAN(X) \
+        } \
+    } while(0)
 /* Py_SET_ERANGE_ON_OVERFLOW(x)
 …
  *    X and Y may be evaluated more than once.
  */
+#define Py_ADJUST_ERANGE1(X)                                            \
+        do {                                                            \
+                if (errno == 0) {                                       \
+                        if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL)  \
+                                errno = ERANGE;                         \
+                }                                                       \
+                else if (errno == ERANGE && (X) == 0.0)                 \
+                        errno = 0;                                      \
+        } while(0)
+#define Py_ADJUST_ERANGE2(X, Y)                                         \
+        do {                                                            \
+                if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL ||        \
+                    (Y) == Py_HUGE_VAL || (Y) == -Py_HUGE_VAL) {        \
+                                if (errno == 0)                         \
+                                        errno = ERANGE;                 \
+                }                                                       \
+                else if (errno == ERANGE)                               \
+                        errno = 0;                                      \
+        } while(0)
+#define Py_ADJUST_ERANGE1(X)                                            \
+    do {                                                                \
+        if (errno == 0) {                                               \
+            if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL)              \
+                errno = ERANGE;                                         \
+        }                                                               \
+        else if (errno == ERANGE && (X) == 0.0)                         \
+            errno = 0;                                                  \
+    } while(0)
+#define Py_ADJUST_ERANGE2(X, Y)                                         \
+    do {                                                                \
+        if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL ||                \
+            (Y) == Py_HUGE_VAL || (Y) == -Py_HUGE_VAL) {                \
+                        if (errno == 0)                                 \
+                                errno = ERANGE;                         \
+        }                                                               \
+        else if (errno == ERANGE)                                       \
+            errno = 0;                                                  \
+    } while(0)
+/*  The functions _Py_dg_strtod and _Py_dg_dtoa in Python/dtoa.c (which are
+ *  required to support the short float repr introduced in Python 3.1) require
+ *  that the floating-point unit that's being used for arithmetic operations
+ *  on C doubles is set to use 53-bit precision.  It also requires that the
+ *  FPU rounding mode is round-half-to-even, but that's less often an issue.
+ *
+ *  If your FPU isn't already set to 53-bit precision/round-half-to-even, and
+ *  you want to make use of _Py_dg_strtod and _Py_dg_dtoa, then you should
+ *
+ *     #define HAVE_PY_SET_53BIT_PRECISION 1
+ *
+ *  and also give appropriate definitions for the following three macros:
+ *
+ *    _PY_SET_53BIT_PRECISION_START : store original FPU settings, and
+ *        set FPU to 53-bit precision/round-half-to-even
+ *    _PY_SET_53BIT_PRECISION_END : restore original FPU settings
+ *    _PY_SET_53BIT_PRECISION_HEADER : any variable declarations needed to
+ *        use the two macros above.
+ *
+ * The macros are designed to be used within a single C function: see
+ * Python/pystrtod.c for an example of their use.
+ */
+/* get and set x87 control word for gcc/x86 */
+#ifdef HAVE_GCC_ASM_FOR_X87
+#define HAVE_PY_SET_53BIT_PRECISION 1
+/* _Py_get/set_387controlword functions are defined in Python/pymath.c */
+#define _Py_SET_53BIT_PRECISION_HEADER                          \
+    unsigned short old_387controlword, new_387controlword
+#define _Py_SET_53BIT_PRECISION_START                                   \
+    do {                                                                \
+        old_387controlword = _Py_get_387controlword();                  \
+        new_387controlword = (old_387controlword & ~0x0f00) | 0x0200; \
+        if (new_387controlword != old_387controlword)                   \
+            _Py_set_387controlword(new_387controlword);                 \
+    } while (0)
+#define _Py_SET_53BIT_PRECISION_END                             \
+    if (new_387controlword != old_387controlword)               \
+        _Py_set_387controlword(old_387controlword)
+#endif
+/* get and set x87 control word for VisualStudio/x86 */
+#if defined(_MSC_VER) && !defined(_WIN64) /* x87 not supported in 64-bit */
+#define HAVE_PY_SET_53BIT_PRECISION 1
+#define _Py_SET_53BIT_PRECISION_HEADER \
+    unsigned int old_387controlword, new_387controlword, out_387controlword
+/* We use the __control87_2 function to set only the x87 control word.
+   The SSE control word is unaffected. */
+#define _Py_SET_53BIT_PRECISION_START                                   \
+    do {                                                                \
+        __control87_2(0, 0, &old_387controlword, NULL);                 \
+        new_387controlword =                                            \
+          (old_387controlword & ~(_MCW_PC | _MCW_RC)) | (_PC_53 | _RC_NEAR); \
+        if (new_387controlword != old_387controlword)                   \
+            __control87_2(new_387controlword, _MCW_PC | _MCW_RC,        \
+                          &out_387controlword, NULL);                   \
+    } while (0)
+#define _Py_SET_53BIT_PRECISION_END                                     \
+    do {                                                                \
+        if (new_387controlword != old_387controlword)                   \
+            __control87_2(old_387controlword, _MCW_PC | _MCW_RC,        \
+                          &out_387controlword, NULL);                   \
+    } while (0)
+#endif
+/* default definitions are empty */
+#ifndef HAVE_PY_SET_53BIT_PRECISION
+#define _Py_SET_53BIT_PRECISION_HEADER
+#define _Py_SET_53BIT_PRECISION_START
+#define _Py_SET_53BIT_PRECISION_END
+#endif
+/* If we can't guarantee 53-bit precision, don't use the code
+   in Python/dtoa.c, but fall back to standard code.  This
+   means that repr of a float will be long (17 sig digits).
+   Realistically, there are two things that could go wrong:
+   (1) doubles aren't IEEE 754 doubles, or
+   (2) we're on x86 with the rounding precision set to 64-bits
+       (extended precision), and we don't know how to change
+       the rounding precision.
+ */
+#if !defined(DOUBLE_IS_LITTLE_ENDIAN_IEEE754) && \
+    !defined(DOUBLE_IS_BIG_ENDIAN_IEEE754) && \
+    !defined(DOUBLE_IS_ARM_MIXED_ENDIAN_IEEE754)
+#define PY_NO_SHORT_FLOAT_REPR
+#endif
+/* double rounding is symptomatic of use of extended precision on x86.  If
+   we're seeing double rounding, and we don't have any mechanism available for
+   changing the FPU rounding precision, then don't use Python/dtoa.c. */
+#if defined(X87_DOUBLE_ROUNDING) && !defined(HAVE_PY_SET_53BIT_PRECISION)
+#define PY_NO_SHORT_FLOAT_REPR
+#endif
 /* Py_DEPRECATED(version)
 …
  */
 #if defined(__GNUC__) && ((__GNUC__ >= 4) || \
                           (__GNUC__ == 3) && (__GNUC_MINOR__ >= 1))
+              (__GNUC__ == 3) && (__GNUC_MINOR__ >= 1))
 #define Py_DEPRECATED(VERSION_UNUSED) __attribute__((__deprecated__))
 #else
 …
 #ifdef HAVE__GETPTY
 #include <sys/types.h>          /* we need to import mode_t */
+#include <sys/types.h>          /* we need to import mode_t */
 extern char * _getpty(int *, int, mode_t, int);
 #endif
 …
    if TCGETA, TCSETA, TCSETAW, or TCSETAF are used.  sys/termio.h must
    be included before termios.h or it will generate an error. */
 #ifdef HAVE_SYS_TERMIO_H
+#if defined(HAVE_SYS_TERMIO_H) && !defined(__hpux)
 #include <sys/termio.h>
 #endif
 #if defined(HAVE_OPENPTY) || defined(HAVE_FORKPTY)
 #if !defined(HAVE_PTY_H) && !defined(HAVE_LIBUTIL_H)
+#if !defined(HAVE_PTY_H) && !defined(HAVE_LIBUTIL_H) && !defined(HAVE_UTIL_H)
 /* BSDI does not supply a prototype for the 'openpty' and 'forkpty'
    functions, even though they are included in libutil. */
 …
 #include <osreldate.h>
 #if __FreeBSD_version > 500039
+# define _PY_PORT_CTYPE_UTF8_ISSUE
+#endif
+#endif
+#if defined(__APPLE__)
+# define _PY_PORT_CTYPE_UTF8_ISSUE
+#endif
+#ifdef _PY_PORT_CTYPE_UTF8_ISSUE
 #include <ctype.h>
 #include <wctype.h>
 …
 #define toupper(c) towupper(btowc(c))
 #endif
-#endif
 …
 */
 #if defined(__CYGWIN__) || defined(__BEOS__)
 #       define HAVE_DECLSPEC_DLL
+#       define HAVE_DECLSPEC_DLL
 #endif
 /* only get special linkage if built as shared or platform is Cygwin */
 #if defined(Py_ENABLE_SHARED) || defined(__CYGWIN__)
+#       if defined(HAVE_DECLSPEC_DLL)
+#               ifdef Py_BUILD_CORE
+#                       define PyAPI_FUNC(RTYPE) __declspec(dllexport) RTYPE
+#                       define PyAPI_DATA(RTYPE) extern __declspec(dllexport) RTYPE
+                        /* module init functions inside the core need no external linkage */
+                        /* except for Cygwin to handle embedding (FIXME: BeOS too?) */
+#                       if defined(__CYGWIN__)
+#                               define PyMODINIT_FUNC __declspec(dllexport) void
+#                       else /* __CYGWIN__ */
+#                               define PyMODINIT_FUNC void
+#                       endif /* __CYGWIN__ */
+#               else /* Py_BUILD_CORE */
+                        /* Building an extension module, or an embedded situation */
+                        /* public Python functions and data are imported */
+                        /* Under Cygwin, auto-import functions to prevent compilation */
+                        /* failures similar to http://python.org/doc/FAQ.html#3.24 */
+#                       if !defined(__CYGWIN__)
+#                               define PyAPI_FUNC(RTYPE) __declspec(dllimport) RTYPE
+#                       endif /* !__CYGWIN__ */
+#                       define PyAPI_DATA(RTYPE) extern __declspec(dllimport) RTYPE
+                        /* module init functions outside the core must be exported */
+#                       if defined(__cplusplus)
+#                               define PyMODINIT_FUNC extern "C" __declspec(dllexport) void
+#                       else /* __cplusplus */
+#                               define PyMODINIT_FUNC __declspec(dllexport) void
+#                       endif /* __cplusplus */
+#               endif /* Py_BUILD_CORE */
+#       endif /* HAVE_DECLSPEC */
+#       if defined(HAVE_DECLSPEC_DLL)
+#               ifdef Py_BUILD_CORE
+#                       define PyAPI_FUNC(RTYPE) __declspec(dllexport) RTYPE
+#                       define PyAPI_DATA(RTYPE) extern __declspec(dllexport) RTYPE
+        /* module init functions inside the core need no external linkage */
+        /* except for Cygwin to handle embedding (FIXME: BeOS too?) */
+#                       if defined(__CYGWIN__)
+#                               define PyMODINIT_FUNC __declspec(dllexport) void
+#                       else /* __CYGWIN__ */
+#                               define PyMODINIT_FUNC void
+#                       endif /* __CYGWIN__ */
+#               else /* Py_BUILD_CORE */
+        /* Building an extension module, or an embedded situation */
+        /* public Python functions and data are imported */
+        /* Under Cygwin, auto-import functions to prevent compilation */
+        /* failures similar to those described at the bottom of 4.1: */
+        /* http://docs.python.org/extending/windows.html#a-cookbook-approach */
+#                       if !defined(__CYGWIN__)
+#                               define PyAPI_FUNC(RTYPE) __declspec(dllimport) RTYPE
+#                       endif /* !__CYGWIN__ */
+#                       define PyAPI_DATA(RTYPE) extern __declspec(dllimport) RTYPE
+        /* module init functions outside the core must be exported */
+#                       if defined(__cplusplus)
+#                               define PyMODINIT_FUNC extern "C" __declspec(dllexport) void
+#                       else /* __cplusplus */
+#                               define PyMODINIT_FUNC __declspec(dllexport) void
+#                       endif /* __cplusplus */
+#               endif /* Py_BUILD_CORE */
+#       endif /* HAVE_DECLSPEC */
 #endif /* Py_ENABLE_SHARED */
 /* If no external linkage macros defined by now, create defaults */
 #ifndef PyAPI_FUNC
 #       define PyAPI_FUNC(RTYPE) RTYPE
+#       define PyAPI_FUNC(RTYPE) RTYPE
 #endif
 #ifndef PyAPI_DATA
 #       define PyAPI_DATA(RTYPE) extern RTYPE
+#       define PyAPI_DATA(RTYPE) extern RTYPE
 #endif
 #ifndef PyMODINIT_FUNC
 #       if defined(__cplusplus)
 #               define PyMODINIT_FUNC extern "C" void
 #       else /* __cplusplus */
 #               define PyMODINIT_FUNC void
 #       endif /* __cplusplus */
+#       if defined(__cplusplus)
+#               define PyMODINIT_FUNC extern "C" void
+#       else /* __cplusplus */
+#               define PyMODINIT_FUNC void
+#       endif /* __cplusplus */
 #endif
 /* Deprecated DL_IMPORT and DL_EXPORT macros */
 #if defined(Py_ENABLE_SHARED) && defined (HAVE_DECLSPEC_DLL)
 #       if defined(Py_BUILD_CORE)
 #               define DL_IMPORT(RTYPE) __declspec(dllexport) RTYPE
 #               define DL_EXPORT(RTYPE) __declspec(dllexport) RTYPE
 #       else
 #               define DL_IMPORT(RTYPE) __declspec(dllimport) RTYPE
 #               define DL_EXPORT(RTYPE) __declspec(dllexport) RTYPE
 #       endif
+#       if defined(Py_BUILD_CORE)
+#               define DL_IMPORT(RTYPE) __declspec(dllexport) RTYPE
+#               define DL_EXPORT(RTYPE) __declspec(dllexport) RTYPE
+#       else
+#               define DL_IMPORT(RTYPE) __declspec(dllimport) RTYPE
+#               define DL_EXPORT(RTYPE) __declspec(dllexport) RTYPE
+#       endif
 #endif
 #ifndef DL_EXPORT
 #       define DL_EXPORT(RTYPE) RTYPE
+#       define DL_EXPORT(RTYPE) RTYPE
 #endif
 #ifndef DL_IMPORT
 #       define DL_IMPORT(RTYPE) RTYPE
+#       define DL_IMPORT(RTYPE) RTYPE
 #endif
 /* End of deprecated DL_* macros */
 …
 #if 0 /* disabled and probably obsolete */
 #ifndef FD_SETSIZE
 #define FD_SETSIZE      256
+#ifndef FD_SETSIZE
+#define FD_SETSIZE      256
 #endif
 …
 typedef long fd_mask;
 #define NFDBITS (sizeof(fd_mask) * NBBY)        /* bits per mask */
+#define NFDBITS (sizeof(fd_mask) * NBBY)        /* bits per mask */
 #ifndef howmany
 #define howmany(x, y)   (((x)+((y)-1))/(y))
+#define howmany(x, y)   (((x)+((y)-1))/(y))
 #endif /* howmany */
 typedef struct fd_set {
         fd_mask fds_bits[howmany(FD_SETSIZE, NFDBITS)];
+typedef struct fd_set {
+    fd_mask     fds_bits[howmany(FD_SETSIZE, NFDBITS)];
 } fd_set;
 #define FD_SET(n, p)    ((p)->fds_bits[(n)/NFDBITS] |= (1 << ((n) % NFDBITS)))
 #define FD_CLR(n, p)    ((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS)))
 #define FD_ISSET(n, p)  ((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS)))
 #define FD_ZERO(p)      memset((char *)(p), '\0', sizeof(*(p)))
+#define FD_SET(n, p)    ((p)->fds_bits[(n)/NFDBITS] |= (1 << ((n) % NFDBITS)))
+#define FD_CLR(n, p)    ((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS)))
+#define FD_ISSET(n, p)  ((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS)))
+#define FD_ZERO(p)      memset((char *)(p), '\0', sizeof(*(p)))
 #endif /* FD_SET */

python/vendor/current/Include/pystate.h

-              r2
+              r388
     long thread_id; /* Thread id where this tstate was created */
+    int trash_delete_nesting;
+    PyObject *trash_delete_later;
     /* XXX signal handlers should also be here */
 …
 PyAPI_FUNC(PyThreadState *) PyThreadState_New(PyInterpreterState *);
+PyAPI_FUNC(PyThreadState *) _PyThreadState_Prealloc(PyInterpreterState *);
+PyAPI_FUNC(void) _PyThreadState_Init(PyThreadState *);
 PyAPI_FUNC(void) PyThreadState_Clear(PyThreadState *);
 PyAPI_FUNC(void) PyThreadState_Delete(PyThreadState *);
 …
 /* Helper/diagnostic function - get the current thread state for
    this thread.  May return NULL if no GILState API has been used
    on the current thread.  Note the main thread always has such a
+   on the current thread.  Note that the main thread always has such a
    thread-state, even if no auto-thread-state call has been made
    on the main thread.

python/vendor/current/Include/pystrtod.h

-              r2
+              r388
 PyAPI_FUNC(double) PyOS_ascii_strtod(const char *str, char **ptr);
 PyAPI_FUNC(double) PyOS_ascii_atof(const char *str);
-PyAPI_FUNC(char *) PyOS_ascii_formatd(char *buffer, size_t buf_len,  const char *format, double d);
+/* Deprecated in 2.7 and 3.1. Will disappear in 2.8 (if it exists) and 3.2 */
+PyAPI_FUNC(char *) PyOS_ascii_formatd(char *buffer, size_t buf_len,
+                                      const char *format, double d);
+PyAPI_FUNC(double) PyOS_string_to_double(const char *str,
+                                         char **endptr,
+                                         PyObject *overflow_exception);
+/* The caller is responsible for calling PyMem_Free to free the buffer
+   that's is returned. */
+PyAPI_FUNC(char *) PyOS_double_to_string(double val,
+                                         char format_code,
+                                         int precision,
+                                         int flags,
+                                         int *type);
+PyAPI_FUNC(double) _Py_parse_inf_or_nan(const char *p, char **endptr);
+/* PyOS_double_to_string's "flags" parameter can be set to 0 or more of: */
+#define Py_DTSF_SIGN      0x01 /* always add the sign */
+#define Py_DTSF_ADD_DOT_0 0x02 /* if the result is an integer add ".0" */
+#define Py_DTSF_ALT       0x04 /* "alternate" formatting. it's format_code
+                                  specific */
+/* PyOS_double_to_string's "type", if non-NULL, will be set to one of: */
+#define Py_DTST_FINITE 0
+#define Py_DTST_INFINITE 1
+#define Py_DTST_NAN 2
 #ifdef __cplusplus

python/vendor/current/Include/pythonrun.h

-              r2
+              r388
 typedef struct {
         int cf_flags;  /* bitmask of CO_xxx flags relevant to future */
+    int cf_flags;  /* bitmask of CO_xxx flags relevant to future */
 } PyCompilerFlags;
 …
 PyAPI_FUNC(int) PyRun_InteractiveLoopFlags(FILE *, const char *, PyCompilerFlags *);
 PyAPI_FUNC(struct _mod *) PyParser_ASTFromString(const char *, const char *,
                                                  int, PyCompilerFlags *flags,
+PyAPI_FUNC(struct _mod *) PyParser_ASTFromString(const char *, const char *,
+                                                 int, PyCompilerFlags *flags,
                                                  PyArena *);
 PyAPI_FUNC(struct _mod *) PyParser_ASTFromFile(FILE *, const char *, int,
                                                char *, char *,
+PyAPI_FUNC(struct _mod *) PyParser_ASTFromFile(FILE *, const char *, int,
+                                               char *, char *,
                                                PyCompilerFlags *, int *,
                                                PyArena *);
 #define PyParser_SimpleParseString(S, B) \
         PyParser_SimpleParseStringFlags(S, B, 0)
+    PyParser_SimpleParseStringFlags(S, B, 0)
 #define PyParser_SimpleParseFile(FP, S, B) \
         PyParser_SimpleParseFileFlags(FP, S, B, 0)
 PyAPI_FUNC(struct _node *) PyParser_SimpleParseStringFlags(const char *, int,
                                                           int);
+    PyParser_SimpleParseFileFlags(FP, S, B, 0)
+PyAPI_FUNC(struct _node *) PyParser_SimpleParseStringFlags(const char *, int,
+                                                          int);
 PyAPI_FUNC(struct _node *) PyParser_SimpleParseFileFlags(FILE *, const char *,
                                                         int, int);
+                                                        int, int);
 PyAPI_FUNC(PyObject *) PyRun_StringFlags(const char *, int, PyObject *,
                                          PyObject *, PyCompilerFlags *);
+PyAPI_FUNC(PyObject *) PyRun_StringFlags(const char *, int, PyObject *,
+                                         PyObject *, PyCompilerFlags *);
 PyAPI_FUNC(PyObject *) PyRun_FileExFlags(FILE *, const char *, int,
+                                         PyObject *, PyObject *, int,
                                          PyCompilerFlags *);
+PyAPI_FUNC(PyObject *) PyRun_FileExFlags(FILE *, const char *, int,
+                                         PyObject *, PyObject *, int,
+                                         PyCompilerFlags *);
 #define Py_CompileString(str, p, s) Py_CompileStringFlags(str, p, s, NULL)
 PyAPI_FUNC(PyObject *) Py_CompileStringFlags(const char *, const char *, int,
                                              PyCompilerFlags *);
+                                             PyCompilerFlags *);
 PyAPI_FUNC(struct symtable *) Py_SymtableString(const char *, const char *, int);
 …
 #define PyRun_AnyFile(fp, name) PyRun_AnyFileExFlags(fp, name, 0, NULL)
 #define PyRun_AnyFileEx(fp, name, closeit) \
         PyRun_AnyFileExFlags(fp, name, closeit, NULL)
+    PyRun_AnyFileExFlags(fp, name, closeit, NULL)
 #define PyRun_AnyFileFlags(fp, name, flags) \
         PyRun_AnyFileExFlags(fp, name, 0, flags)
+    PyRun_AnyFileExFlags(fp, name, 0, flags)
 #define PyRun_SimpleString(s) PyRun_SimpleStringFlags(s, NULL)
 #define PyRun_SimpleFile(f, p) PyRun_SimpleFileExFlags(f, p, 0, NULL)
 …
 #define PyRun_InteractiveLoop(f, p) PyRun_InteractiveLoopFlags(f, p, NULL)
 #define PyRun_File(fp, p, s, g, l) \
         PyRun_FileExFlags(fp, p, s, g, l, 0, NULL)
+    PyRun_FileExFlags(fp, p, s, g, l, 0, NULL)
 #define PyRun_FileEx(fp, p, s, g, l, c) \
         PyRun_FileExFlags(fp, p, s, g, l, c, NULL)
+    PyRun_FileExFlags(fp, p, s, g, l, c, NULL)
 #define PyRun_FileFlags(fp, p, s, g, l, flags) \
         PyRun_FileExFlags(fp, p, s, g, l, 0, flags)
+    PyRun_FileExFlags(fp, p, s, g, l, 0, flags)
 /* In getpath.c */
 …
 PyAPI_FUNC(const char *) Py_SubversionRevision(void);
 PyAPI_FUNC(const char *) Py_SubversionShortBranch(void);
+PyAPI_FUNC(const char *) _Py_hgidentifier(void);
+PyAPI_FUNC(const char *) _Py_hgversion(void);
 /* Internal -- various one-time initializations */
 …
 PyAPI_FUNC(int) _PyFrame_Init(void);
 PyAPI_FUNC(int) _PyInt_Init(void);
+PyAPI_FUNC(int) _PyLong_Init(void);
 PyAPI_FUNC(void) _PyFloat_Init(void);
 PyAPI_FUNC(int) PyByteArray_Init(void);
+PyAPI_FUNC(void) _PyRandom_Init(void);
 /* Various internal finalizers */
 …
 PyAPI_FUNC(PyOS_sighandler_t) PyOS_setsig(int, PyOS_sighandler_t);
+/* Random */
+PyAPI_FUNC(int) _PyOS_URandom (void *buffer, Py_ssize_t size);
 #ifdef __cplusplus

python/vendor/current/Include/pythread.h

-              r2
+              r388
 #ifndef Py_PYTHREAD_H
 #define Py_PYTHREAD_H
-#define NO_EXIT_PROG            /* don't define PyThread_exit_prog() */
-                                /* (the result is no use of signals on SGI) */
 typedef void *PyThread_type_lock;
 …
 PyAPI_FUNC(long) PyThread_start_new_thread(void (*)(void *), void *);
 PyAPI_FUNC(void) PyThread_exit_thread(void);
-PyAPI_FUNC(void) PyThread__PyThread_exit_thread(void);
 PyAPI_FUNC(long) PyThread_get_thread_ident(void);
 …
 PyAPI_FUNC(size_t) PyThread_get_stacksize(void);
 PyAPI_FUNC(int) PyThread_set_stacksize(size_t);
-#ifndef NO_EXIT_PROG
-PyAPI_FUNC(void) PyThread_exit_prog(int);
-PyAPI_FUNC(void) PyThread__PyThread_exit_prog(int);
-#endif
 /* Thread Local Storage (TLS) API */

python/vendor/current/Include/setobject.h

-              r2
+              r388
 typedef struct {
         long hash;      /* cached hash code for the entry key */
         PyObject *key;
+    long hash;      /* cached hash code for the entry key */
+    PyObject *key;
 } setentry;
 …
 typedef struct _setobject PySetObject;
 struct _setobject {
         PyObject_HEAD
+    PyObject_HEAD
         Py_ssize_t fill;  /* # Active + # Dummy */
         Py_ssize_t used;  /* # Active */
+    Py_ssize_t fill;  /* # Active + # Dummy */
+    Py_ssize_t used;  /* # Active */
         /* The table contains mask + 1 slots, and that's a power of 2.
          * We store the mask instead of the size because the mask is more
          * frequently needed.
          */
         Py_ssize_t mask;
+    /* The table contains mask + 1 slots, and that's a power of 2.
+     * We store the mask instead of the size because the mask is more
+     * frequently needed.
+     */
+    Py_ssize_t mask;
         /* table points to smalltable for small tables, else to
          * additional malloc'ed memory.  table is never NULL!  This rule
          * saves repeated runtime null-tests.
          */
         setentry *table;
         setentry *(*lookup)(PySetObject *so, PyObject *key, long hash);
         setentry smalltable[PySet_MINSIZE];
+    /* table points to smalltable for small tables, else to
+     * additional malloc'ed memory.  table is never NULL!  This rule
+     * saves repeated runtime null-tests.
+     */
+    setentry *table;
+    setentry *(*lookup)(PySetObject *so, PyObject *key, long hash);
+    setentry smalltable[PySet_MINSIZE];
         long hash;              /* only used by frozenset objects */
         PyObject *weakreflist;  /* List of weak references */
+    long hash;                  /* only used by frozenset objects */
+    PyObject *weakreflist;      /* List of weak references */
 };
 …
 #define PyFrozenSet_CheckExact(ob) (Py_TYPE(ob) == &PyFrozenSet_Type)
 #define PyAnySet_CheckExact(ob) \
         (Py_TYPE(ob) == &PySet_Type || Py_TYPE(ob) == &PyFrozenSet_Type)
+    (Py_TYPE(ob) == &PySet_Type || Py_TYPE(ob) == &PyFrozenSet_Type)
 #define PyAnySet_Check(ob) \
         (Py_TYPE(ob) == &PySet_Type || Py_TYPE(ob) == &PyFrozenSet_Type || \
           PyType_IsSubtype(Py_TYPE(ob), &PySet_Type) || \
           PyType_IsSubtype(Py_TYPE(ob), &PyFrozenSet_Type))
+    (Py_TYPE(ob) == &PySet_Type || Py_TYPE(ob) == &PyFrozenSet_Type || \
+      PyType_IsSubtype(Py_TYPE(ob), &PySet_Type) || \
+      PyType_IsSubtype(Py_TYPE(ob), &PyFrozenSet_Type))
 #define PySet_Check(ob) \
         (Py_TYPE(ob) == &PySet_Type || \
         PyType_IsSubtype(Py_TYPE(ob), &PySet_Type))
+    (Py_TYPE(ob) == &PySet_Type || \
+    PyType_IsSubtype(Py_TYPE(ob), &PySet_Type))
 #define   PyFrozenSet_Check(ob) \
         (Py_TYPE(ob) == &PyFrozenSet_Type || \
           PyType_IsSubtype(Py_TYPE(ob), &PyFrozenSet_Type))
+    (Py_TYPE(ob) == &PyFrozenSet_Type || \
+      PyType_IsSubtype(Py_TYPE(ob), &PyFrozenSet_Type))
 PyAPI_FUNC(PyObject *) PySet_New(PyObject *);

python/vendor/current/Include/stringobject.h

-              r2
+              r388
     );
 /* Using the current locale, insert the thousands grouping
    into the string pointed to by buffer.  For the argument descriptions,
    see Objects/stringlib/localeutil.h */
+PyAPI_FUNC(int) _PyString_InsertThousandsGrouping(char *buffer,
+                                                  Py_ssize_t n_buffer,
+                                                  Py_ssize_t n_digits,
+                                                  Py_ssize_t buf_size,
+                                                  Py_ssize_t *count,
+                                                  int append_zero_char);
+PyAPI_FUNC(Py_ssize_t) _PyString_InsertThousandsGroupingLocale(char *buffer,
+                                  Py_ssize_t n_buffer,
+                                  char *digits,
+                                  Py_ssize_t n_digits,
+                                  Py_ssize_t min_width);
+/* Using explicit passed-in values, insert the thousands grouping
+   into the string pointed to by buffer.  For the argument descriptions,
+   see Objects/stringlib/localeutil.h */
+PyAPI_FUNC(Py_ssize_t) _PyString_InsertThousandsGrouping(char *buffer,
+                                  Py_ssize_t n_buffer,
+                                  char *digits,
+                                  Py_ssize_t n_digits,
+                                  Py_ssize_t min_width,
+                                  const char *grouping,
+                                  const char *thousands_sep);
 /* Format the object based on the format_spec, as defined in PEP 3101

python/vendor/current/Include/structmember.h

-              r2
+              r388
 struct memberlist {
         /* Obsolete version, for binary backwards compatibility */
         char *name;
         int type;
         int offset;
         int flags;
+    /* Obsolete version, for binary backwards compatibility */
+    char *name;
+    int type;
+    int offset;
+    int flags;
 };
 typedef struct PyMemberDef {
         /* Current version, use this */
         char *name;
         int type;
         Py_ssize_t offset;
         int flags;
         char *doc;
+    /* Current version, use this */
+    char *name;
+    int type;
+    Py_ssize_t offset;
+    int flags;
+    char *doc;
 } PyMemberDef;
 /* Types */
 #define T_SHORT         0
 #define T_INT           1
 #define T_LONG          2
 #define T_FLOAT         3
 #define T_DOUBLE        4
 #define T_STRING        5
 #define T_OBJECT        6
+#define T_SHORT         0
+#define T_INT           1
+#define T_LONG          2
+#define T_FLOAT         3
+#define T_DOUBLE        4
+#define T_STRING        5
+#define T_OBJECT        6
 /* XXX the ordering here is weird for binary compatibility */
 #define T_CHAR          7       /* 1-character string */
 #define T_BYTE          8       /* 8-bit signed int */
+#define T_CHAR          7       /* 1-character string */
+#define T_BYTE          8       /* 8-bit signed int */
 /* unsigned variants: */
 #define T_UBYTE         9
 #define T_USHORT        10
 #define T_UINT          11
 #define T_ULONG         12
+#define T_UBYTE         9
+#define T_USHORT        10
+#define T_UINT          11
+#define T_ULONG         12
 /* Added by Jack: strings contained in the structure */
 #define T_STRING_INPLACE        13
+#define T_STRING_INPLACE        13
 /* Added by Lillo: bools contained in the structure (assumed char) */
 #define T_BOOL          14
+#define T_BOOL          14
 #define T_OBJECT_EX     16      /* Like T_OBJECT, but raises AttributeError
                                    when the value is NULL, instead of
                                    converting to None. */
+#define T_OBJECT_EX     16      /* Like T_OBJECT, but raises AttributeError
+                   when the value is NULL, instead of
+                   converting to None. */
 #ifdef HAVE_LONG_LONG
 #define T_LONGLONG      17
+#define T_LONGLONG      17
 #define T_ULONGLONG      18
 #endif /* HAVE_LONG_LONG */
 …
 /* Flags */
 #define READONLY        1
 #define RO              READONLY                /* Shorthand */
 #define READ_RESTRICTED 2
+#define READONLY        1
+#define RO              READONLY                /* Shorthand */
+#define READ_RESTRICTED 2
 #define PY_WRITE_RESTRICTED 4
 #define RESTRICTED      (READ_RESTRICTED | PY_WRITE_RESTRICTED)
+#define RESTRICTED      (READ_RESTRICTED | PY_WRITE_RESTRICTED)

python/vendor/current/Include/symtable.h

-              r2
+              r388
 struct symtable {
+        const char *st_filename; /* name of file being compiled */
+        struct _symtable_entry *st_cur; /* current symbol table entry */
+        struct _symtable_entry *st_top; /* module entry */
+        PyObject *st_symbols;    /* dictionary of symbol table entries */
+        PyObject *st_stack;      /* stack of namespace info */
+        PyObject *st_global;     /* borrowed ref to MODULE in st_symbols */
+        int st_nblocks;          /* number of blocks */
+        PyObject *st_private;        /* name of current class or NULL */
+        int st_tmpname;          /* temporary name counter */
+        PyFutureFeatures *st_future; /* module's future features */
+    const char *st_filename; /* name of file being compiled */
+    struct _symtable_entry *st_cur; /* current symbol table entry */
+    struct _symtable_entry *st_top; /* module entry */
+    PyObject *st_symbols;    /* dictionary of symbol table entries */
+    PyObject *st_stack;      /* stack of namespace info */
+    PyObject *st_global;     /* borrowed ref to MODULE in st_symbols */
+    int st_nblocks;          /* number of blocks */
+    PyObject *st_private;        /* name of current class or NULL */
+    PyFutureFeatures *st_future; /* module's future features */
 };
 typedef struct _symtable_entry {
         PyObject_HEAD
         PyObject *ste_id;        /* int: key in st_symbols */
         PyObject *ste_symbols;   /* dict: name to flags */
         PyObject *ste_name;      /* string: name of block */
         PyObject *ste_varnames;  /* list of variable names */
         PyObject *ste_children;  /* list of child ids */
         _Py_block_ty ste_type;   /* module, class, or function */
         int ste_unoptimized;     /* false if namespace is optimized */
         int ste_nested;      /* true if block is nested */
         unsigned ste_free : 1;        /* true if block has free variables */
         unsigned ste_child_free : 1;  /* true if a child block has free vars,
                                          including free refs to globals */
         unsigned ste_generator : 1;   /* true if namespace is a generator */
         unsigned ste_varargs : 1;     /* true if block has varargs */
         unsigned ste_varkeywords : 1; /* true if block has varkeywords */
         unsigned ste_returns_value : 1;  /* true if namespace uses return with
                                             an argument */
         int ste_lineno;          /* first line of block */
         int ste_opt_lineno;      /* lineno of last exec or import * */
         int ste_tmpname;         /* counter for listcomp temp vars */
         struct symtable *ste_table;
+    PyObject_HEAD
+    PyObject *ste_id;        /* int: key in st_symbols */
+    PyObject *ste_symbols;   /* dict: name to flags */
+    PyObject *ste_name;      /* string: name of block */
+    PyObject *ste_varnames;  /* list of variable names */
+    PyObject *ste_children;  /* list of child ids */
+    _Py_block_ty ste_type;   /* module, class, or function */
+    int ste_unoptimized;     /* false if namespace is optimized */
+    int ste_nested;      /* true if block is nested */
+    unsigned ste_free : 1;        /* true if block has free variables */
+    unsigned ste_child_free : 1;  /* true if a child block has free vars,
+                                     including free refs to globals */
+    unsigned ste_generator : 1;   /* true if namespace is a generator */
+    unsigned ste_varargs : 1;     /* true if block has varargs */
+    unsigned ste_varkeywords : 1; /* true if block has varkeywords */
+    unsigned ste_returns_value : 1;  /* true if namespace uses return with
+                                        an argument */
+    int ste_lineno;          /* first line of block */
+    int ste_opt_lineno;      /* lineno of last exec or import * */
+    int ste_tmpname;         /* counter for listcomp temp vars */
+    struct symtable *ste_table;
 } PySTEntryObject;
 …
 PyAPI_FUNC(int) PyST_GetScope(PySTEntryObject *, PyObject *);
 PyAPI_FUNC(struct symtable *) PySymtable_Build(mod_ty, const char *,
                                               PyFutureFeatures *);
+PyAPI_FUNC(struct symtable *) PySymtable_Build(mod_ty, const char *,
+                                              PyFutureFeatures *);
 PyAPI_FUNC(PySTEntryObject *) PySymtable_Lookup(struct symtable *, void *);
 …
 #define DEF_PARAM 2<<1         /* formal parameter */
 #define USE 2<<2               /* name is used */
+#define DEF_STAR 2<<3          /* parameter is star arg */
+#define DEF_DOUBLESTAR 2<<4    /* parameter is star-star arg */
+#define DEF_INTUPLE 2<<5       /* name defined in tuple in parameters */
+#define DEF_FREE 2<<6          /* name used but not defined in nested block */
+#define DEF_FREE_GLOBAL 2<<7   /* free variable is actually implicit global */
+#define DEF_FREE_CLASS 2<<8    /* free variable from class's method */
+#define DEF_IMPORT 2<<9        /* assignment occurred via import */
+#define DEF_FREE 2<<3         /* name used but not defined in nested block */
+#define DEF_FREE_CLASS 2<<4    /* free variable from class's method */
+#define DEF_IMPORT 2<<5        /* assignment occurred via import */
 #define DEF_BOUND (DEF_LOCAL | DEF_PARAM | DEF_IMPORT)
 /* GLOBAL_EXPLICIT and GLOBAL_IMPLICIT are used internally by the symbol
    table.  GLOBAL is returned from PyST_GetScope() for either of them.
+   table.  GLOBAL is returned from PyST_GetScope() for either of them.
    It is stored in ste_symbols at bits 12-14.
 */

python/vendor/current/Include/sysmodule.h

-              r2
+              r388
 PyAPI_FUNC(FILE *) PySys_GetFile(char *, FILE *);
 PyAPI_FUNC(void) PySys_SetArgv(int, char **);
+PyAPI_FUNC(void) PySys_SetArgvEx(int, char **, int);
 PyAPI_FUNC(void) PySys_SetPath(char *);
 …
 PyAPI_FUNC(void) PySys_WriteStderr(const char *format, ...)
                         Py_GCC_ATTRIBUTE((format(printf, 1, 2)));
-PyAPI_DATA(PyObject *) _PySys_TraceFunc, *_PySys_ProfileFunc;
-PyAPI_DATA(int) _PySys_CheckInterval;
 PyAPI_FUNC(void) PySys_ResetWarnOptions(void);

python/vendor/current/Include/timefuncs.h

-              r2
+              r388
 PyAPI_FUNC(time_t) _PyTime_DoubleToTimet(double x);
+/* Get the current time since the epoch in seconds */
+PyAPI_FUNC(double) _PyTime_FloatTime(void);
 #ifdef __cplusplus

python/vendor/current/Include/token.h

r2	r388
7	7	extern "C" {
8	8	#endif
	9
	10	#undef TILDE /* Prevent clash of our definition with system macro. Ex AIX, ioctl.h */
9	11
10	12	#define ENDMARKER 0

python/vendor/current/Include/tupleobject.h

r2	r388
45	45	PyAPI_FUNC(int) _PyTuple_Resize(PyObject **, Py_ssize_t);
46	46	PyAPI_FUNC(PyObject *) PyTuple_Pack(Py_ssize_t, ...);
	47	PyAPI_FUNC(void) _PyTuple_MaybeUntrack(PyObject *);
47	48
48	49	/* Macro, trading safety for speed */

python/vendor/current/Include/ucnhash.h

-              r2
+              r388
 #endif
+/* revised ucnhash CAPI interface (exported through a PyCObject) */
+/* revised ucnhash CAPI interface (exported through a "wrapper") */
+#define PyUnicodeData_CAPSULE_NAME "unicodedata.ucnhash_CAPI"
 typedef struct {

python/vendor/current/Include/unicodeobject.h

-              r2
+              r388
  * --------------------------------------------------------------------
  * This Unicode String Type is
+ *
+ *
  * Copyright (c) 1999 by Secret Labs AB
  * Copyright (c) 1999 by Fredrik Lundh
+ *
+ *
  * By obtaining, using, and/or copying this software and/or its
  * associated documentation, you agree that you have read, understood,
  * and will comply with the following terms and conditions:
+ *
+ *
  * Permission to use, copy, modify, and distribute this software and its
  * associated documentation for any purpose and without fee is hereby
 …
  * distribution of the software without specific, written prior
  * permission.
+ *
+ *
  * SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO
  * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
 …
  * as single unsigned integer.
  */
 #if SIZEOF_INT >= 4
 typedef unsigned int Py_UCS4;
+#if SIZEOF_INT >= 4
+typedef unsigned int Py_UCS4;
 #elif SIZEOF_LONG >= 4
 typedef unsigned long Py_UCS4;
+typedef unsigned long Py_UCS4;
 #endif
 …
  */
 #define Py_UNICODE_ISSPACE(ch) \
         ((ch) < 128U ? _Py_ascii_whitespace[(ch)] : _PyUnicode_IsWhitespace(ch))
+    ((ch) < 128U ? _Py_ascii_whitespace[(ch)] : _PyUnicode_IsWhitespace(ch))
 #define Py_UNICODE_ISLOWER(ch) _PyUnicode_IsLowercase(ch)
 …
 #define Py_UNICODE_ISALNUM(ch) \
        (Py_UNICODE_ISALPHA(ch) || \
         Py_UNICODE_ISDECIMAL(ch) || \
         Py_UNICODE_ISDIGIT(ch) || \
         Py_UNICODE_ISNUMERIC(ch))
 #define Py_UNICODE_COPY(target, source, length)                         \
         Py_MEMCPY((target), (source), (length)*sizeof(Py_UNICODE))
+    Py_UNICODE_ISDECIMAL(ch) || \
+    Py_UNICODE_ISDIGIT(ch) || \
+    Py_UNICODE_ISNUMERIC(ch))
+#define Py_UNICODE_COPY(target, source, length)                         \
+    Py_MEMCPY((target), (source), (length)*sizeof(Py_UNICODE))
 #define Py_UNICODE_FILL(target, value, length) \
     do {Py_ssize_t i_; Py_UNICODE *t_ = (target); Py_UNICODE v_ = (value);\
         for (i_ = 0; i_ < (length); i_++) t_[i_] = v_;\
+    for (i_ = 0; i_ < (length); i_++) t_[i_] = v_;\
     } while (0)
 …
 typedef struct {
     PyObject_HEAD
     Py_ssize_t length;          /* Length of raw Unicode data in buffer */
     Py_UNICODE *str;            /* Raw Unicode buffer */
     long hash;                  /* Hash value; -1 if not set */
     PyObject *defenc;           /* (Default) Encoded version as Python
                                    string, or NULL; this is used for
                                    implementing the buffer protocol */
+    Py_ssize_t length;          /* Length of raw Unicode data in buffer */
+    Py_UNICODE *str;            /* Raw Unicode buffer */
+    long hash;                  /* Hash value; -1 if not set */
+    PyObject *defenc;           /* (Default) Encoded version as Python
+                                   string, or NULL; this is used for
+                                   implementing the buffer protocol */
 } PyUnicodeObject;
 …
 /* Fast access macros */
 #define PyUnicode_GET_SIZE(op) \
         (((PyUnicodeObject *)(op))->length)
+    (((PyUnicodeObject *)(op))->length)
 #define PyUnicode_GET_DATA_SIZE(op) \
         (((PyUnicodeObject *)(op))->length * sizeof(Py_UNICODE))
+    (((PyUnicodeObject *)(op))->length * sizeof(Py_UNICODE))
 #define PyUnicode_AS_UNICODE(op) \
         (((PyUnicodeObject *)(op))->str)
+    (((PyUnicodeObject *)(op))->str)
 #define PyUnicode_AS_DATA(op) \
         ((const char *)((PyUnicodeObject *)(op))->str)
+    ((const char *)((PyUnicodeObject *)(op))->str)
 /* --- Constants ---------------------------------------------------------- */
 …
 /* Create a Unicode Object from the Py_UNICODE buffer u of the given
    size.
+   size.
    u may be NULL which causes the contents to be undefined. It is the
 …
 PyAPI_FUNC(Py_UNICODE *) PyUnicode_AsUnicode(
     PyObject *unicode           /* Unicode object */
+    PyObject *unicode           /* Unicode object */
     );
 …
 PyAPI_FUNC(Py_ssize_t) PyUnicode_GetSize(
     PyObject *unicode           /* Unicode object */
+    PyObject *unicode           /* Unicode object */
     );
 …
 PyAPI_FUNC(int) PyUnicode_Resize(
     PyObject **unicode,         /* Pointer to the Unicode object */
     Py_ssize_t length           /* New length */
+    PyObject **unicode,         /* Pointer to the Unicode object */
+    Py_ssize_t length           /* New length */
     );
 …
 PyAPI_FUNC(PyObject*) PyUnicode_FromEncodedObject(
     register PyObject *obj,     /* Object */
+    register PyObject *obj,     /* Object */
     const char *encoding,       /* encoding */
     const char *errors          /* error handling */
 …
 /* Coerce obj to an Unicode object and return a reference with
    *incremented* refcount.
    Unicode objects are passed back as-is (subclasses are converted to
    true Unicode objects), all other objects are delegated to
 …
 PyAPI_FUNC(PyObject*) PyUnicode_FromObject(
     register PyObject *obj      /* Object */
+    register PyObject *obj      /* Object */
     );
 …
    (Advanced String Formatting). */
 PyAPI_FUNC(PyObject *) _PyUnicode_FormatAdvanced(PyObject *obj,
                                                  Py_UNICODE *format_spec,
                                                  Py_ssize_t format_spec_len);
+                                                 Py_UNICODE *format_spec,
+                                                 Py_ssize_t format_spec_len);
 /* --- wchar_t support for platforms which support it --------------------- */
 …
 /* --- Unicode ordinals --------------------------------------------------- */
 /* Create a Unicode Object from the given Unicode code point ordinal.
+/* Create a Unicode Object from the given Unicode code point ordinal.
    The ordinal must be in range(0x10000) on narrow Python builds
    (UCS2), and range(0x110000) on wide builds (UCS4). A ValueError is
 …
 PyAPI_FUNC(int) PyUnicode_ClearFreeList(void);
 /* === Builtin Codecs =====================================================
+/* === Builtin Codecs =====================================================
    Many of these APIs take two arguments encoding and errors. These
    parameters encoding and errors have the same semantics as the ones
    of the builtin unicode() API.
+   of the builtin unicode() API.
    Setting encoding to NULL causes the default encoding to be used.
 …
 /* Return a Python string holding the default encoded value of the
    Unicode object.
+   Unicode object.
    The resulting string is cached in the Unicode object for subsequent
 …
    interpreter to become a parameter which is managed on a per-thread
    basis.
  */
 …
    Returns 0 on success, -1 in case of an error.
  */
 PyAPI_FUNC(int) PyUnicode_SetDefaultEncoding(
     const char *encoding        /* Encoding name in standard form */
+    const char *encoding        /* Encoding name in standard form */
     );
 …
     );
 /* Encodes a Py_UNICODE buffer of the given size and returns a
+/* Encodes a Py_UNICODE buffer of the given size and returns a
    Python string object. */
 …
 PyAPI_FUNC(PyObject*) PyUnicode_AsEncodedObject(
     PyObject *unicode,          /* Unicode object */
     const char *encoding,       /* encoding */
     const char *errors          /* error handling */
+    PyObject *unicode,          /* Unicode object */
+    const char *encoding,       /* encoding */
+    const char *errors          /* error handling */
     );
 …
 PyAPI_FUNC(PyObject*) PyUnicode_AsEncodedString(
     PyObject *unicode,          /* Unicode object */
     const char *encoding,       /* encoding */
     const char *errors          /* error handling */
+    PyObject *unicode,          /* Unicode object */
+    const char *encoding,       /* encoding */
+    const char *errors          /* error handling */
     );
 …
 PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF7(
     const char *string,         /* UTF-7 encoded string */
     Py_ssize_t length,          /* size of string */
     const char *errors          /* error handling */
+    const char *string,         /* UTF-7 encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors          /* error handling */
     );
 PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF7Stateful(
     const char *string,         /* UTF-7 encoded string */
     Py_ssize_t length,          /* size of string */
     const char *errors,         /* error handling */
     Py_ssize_t *consumed        /* bytes consumed */
+    const char *string,         /* UTF-7 encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors,         /* error handling */
+    Py_ssize_t *consumed        /* bytes consumed */
     );
 PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF7(
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length,                  /* number of Py_UNICODE chars to encode */
+    int encodeSetO,             /* force the encoder to encode characters in
+                                   Set O, as described in RFC2152 */
+    int encodeWhiteSpace,       /* force the encoder to encode space, tab,
+                                   carriage return and linefeed characters */
+    const char *errors          /* error handling */
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length,                  /* number of Py_UNICODE chars to encode */
+    int base64SetO,             /* Encode RFC2152 Set O characters in base64 */
+    int base64WhiteSpace,       /* Encode whitespace (sp, ht, nl, cr) in base64 */
+    const char *errors          /* error handling */
     );
 …
 PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF8(
     const char *string,         /* UTF-8 encoded string */
     Py_ssize_t length,          /* size of string */
     const char *errors          /* error handling */
+    const char *string,         /* UTF-8 encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors          /* error handling */
     );
 PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF8Stateful(
     const char *string,         /* UTF-8 encoded string */
     Py_ssize_t length,          /* size of string */
     const char *errors,         /* error handling */
     Py_ssize_t *consumed                /* bytes consumed */
+    const char *string,         /* UTF-8 encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors,         /* error handling */
+    Py_ssize_t *consumed                /* bytes consumed */
     );
 PyAPI_FUNC(PyObject*) PyUnicode_AsUTF8String(
     PyObject *unicode           /* Unicode object */
+    PyObject *unicode           /* Unicode object */
     );
 PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF8(
     const Py_UNICODE *data,     /* Unicode char buffer */
     Py_ssize_t length,                  /* number of Py_UNICODE chars to encode */
     const char *errors          /* error handling */
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length,                  /* number of Py_UNICODE chars to encode */
+    const char *errors          /* error handling */
     );
 …
    errors (if non-NULL) defines the error handling. It defaults
    to "strict".
+   to "strict".
    If byteorder is non-NULL, the decoder starts decoding using the
    given byte order:
         *byteorder == -1: little endian
         *byteorder == 0:  native order
         *byteorder == 1:  big endian
+    *byteorder == -1: little endian
+    *byteorder == 0:  native order
+    *byteorder == 1:  big endian
    In native mode, the first four bytes of the stream are checked for a
 …
 PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF32(
     const char *string,         /* UTF-32 encoded string */
     Py_ssize_t length,          /* size of string */
     const char *errors,         /* error handling */
     int *byteorder              /* pointer to byteorder to use
 =native;-1=LE,1=BE; updated on
                                    exit */
+    const char *string,         /* UTF-32 encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors,         /* error handling */
+    int *byteorder              /* pointer to byteorder to use
+=native;-1=LE,1=BE; updated on
+                                   exit */
     );
 PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF32Stateful(
     const char *string,         /* UTF-32 encoded string */
     Py_ssize_t length,          /* size of string */
     const char *errors,         /* error handling */
     int *byteorder,             /* pointer to byteorder to use
 =native;-1=LE,1=BE; updated on
                                    exit */
     Py_ssize_t *consumed        /* bytes consumed */
+    const char *string,         /* UTF-32 encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors,         /* error handling */
+    int *byteorder,             /* pointer to byteorder to use
+=native;-1=LE,1=BE; updated on
+                                   exit */
+    Py_ssize_t *consumed        /* bytes consumed */
     );
 …
 PyAPI_FUNC(PyObject*) PyUnicode_AsUTF32String(
     PyObject *unicode           /* Unicode object */
+    PyObject *unicode           /* Unicode object */
     );
 …
 PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF32(
     const Py_UNICODE *data,     /* Unicode char buffer */
     Py_ssize_t length,          /* number of Py_UNICODE chars to encode */
     const char *errors,         /* error handling */
     int byteorder               /* byteorder to use 0=BOM+native;-1=LE,1=BE */
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length,          /* number of Py_UNICODE chars to encode */
+    const char *errors,         /* error handling */
+    int byteorder               /* byteorder to use 0=BOM+native;-1=LE,1=BE */
     );
 …
    errors (if non-NULL) defines the error handling. It defaults
    to "strict".
+   to "strict".
    If byteorder is non-NULL, the decoder starts decoding using the
    given byte order:
         *byteorder == -1: little endian
         *byteorder == 0:  native order
         *byteorder == 1:  big endian
+    *byteorder == -1: little endian
+    *byteorder == 0:  native order
+    *byteorder == 1:  big endian
    In native mode, the first two bytes of the stream are checked for a
 …
 PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF16(
     const char *string,         /* UTF-16 encoded string */
     Py_ssize_t length,          /* size of string */
     const char *errors,         /* error handling */
     int *byteorder              /* pointer to byteorder to use
 =native;-1=LE,1=BE; updated on
                                    exit */
+    const char *string,         /* UTF-16 encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors,         /* error handling */
+    int *byteorder              /* pointer to byteorder to use
+=native;-1=LE,1=BE; updated on
+                                   exit */
     );
 PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF16Stateful(
     const char *string,         /* UTF-16 encoded string */
     Py_ssize_t length,          /* size of string */
     const char *errors,         /* error handling */
     int *byteorder,             /* pointer to byteorder to use
 =native;-1=LE,1=BE; updated on
                                    exit */
     Py_ssize_t *consumed                /* bytes consumed */
+    const char *string,         /* UTF-16 encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors,         /* error handling */
+    int *byteorder,             /* pointer to byteorder to use
+=native;-1=LE,1=BE; updated on
+                                   exit */
+    Py_ssize_t *consumed                /* bytes consumed */
     );
 …
 PyAPI_FUNC(PyObject*) PyUnicode_AsUTF16String(
     PyObject *unicode           /* Unicode object */
+    PyObject *unicode           /* Unicode object */
     );
 …
 PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF16(
     const Py_UNICODE *data,     /* Unicode char buffer */
     Py_ssize_t length,                  /* number of Py_UNICODE chars to encode */
     const char *errors,         /* error handling */
     int byteorder               /* byteorder to use 0=BOM+native;-1=LE,1=BE */
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length,                  /* number of Py_UNICODE chars to encode */
+    const char *errors,         /* error handling */
+    int byteorder               /* byteorder to use 0=BOM+native;-1=LE,1=BE */
     );
 …
 PyAPI_FUNC(PyObject*) PyUnicode_DecodeUnicodeEscape(
     const char *string,         /* Unicode-Escape encoded string */
     Py_ssize_t length,          /* size of string */
     const char *errors          /* error handling */
+    const char *string,         /* Unicode-Escape encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors          /* error handling */
     );
 PyAPI_FUNC(PyObject*) PyUnicode_AsUnicodeEscapeString(
     PyObject *unicode           /* Unicode object */
+    PyObject *unicode           /* Unicode object */
     );
 PyAPI_FUNC(PyObject*) PyUnicode_EncodeUnicodeEscape(
     const Py_UNICODE *data,     /* Unicode char buffer */
     Py_ssize_t length                   /* Number of Py_UNICODE chars to encode */
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length                   /* Number of Py_UNICODE chars to encode */
     );
 …
 PyAPI_FUNC(PyObject*) PyUnicode_DecodeRawUnicodeEscape(
     const char *string,         /* Raw-Unicode-Escape encoded string */
     Py_ssize_t length,          /* size of string */
     const char *errors          /* error handling */
+    const char *string,         /* Raw-Unicode-Escape encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors          /* error handling */
     );
 PyAPI_FUNC(PyObject*) PyUnicode_AsRawUnicodeEscapeString(
     PyObject *unicode           /* Unicode object */
+    PyObject *unicode           /* Unicode object */
     );
 PyAPI_FUNC(PyObject*) PyUnicode_EncodeRawUnicodeEscape(
     const Py_UNICODE *data,     /* Unicode char buffer */
     Py_ssize_t length                   /* Number of Py_UNICODE chars to encode */
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length                   /* Number of Py_UNICODE chars to encode */
     );
 …
     );
 /* --- Latin-1 Codecs -----------------------------------------------------
+/* --- Latin-1 Codecs -----------------------------------------------------
    Note: Latin-1 corresponds to the first 256 Unicode ordinals.
 …
 PyAPI_FUNC(PyObject*) PyUnicode_DecodeLatin1(
     const char *string,         /* Latin-1 encoded string */
     Py_ssize_t length,          /* size of string */
     const char *errors          /* error handling */
+    const char *string,         /* Latin-1 encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors          /* error handling */
     );
 PyAPI_FUNC(PyObject*) PyUnicode_AsLatin1String(
     PyObject *unicode           /* Unicode object */
+    PyObject *unicode           /* Unicode object */
     );
 PyAPI_FUNC(PyObject*) PyUnicode_EncodeLatin1(
     const Py_UNICODE *data,     /* Unicode char buffer */
     Py_ssize_t length,                  /* Number of Py_UNICODE chars to encode */
     const char *errors          /* error handling */
     );
 /* --- ASCII Codecs -------------------------------------------------------
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length,                  /* Number of Py_UNICODE chars to encode */
+    const char *errors          /* error handling */
+    );
+/* --- ASCII Codecs -------------------------------------------------------
    Only 7-bit ASCII data is excepted. All other codes generate errors.
 …
 PyAPI_FUNC(PyObject*) PyUnicode_DecodeASCII(
     const char *string,         /* ASCII encoded string */
     Py_ssize_t length,          /* size of string */
     const char *errors          /* error handling */
+    const char *string,         /* ASCII encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors          /* error handling */
     );
 PyAPI_FUNC(PyObject*) PyUnicode_AsASCIIString(
     PyObject *unicode           /* Unicode object */
+    PyObject *unicode           /* Unicode object */
     );
 PyAPI_FUNC(PyObject*) PyUnicode_EncodeASCII(
     const Py_UNICODE *data,     /* Unicode char buffer */
     Py_ssize_t length,                  /* Number of Py_UNICODE chars to encode */
     const char *errors          /* error handling */
     );
 /* --- Character Map Codecs -----------------------------------------------
    This codec uses mappings to encode and decode characters.
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length,                  /* Number of Py_UNICODE chars to encode */
+    const char *errors          /* error handling */
+    );
+/* --- Character Map Codecs -----------------------------------------------
+   This codec uses mappings to encode and decode characters.
    Decoding mappings must map single string characters to single
 …
 PyAPI_FUNC(PyObject*) PyUnicode_DecodeCharmap(
     const char *string,         /* Encoded string */
     Py_ssize_t length,          /* size of string */
     PyObject *mapping,          /* character mapping
                                    (char ordinal -> unicode ordinal) */
     const char *errors          /* error handling */
+    const char *string,         /* Encoded string */
+    Py_ssize_t length,          /* size of string */
+    PyObject *mapping,          /* character mapping
+                                   (char ordinal -> unicode ordinal) */
+    const char *errors          /* error handling */
     );
 PyAPI_FUNC(PyObject*) PyUnicode_AsCharmapString(
     PyObject *unicode,          /* Unicode object */
     PyObject *mapping           /* character mapping
                                    (unicode ordinal -> char ordinal) */
+    PyObject *unicode,          /* Unicode object */
+    PyObject *mapping           /* character mapping
+                                   (unicode ordinal -> char ordinal) */
     );
 PyAPI_FUNC(PyObject*) PyUnicode_EncodeCharmap(
     const Py_UNICODE *data,     /* Unicode char buffer */
     Py_ssize_t length,          /* Number of Py_UNICODE chars to encode */
     PyObject *mapping,          /* character mapping
                                    (unicode ordinal -> char ordinal) */
     const char *errors          /* error handling */
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length,          /* Number of Py_UNICODE chars to encode */
+    PyObject *mapping,          /* character mapping
+                                   (unicode ordinal -> char ordinal) */
+    const char *errors          /* error handling */
     );
 …
    The mapping table must map Unicode ordinal integers to Unicode
    ordinal integers or None (causing deletion of the character).
+   ordinal integers or None (causing deletion of the character).
    Mapping tables may be dictionaries or sequences. Unmapped character
 …
 PyAPI_FUNC(PyObject *) PyUnicode_TranslateCharmap(
     const Py_UNICODE *data,     /* Unicode char buffer */
     Py_ssize_t length,                  /* Number of Py_UNICODE chars to encode */
     PyObject *table,            /* Translate table */
     const char *errors          /* error handling */
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length,                  /* Number of Py_UNICODE chars to encode */
+    PyObject *table,            /* Translate table */
+    const char *errors          /* error handling */
     );
 …
       NULL or "strict": raise a ValueError
       "ignore": ignore the wrong characters (these are not copied to the
                 output buffer)
+                output buffer)
       "replace": replaces illegal characters with '?'
 …
 PyAPI_FUNC(int) PyUnicode_EncodeDecimal(
     Py_UNICODE *s,              /* Unicode buffer */
     Py_ssize_t length,                  /* Number of Py_UNICODE chars to encode */
     char *output,               /* Output buffer; must have size >= length */
     const char *errors          /* error handling */
+    Py_UNICODE *s,              /* Unicode buffer */
+    Py_ssize_t length,                  /* Number of Py_UNICODE chars to encode */
+    char *output,               /* Output buffer; must have size >= length */
+    const char *errors          /* error handling */
     );
 …
 PyAPI_FUNC(PyObject*) PyUnicode_Concat(
     PyObject *left,             /* Left string */
     PyObject *right             /* Right string */
+    PyObject *left,             /* Left string */
+    PyObject *right             /* Right string */
     );
 …
 PyAPI_FUNC(PyObject*) PyUnicode_Split(
     PyObject *s,                /* String to split */
     PyObject *sep,              /* String separator */
     Py_ssize_t maxsplit         /* Maxsplit count */
     );
+    PyObject *s,                /* String to split */
+    PyObject *sep,              /* String separator */
+    Py_ssize_t maxsplit         /* Maxsplit count */
+    );
 /* Dito, but split at line breaks.
 …
    CRLF is considered to be one line break. Line breaks are not
    included in the resulting list. */
 PyAPI_FUNC(PyObject*) PyUnicode_Splitlines(
     PyObject *s,                /* String to split */
     int keepends                /* If true, line end markers are included */
     );
+    PyObject *s,                /* String to split */
+    int keepends                /* If true, line end markers are included */
+    );
 /* Partition a string using a given separator. */
 PyAPI_FUNC(PyObject*) PyUnicode_Partition(
     PyObject *s,                /* String to partition */
     PyObject *sep               /* String separator */
     );
+    PyObject *s,                /* String to partition */
+    PyObject *sep               /* String separator */
+    );
 /* Partition a string using a given separator, searching from the end of the
 …
 PyAPI_FUNC(PyObject*) PyUnicode_RPartition(
     PyObject *s,                /* String to partition */
     PyObject *sep               /* String separator */
     );
+    PyObject *s,                /* String to partition */
+    PyObject *sep               /* String separator */
+    );
 /* Split a string giving a list of Unicode strings.
 …
 PyAPI_FUNC(PyObject*) PyUnicode_RSplit(
     PyObject *s,                /* String to split */
     PyObject *sep,              /* String separator */
     Py_ssize_t maxsplit         /* Maxsplit count */
     );
+    PyObject *s,                /* String to split */
+    PyObject *sep,              /* String separator */
+    Py_ssize_t maxsplit         /* Maxsplit count */
+    );
 /* Translate a string by applying a character mapping table to it and
 …
    The mapping table must map Unicode ordinal integers to Unicode
    ordinal integers or None (causing deletion of the character).
+   ordinal integers or None (causing deletion of the character).
    Mapping tables may be dictionaries or sequences. Unmapped character
 …
 PyAPI_FUNC(PyObject *) PyUnicode_Translate(
     PyObject *str,              /* String */
     PyObject *table,            /* Translate table */
     const char *errors          /* error handling */
+    PyObject *str,              /* String */
+    PyObject *table,            /* Translate table */
+    const char *errors          /* error handling */
     );
 /* Join a sequence of strings using the given separator and return
    the resulting Unicode string. */
 PyAPI_FUNC(PyObject*) PyUnicode_Join(
     PyObject *separator,        /* Separator string */
     PyObject *seq               /* Sequence object */
+    PyObject *separator,        /* Separator string */
+    PyObject *seq               /* Sequence object */
     );
 …
 PyAPI_FUNC(Py_ssize_t) PyUnicode_Tailmatch(
     PyObject *str,              /* String */
     PyObject *substr,           /* Prefix or Suffix string */
     Py_ssize_t start,           /* Start index */
     Py_ssize_t end,             /* Stop index */
     int direction               /* Tail end: -1 prefix, +1 suffix */
+    PyObject *str,              /* String */
+    PyObject *substr,           /* Prefix or Suffix string */
+    Py_ssize_t start,           /* Start index */
+    Py_ssize_t end,             /* Stop index */
+    int direction               /* Tail end: -1 prefix, +1 suffix */
     );
 …
 PyAPI_FUNC(Py_ssize_t) PyUnicode_Find(
     PyObject *str,              /* String */
     PyObject *substr,           /* Substring to find */
     Py_ssize_t start,           /* Start index */
     Py_ssize_t end,             /* Stop index */
     int direction               /* Find direction: +1 forward, -1 backward */
+    PyObject *str,              /* String */
+    PyObject *substr,           /* Substring to find */
+    Py_ssize_t start,           /* Start index */
+    Py_ssize_t end,             /* Stop index */
+    int direction               /* Find direction: +1 forward, -1 backward */
     );
 …
 PyAPI_FUNC(Py_ssize_t) PyUnicode_Count(
     PyObject *str,              /* String */
     PyObject *substr,           /* Substring to count */
     Py_ssize_t start,           /* Start index */
     Py_ssize_t end              /* Stop index */
+    PyObject *str,              /* String */
+    PyObject *substr,           /* Substring to count */
+    Py_ssize_t start,           /* Start index */
+    Py_ssize_t end              /* Stop index */
     );
 …
 PyAPI_FUNC(PyObject *) PyUnicode_Replace(
     PyObject *str,              /* String */
     PyObject *substr,           /* Substring to find */
     PyObject *replstr,          /* Substring to replace */
     Py_ssize_t maxcount         /* Max. number of replacements to apply;
                                    -1 = all */
+    PyObject *str,              /* String */
+    PyObject *substr,           /* Substring to find */
+    PyObject *replstr,          /* Substring to replace */
+    Py_ssize_t maxcount         /* Max. number of replacements to apply;
+                                   -1 = all */
     );
 …
 PyAPI_FUNC(int) PyUnicode_Compare(
     PyObject *left,             /* Left string */
     PyObject *right             /* Right string */
+    PyObject *left,             /* Left string */
+    PyObject *right             /* Right string */
     );
 …
 PyAPI_FUNC(PyObject *) PyUnicode_RichCompare(
     PyObject *left,             /* Left string */
     PyObject *right,            /* Right string */
     int op                      /* Operation: Py_EQ, Py_NE, Py_GT, etc. */
+    PyObject *left,             /* Left string */
+    PyObject *right,            /* Right string */
+    int op                      /* Operation: Py_EQ, Py_NE, Py_GT, etc. */
     );
 …
 PyAPI_FUNC(PyObject *) PyUnicode_Format(
     PyObject *format,           /* Format string */
     PyObject *args              /* Argument tuple or dictionary */
+    PyObject *format,           /* Format string */
+    PyObject *args              /* Argument tuple or dictionary */
     );
 …
 PyAPI_FUNC(int) PyUnicode_Contains(
     PyObject *container,        /* Container string */
     PyObject *element           /* Element string */
+    PyObject *container,        /* Container string */
+    PyObject *element           /* Element string */
     );
 …
 /* These should not be used directly. Use the Py_UNICODE_IS* and
    Py_UNICODE_TO* macros instead.
+   Py_UNICODE_TO* macros instead.
    These APIs are implemented in Objects/unicodectype.c.
 …
 PyAPI_FUNC(int) _PyUnicode_IsLowercase(
     Py_UNICODE ch       /* Unicode character */
+    Py_UNICODE ch       /* Unicode character */
     );
 PyAPI_FUNC(int) _PyUnicode_IsUppercase(
     Py_UNICODE ch       /* Unicode character */
+    Py_UNICODE ch       /* Unicode character */
     );
 PyAPI_FUNC(int) _PyUnicode_IsTitlecase(
     Py_UNICODE ch       /* Unicode character */
+    Py_UNICODE ch       /* Unicode character */
     );
 PyAPI_FUNC(int) _PyUnicode_IsWhitespace(
     const Py_UNICODE ch         /* Unicode character */
+    const Py_UNICODE ch         /* Unicode character */
     );
 PyAPI_FUNC(int) _PyUnicode_IsLinebreak(
     const Py_UNICODE ch         /* Unicode character */
+    const Py_UNICODE ch         /* Unicode character */
     );
 PyAPI_FUNC(Py_UNICODE) _PyUnicode_ToLowercase(
     Py_UNICODE ch       /* Unicode character */
+    Py_UNICODE ch       /* Unicode character */
     );
 PyAPI_FUNC(Py_UNICODE) _PyUnicode_ToUppercase(
     Py_UNICODE ch       /* Unicode character */
+    Py_UNICODE ch       /* Unicode character */
     );
 PyAPI_FUNC(Py_UNICODE) _PyUnicode_ToTitlecase(
     Py_UNICODE ch       /* Unicode character */
+    Py_UNICODE ch       /* Unicode character */
     );
 PyAPI_FUNC(int) _PyUnicode_ToDecimalDigit(
     Py_UNICODE ch       /* Unicode character */
+    Py_UNICODE ch       /* Unicode character */
     );
 PyAPI_FUNC(int) _PyUnicode_ToDigit(
     Py_UNICODE ch       /* Unicode character */
+    Py_UNICODE ch       /* Unicode character */
     );
 PyAPI_FUNC(double) _PyUnicode_ToNumeric(
     Py_UNICODE ch       /* Unicode character */
+    Py_UNICODE ch       /* Unicode character */
     );
 PyAPI_FUNC(int) _PyUnicode_IsDecimalDigit(
     Py_UNICODE ch       /* Unicode character */
+    Py_UNICODE ch       /* Unicode character */
     );
 PyAPI_FUNC(int) _PyUnicode_IsDigit(
     Py_UNICODE ch       /* Unicode character */
+    Py_UNICODE ch       /* Unicode character */
     );
 PyAPI_FUNC(int) _PyUnicode_IsNumeric(
     Py_UNICODE ch       /* Unicode character */
+    Py_UNICODE ch       /* Unicode character */
     );
 PyAPI_FUNC(int) _PyUnicode_IsAlpha(
     Py_UNICODE ch       /* Unicode character */
+    Py_UNICODE ch       /* Unicode character */
     );

python/vendor/current/Include/weakrefobject.h

-              r2
+              r388
          (Py_TYPE(op) == &_PyWeakref_CallableProxyType))
-/* This macro calls PyWeakref_CheckRef() last since that can involve a
-   function call; this makes it more likely that the function call
-   will be avoided. */
 #define PyWeakref_Check(op) \
         (PyWeakref_CheckRef(op) || PyWeakref_CheckProxy(op))
 …
 PyAPI_FUNC(void) _PyWeakref_ClearRef(PyWeakReference *self);
+#define PyWeakref_GET_OBJECT(ref) (((PyWeakReference *)(ref))->wr_object)
+/* Explanation for the Py_REFCNT() check: when a weakref's target is part
+   of a long chain of deallocations which triggers the trashcan mechanism,
+   clearing the weakrefs can be delayed long after the target's refcount
+   has dropped to zero.  In the meantime, code accessing the weakref will
+   be able to "see" the target object even though it is supposed to be
+   unreachable.  See issue #16602. */
+#define PyWeakref_GET_OBJECT(ref)                           \
+    (Py_REFCNT(((PyWeakReference *)(ref))->wr_object) > 0   \
+     ? ((PyWeakReference *)(ref))->wr_object                \
+     : Py_None)

Context Navigation

Legend:

Download in other formats: