Merged revisions 71920-71923,71925-71929,71931-71934,71937 via svnmerge from

svn+ssh://pythondev@svn.python.org/python/trunk

........
  r71920 | jeroen.ruigrok | 2009-04-25 21:44:55 +0200 (za, 25 apr 2009) | 5 lines

  Issue #4129: More documentation pointers about int -> Py_ssize_t.
  Also fix up the documentation for PyObject_GC_Resize(). It seems that since
  it first got documented, the documentation was actually for
  _PyObject_GC_Resize().
........
  r71921 | jeroen.ruigrok | 2009-04-25 21:46:19 +0200 (za, 25 apr 2009) | 2 lines

  Issue #4129: Documentation notes for int -> Py_ssize_t changes.
........
  r71922 | jeroen.ruigrok | 2009-04-25 21:49:05 +0200 (za, 25 apr 2009) | 2 lines

  Reformat, since I've been busy here anyway.
........
  r71923 | jeroen.ruigrok | 2009-04-25 21:54:34 +0200 (za, 25 apr 2009) | 2 lines

  Issue #4129: Add a versionchanged notice for a few forgotten entries.
........
  r71925 | jeroen.ruigrok | 2009-04-25 22:37:39 +0200 (za, 25 apr 2009) | 2 lines

  Since it's a macro, actually refer to it as such instead of function.
........
  r71926 | jeroen.ruigrok | 2009-04-25 22:40:10 +0200 (za, 25 apr 2009) | 2 lines

  Reformat prior to editing.
........
  r71927 | jeroen.ruigrok | 2009-04-25 22:41:40 +0200 (za, 25 apr 2009) | 2 lines

  Issue #4129: int -> Py_ssize_t documentation.
........
  r71928 | jeroen.ruigrok | 2009-04-25 22:43:30 +0200 (za, 25 apr 2009) | 2 lines

  Reformat prior to editing.
........
  r71929 | jeroen.ruigrok | 2009-04-25 22:44:58 +0200 (za, 25 apr 2009) | 2 lines

  Issue #4129: int -> Py_ssize_t documentation.
........
  r71931 | jeroen.ruigrok | 2009-04-25 22:50:27 +0200 (za, 25 apr 2009) | 2 lines

  Issue #4129: int -> Py_ssize_t documentation.
........
  r71932 | jeroen.ruigrok | 2009-04-25 22:55:39 +0200 (za, 25 apr 2009) | 2 lines

  Issue #4129: more int -> Py_ssize_t documentation.
........
  r71933 | jeroen.ruigrok | 2009-04-25 22:58:35 +0200 (za, 25 apr 2009) | 2 lines

  Issue #4129: more int -> Py_ssize_t documentation.
........
  r71934 | jeroen.ruigrok | 2009-04-25 23:02:34 +0200 (za, 25 apr 2009) | 2 lines

  Issue #4129: field changed from int to Py_ssize_t.
........
  r71937 | jeroen.ruigrok | 2009-04-25 23:16:05 +0200 (za, 25 apr 2009) | 2 lines

  Issue #4129: document int -> Py_ssize_t changes.
........

9 files changed, 283 insertions, 76 deletions

diff --git a/Doc/c-api/allocation.rst b/Doc/c-api/allocation.rst
index 3f16730..32397b3 100644
--- a/Doc/c-api/allocation.rst
+++ b/Doc/c-api/allocation.rst
@@ -30,6 +30,10 @@ Allocating Objects on the Heap
    This does everything :cfunc:`PyObject_Init` does, and also initializes the
    length information for a variable-size object.
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+
 
 .. cfunction:: TYPE* PyObject_New(TYPE, PyTypeObject *type)
 
@@ -51,6 +55,10 @@ Allocating Objects on the Heap
    fields into the same allocation decreases the number of allocations,
    improving the memory management efficiency.
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+
 
 .. cfunction:: void PyObject_Del(PyObject *op)
 
diff --git a/Doc/c-api/gcsupport.rst b/Doc/c-api/gcsupport.rst
index dd75191..b7be993 100644
--- a/Doc/c-api/gcsupport.rst
+++ b/Doc/c-api/gcsupport.rst
@@ -45,12 +45,20 @@ Constructors for container types must conform to two rules:
    Analogous to :cfunc:`PyObject_NewVar` but for container objects with the
    :const:`Py_TPFLAGS_HAVE_GC` flag set.
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
 
-.. cfunction:: PyVarObject * PyObject_GC_Resize(PyVarObject *op, Py_ssize_t)
+
+.. cfunction:: TYPE* PyObject_GC_Resize(TYPE, PyVarObject *op, Py_ssize_t newsize)
 
    Resize an object allocated by :cfunc:`PyObject_NewVar`.  Returns the
    resized object or *NULL* on failure.
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *newsize*. This might
+      require changes in your code for properly supporting 64-bit systems.
+
 
 .. cfunction:: void PyObject_GC_Track(PyObject *op)
 
diff --git a/Doc/c-api/list.rst b/Doc/c-api/list.rst
index e2990e7..e971d36 100644
--- a/Doc/c-api/list.rst
+++ b/Doc/c-api/list.rst
@@ -17,8 +17,9 @@ List Objects
 
    .. index:: single: ListType (in module types)
 
-   This instance of :ctype:`PyTypeObject` represents the Python list type.  This is
-   the same object as ``list`` and ``types.ListType`` in the Python layer.
+   This instance of :ctype:`PyTypeObject` represents the Python list type.
+   This is the same object as ``list`` and ``types.ListType`` in the Python
+   layer.
 
 
 .. cfunction:: int PyList_Check(PyObject *p)
@@ -29,8 +30,8 @@ List Objects
 
 .. cfunction:: int PyList_CheckExact(PyObject *p)
 
-   Return true if *p* is a list object, but not an instance of a subtype of the
-   list type.
+   Return true if *p* is a list object, but not an instance of a subtype of
+   the list type.
 
 
 .. cfunction:: PyObject* PyList_New(Py_ssize_t len)
@@ -39,10 +40,10 @@ List Objects
 
    .. note::
 
-      If *length* is greater than zero, the returned list object's items are set to
-      ``NULL``.  Thus you cannot use abstract API functions such as
-      :cfunc:`PySequence_SetItem`  or expose the object to Python code before setting
-      all items to a real object with :cfunc:`PyList_SetItem`.
+      If *length* is greater than zero, the returned list object's items are
+      set to ``NULL``.  Thus you cannot use abstract API functions such as
+      :cfunc:`PySequence_SetItem`  or expose the object to Python code before
+      setting all items to a real object with :cfunc:`PyList_SetItem`.
 
    .. versionchanged:: 2.5
       This function used an :ctype:`int` for *size*. This might require
@@ -65,12 +66,17 @@ List Objects
 
    Macro form of :cfunc:`PyList_Size` without error checking.
 
+   .. versionchanged:: 2.5
+      This macro returned an :ctype:`int`. This might require changes in your
+      code for properly supporting 64-bit systems.
+
 
 .. cfunction:: PyObject* PyList_GetItem(PyObject *list, Py_ssize_t index)
 
-   Return the object at position *pos* in the list pointed to by *p*.  The position
-   must be positive, indexing from the end of the list is not supported.  If *pos*
-   is out of bounds, return *NULL* and set an :exc:`IndexError` exception.
+   Return the object at position *pos* in the list pointed to by *p*.  The
+   position must be positive, indexing from the end of the list is not
+   supported.  If *pos* is out of bounds, return *NULL* and set an
+   :exc:`IndexError` exception.
 
    .. versionchanged:: 2.5
       This function used an :ctype:`int` for *index*. This might require
@@ -81,16 +87,20 @@ List Objects
 
    Macro form of :cfunc:`PyList_GetItem` without error checking.
 
+   .. versionchanged:: 2.5
+      This macro used an :ctype:`int` for *i*. This might require changes in
+      your code for properly supporting 64-bit systems.
+
 
 .. cfunction:: int PyList_SetItem(PyObject *list, Py_ssize_t index, PyObject *item)
 
-   Set the item at index *index* in list to *item*.  Return ``0`` on success or
-   ``-1`` on failure.
+   Set the item at index *index* in list to *item*.  Return ``0`` on success
+   or ``-1`` on failure.
 
    .. note::
 
-      This function "steals" a reference to *item* and discards a reference to an item
-      already in the list at the affected position.
+      This function "steals" a reference to *item* and discards a reference to
+      an item already in the list at the affected position.
 
    .. versionchanged:: 2.5
       This function used an :ctype:`int` for *index*. This might require
@@ -99,21 +109,26 @@ List Objects
 
 .. cfunction:: void PyList_SET_ITEM(PyObject *list, Py_ssize_t i, PyObject *o)
 
-   Macro form of :cfunc:`PyList_SetItem` without error checking. This is normally
-   only used to fill in new lists where there is no previous content.
+   Macro form of :cfunc:`PyList_SetItem` without error checking. This is
+   normally only used to fill in new lists where there is no previous content.
 
    .. note::
 
-      This function "steals" a reference to *item*, and, unlike
-      :cfunc:`PyList_SetItem`, does *not* discard a reference to any item that it
-      being replaced; any reference in *list* at position *i* will be leaked.
+      This macro "steals" a reference to *item*, and, unlike
+      :cfunc:`PyList_SetItem`, does *not* discard a reference to any item that
+      is being replaced; any reference in *list* at position *i* will be
+      leaked.
+
+   .. versionchanged:: 2.5
+      This macro used an :ctype:`int` for *i*. This might require
+      changes in your code for properly supporting 64-bit systems.
 
 
 .. cfunction:: int PyList_Insert(PyObject *list, Py_ssize_t index, PyObject *item)
 
-   Insert the item *item* into list *list* in front of index *index*.  Return ``0``
-   if successful; return ``-1`` and set an exception if unsuccessful.  Analogous to
-   ``list.insert(index, item)``.
+   Insert the item *item* into list *list* in front of index *index*.  Return
+   ``0`` if successful; return ``-1`` and set an exception if unsuccessful.
+   Analogous to ``list.insert(index, item)``.
 
    .. versionchanged:: 2.5
       This function used an :ctype:`int` for *index*. This might require
@@ -122,16 +137,16 @@ List Objects
 
 .. cfunction:: int PyList_Append(PyObject *list, PyObject *item)
 
-   Append the object *item* at the end of list *list*. Return ``0`` if successful;
-   return ``-1`` and set an exception if unsuccessful.  Analogous to
-   ``list.append(item)``.
+   Append the object *item* at the end of list *list*. Return ``0`` if
+   successful; return ``-1`` and set an exception if unsuccessful.  Analogous
+   to ``list.append(item)``.
 
 
 .. cfunction:: PyObject* PyList_GetSlice(PyObject *list, Py_ssize_t low, Py_ssize_t high)
 
-   Return a list of the objects in *list* containing the objects *between* *low*
-   and *high*.  Return *NULL* and set an exception if unsuccessful. Analogous to
-   ``list[low:high]``.
+   Return a list of the objects in *list* containing the objects *between*
+   *low* and *high*.  Return *NULL* and set an exception if unsuccessful.
+   Analogous to ``list[low:high]``.
 
    .. versionchanged:: 2.5
       This function used an :ctype:`int` for *low* and *high*. This might
@@ -140,10 +155,10 @@ List Objects
 
 .. cfunction:: int PyList_SetSlice(PyObject *list, Py_ssize_t low, Py_ssize_t high, PyObject *itemlist)
 
-   Set the slice of *list* between *low* and *high* to the contents of *itemlist*.
-   Analogous to ``list[low:high] = itemlist``. The *itemlist* may be *NULL*,
-   indicating the assignment of an empty list (slice deletion). Return ``0`` on
-   success, ``-1`` on failure.
+   Set the slice of *list* between *low* and *high* to the contents of
+   *itemlist*.  Analogous to ``list[low:high] = itemlist``. The *itemlist* may
+   be *NULL*, indicating the assignment of an empty list (slice deletion).
+   Return ``0`` on success, ``-1`` on failure.
 
    .. versionchanged:: 2.5
       This function used an :ctype:`int` for *low* and *high*. This might
@@ -152,8 +167,8 @@ List Objects
 
 .. cfunction:: int PyList_Sort(PyObject *list)
 
-   Sort the items of *list* in place.  Return ``0`` on success, ``-1`` on failure.
-   This is equivalent to ``list.sort()``.
+   Sort the items of *list* in place.  Return ``0`` on success, ``-1`` on
+   failure.  This is equivalent to ``list.sort()``.
 
 
 .. cfunction:: int PyList_Reverse(PyObject *list)
diff --git a/Doc/c-api/marshal.rst b/Doc/c-api/marshal.rst
index 6d9879c..16c9fc3 100644
--- a/Doc/c-api/marshal.rst
+++ b/Doc/c-api/marshal.rst
@@ -5,24 +5,25 @@
 Data marshalling support
 ========================
 
-These routines allow C code to work with serialized objects using the same data
-format as the :mod:`marshal` module.  There are functions to write data into the
-serialization format, and additional functions that can be used to read the data
-back.  Files used to store marshalled data must be opened in binary mode.
+These routines allow C code to work with serialized objects using the same
+data format as the :mod:`marshal` module.  There are functions to write data
+into the serialization format, and additional functions that can be used to
+read the data back.  Files used to store marshalled data must be opened in
+binary mode.
 
 Numeric values are stored with the least significant byte first.
 
-The module supports two versions of the data format: version 0 is the historical
-version, version 1 shares interned strings in the file, and upon unmarshalling.
-Version 2 uses a binary format for floating point numbers.
+The module supports two versions of the data format: version 0 is the
+historical version, version 1 shares interned strings in the file, and upon
+unmarshalling.  Version 2 uses a binary format for floating point numbers.
 *Py_MARSHAL_VERSION* indicates the current file format (currently 2).
 
 
 .. cfunction:: void PyMarshal_WriteLongToFile(long value, FILE *file, int version)
 
-   Marshal a :ctype:`long` integer, *value*, to *file*.  This will only write the
-   least-significant 32 bits of *value*; regardless of the size of the native
-   :ctype:`long` type.  *version* indicates the file format.
+   Marshal a :ctype:`long` integer, *value*, to *file*.  This will only write
+   the least-significant 32 bits of *value*; regardless of the size of the
+   native :ctype:`long` type.  *version* indicates the file format.
 
 
 .. cfunction:: void PyMarshal_WriteObjectToFile(PyObject *value, FILE *file, int version)
@@ -40,24 +41,24 @@ Version 2 uses a binary format for floating point numbers.
 The following functions allow marshalled values to be read back in.
 
 XXX What about error detection?  It appears that reading past the end of the
-file will always result in a negative numeric value (where that's relevant), but
-it's not clear that negative values won't be handled properly when there's no
-error.  What's the right way to tell? Should only non-negative values be written
-using these routines?
+file will always result in a negative numeric value (where that's relevant),
+but it's not clear that negative values won't be handled properly when there's
+no error.  What's the right way to tell? Should only non-negative values be
+written using these routines?
 
 
 .. cfunction:: long PyMarshal_ReadLongFromFile(FILE *file)
 
-   Return a C :ctype:`long` from the data stream in a :ctype:`FILE\*` opened for
-   reading.  Only a 32-bit value can be read in using this function, regardless of
-   the native size of :ctype:`long`.
+   Return a C :ctype:`long` from the data stream in a :ctype:`FILE\*` opened
+   for reading.  Only a 32-bit value can be read in using this function,
+   regardless of the native size of :ctype:`long`.
 
 
 .. cfunction:: int PyMarshal_ReadShortFromFile(FILE *file)
 
-   Return a C :ctype:`short` from the data stream in a :ctype:`FILE\*` opened for
-   reading.  Only a 16-bit value can be read in using this function, regardless of
-   the native size of :ctype:`short`.
+   Return a C :ctype:`short` from the data stream in a :ctype:`FILE\*` opened
+   for reading.  Only a 16-bit value can be read in using this function,
+   regardless of the native size of :ctype:`short`.
 
 
 .. cfunction:: PyObject* PyMarshal_ReadObjectFromFile(FILE *file)
@@ -70,17 +71,22 @@ using these routines?
 .. cfunction:: PyObject* PyMarshal_ReadLastObjectFromFile(FILE *file)
 
    Return a Python object from the data stream in a :ctype:`FILE\*` opened for
-   reading.  Unlike :cfunc:`PyMarshal_ReadObjectFromFile`, this function assumes
-   that no further objects will be read from the file, allowing it to aggressively
-   load file data into memory so that the de-serialization can operate from data in
-   memory rather than reading a byte at a time from the file.  Only use these
-   variant if you are certain that you won't be reading anything else from the
-   file.  On error, sets the appropriate exception (:exc:`EOFError` or
-   :exc:`TypeError`) and returns *NULL*.
+   reading.  Unlike :cfunc:`PyMarshal_ReadObjectFromFile`, this function
+   assumes that no further objects will be read from the file, allowing it to
+   aggressively load file data into memory so that the de-serialization can
+   operate from data in memory rather than reading a byte at a time from the
+   file.  Only use these variant if you are certain that you won't be reading
+   anything else from the file.  On error, sets the appropriate exception
+   (:exc:`EOFError` or :exc:`TypeError`) and returns *NULL*.
 
 
 .. cfunction:: PyObject* PyMarshal_ReadObjectFromString(char *string, Py_ssize_t len)
 
-   Return a Python object from the data stream in a character buffer containing
-   *len* bytes pointed to by *string*.  On error, sets the appropriate exception
-   (:exc:`EOFError` or :exc:`TypeError`) and returns *NULL*.
+   Return a Python object from the data stream in a character buffer
+   containing *len* bytes pointed to by *string*.  On error, sets the
+   appropriate exception (:exc:`EOFError` or :exc:`TypeError`) and returns
+   *NULL*.
+
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *len*. This might require
+      changes in your code for properly supporting 64-bit systems.
diff --git a/Doc/c-api/objbuffer.rst b/Doc/c-api/objbuffer.rst
index 3c5dc99..e816c3d 100644
--- a/Doc/c-api/objbuffer.rst
+++ b/Doc/c-api/objbuffer.rst
@@ -10,17 +10,26 @@ Buffer Protocol
 
    Returns a pointer to a read-only memory location usable as character-based
    input.  The *obj* argument must support the single-segment character buffer
-   interface.  On success, returns ``0``, sets *buffer* to the memory location and
-   *buffer_len* to the buffer length.  Returns ``-1`` and sets a :exc:`TypeError`
-   on error.
+   interface.  On success, returns ``0``, sets *buffer* to the memory location
+   and *buffer_len* to the buffer length.  Returns ``-1`` and sets a
+   :exc:`TypeError` on error.
+
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int *` type for *buffer_len*. This might
+      require changes in your code for properly supporting 64-bit systems.
 
 
 .. cfunction:: int PyObject_AsReadBuffer(PyObject *obj, const void **buffer, Py_ssize_t *buffer_len)
 
-   Returns a pointer to a read-only memory location containing arbitrary data.  The
-   *obj* argument must support the single-segment readable buffer interface.  On
-   success, returns ``0``, sets *buffer* to the memory location and *buffer_len* to
-   the buffer length.  Returns ``-1`` and sets a :exc:`TypeError` on error.
+   Returns a pointer to a read-only memory location containing arbitrary data.
+   The *obj* argument must support the single-segment readable buffer
+   interface.  On success, returns ``0``, sets *buffer* to the memory location
+   and *buffer_len* to the buffer length.  Returns ``-1`` and sets a
+   :exc:`TypeError` on error.
+
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int *` type for *buffer_len*. This might
+      require changes in your code for properly supporting 64-bit systems.
 
 
 .. cfunction:: int PyObject_CheckReadBuffer(PyObject *o)
@@ -32,6 +41,11 @@ Buffer Protocol
 .. cfunction:: int PyObject_AsWriteBuffer(PyObject *obj, void **buffer, Py_ssize_t *buffer_len)
 
    Returns a pointer to a writable memory location.  The *obj* argument must
-   support the single-segment, character buffer interface.  On success, returns
-   ``0``, sets *buffer* to the memory location and *buffer_len* to the buffer
-   length.  Returns ``-1`` and sets a :exc:`TypeError` on error.
+   support the single-segment, character buffer interface.  On success,
+   returns ``0``, sets *buffer* to the memory location and *buffer_len* to the
+   buffer length.  Returns ``-1`` and sets a :exc:`TypeError` on error.
+
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int *` type for *buffer_len*. This might
+      require changes in your code for properly supporting 64-bit systems.
+
diff --git a/Doc/c-api/sequence.rst b/Doc/c-api/sequence.rst
index 132c100..b3e76b7 100644
--- a/Doc/c-api/sequence.rst
+++ b/Doc/c-api/sequence.rst
@@ -178,6 +178,10 @@ Sequence Protocol
    Return the *i*th element of *o*, assuming that *o* was returned by
    :cfunc:`PySequence_Fast`, *o* is not *NULL*, and that *i* is within bounds.
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *i*. This might require
+      changes in your code for properly supporting 64-bit systems.
+
 
 .. cfunction:: PyObject** PySequence_Fast_ITEMS(PyObject *o)
 
@@ -196,6 +200,10 @@ Sequence Protocol
    :cfunc:`PySequence_Check(o)` is true and without adjustment for negative
    indices.
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *i*. This might require
+      changes in your code for properly supporting 64-bit systems.
+
 
 .. cfunction:: Py_ssize_t PySequence_Fast_GET_SIZE(PyObject *o)
 
diff --git a/Doc/c-api/tuple.rst b/Doc/c-api/tuple.rst
index 77e6e8b..5cfab9c 100644
--- a/Doc/c-api/tuple.rst
+++ b/Doc/c-api/tuple.rst
@@ -67,6 +67,10 @@ Tuple Objects
    Return the size of the tuple *p*, which must be non-*NULL* and point to a tuple;
    no error checking is performed.
 
+   .. versionchanged:: 2.5
+      This function returned an :ctype:`int` type. This might require changes
+      in your code for properly supporting 64-bit systems.
+
 
 .. cfunction:: PyObject* PyTuple_GetItem(PyObject *p, Py_ssize_t pos)
 
@@ -82,6 +86,10 @@ Tuple Objects
 
    Like :cfunc:`PyTuple_GetItem`, but does no checking of its arguments.
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *pos*. This might require
+      changes in your code for properly supporting 64-bit systems.
+
 
 .. cfunction:: PyObject* PyTuple_GetSlice(PyObject *p, Py_ssize_t low, Py_ssize_t high)
 
@@ -116,6 +124,10 @@ Tuple Objects
 
       This function "steals" a reference to *o*.
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *pos*. This might require
+      changes in your code for properly supporting 64-bit systems.
+
 
 .. cfunction:: int _PyTuple_Resize(PyObject **p, Py_ssize_t newsize)
 
diff --git a/Doc/c-api/typeobj.rst b/Doc/c-api/typeobj.rst
index eba8d69..81ef922 100644
--- a/Doc/c-api/typeobj.rst
+++ b/Doc/c-api/typeobj.rst
@@ -64,6 +64,10 @@ type objects) *must* have the :attr:`ob_size` field.
 
    This field is not inherited by subtypes.
 
+   .. versionchanged:: 2.5
+      This field used to be an :ctype:`int` type. This might require changes
+      in your code for properly supporting 64-bit systems.
+
 
 .. cmember:: PyTypeObject* PyObject.ob_type
 
diff --git a/Doc/c-api/unicode.rst b/Doc/c-api/unicode.rst
index 011a6cd..5526e99 100644
--- a/Doc/c-api/unicode.rst
+++ b/Doc/c-api/unicode.rst
@@ -65,12 +65,20 @@ access internal read-only data of Unicode objects:
    Return the size of the object.  *o* has to be a :ctype:`PyUnicodeObject` (not
    checked).
 
+   .. versionchanged:: 2.5
+      This function returned an :ctype:`int` type. This might require changes
+      in your code for properly supporting 64-bit systems.
+
 
 .. cfunction:: Py_ssize_t PyUnicode_GET_DATA_SIZE(PyObject *o)
 
    Return the size of the object's internal buffer in bytes.  *o* has to be a
    :ctype:`PyUnicodeObject` (not checked).
 
+   .. versionchanged:: 2.5
+      This function returned an :ctype:`int` type. This might require changes
+      in your code for properly supporting 64-bit systems.
+
 
 .. cfunction:: Py_UNICODE* PyUnicode_AS_UNICODE(PyObject *o)
 
@@ -206,6 +214,9 @@ APIs:
    Therefore, modification of the resulting Unicode object is only allowed when *u*
    is *NULL*.
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
 
 .. cfunction:: PyObject* PyUnicode_FromStringAndSize(const char *u, Py_ssize_t size)
 
@@ -317,6 +328,10 @@ APIs:
 
    Return the length of the Unicode object.
 
+   .. versionchanged:: 2.5
+      This function returned an :ctype:`int` type. This might require changes
+      in your code for properly supporting 64-bit systems.
+
 
 .. cfunction:: PyObject* PyUnicode_FromEncodedObject(PyObject *obj, const char *encoding, const char *errors)
 
@@ -355,6 +370,10 @@ the system's :ctype:`wchar_t`.
    using wcslen.
    Return *NULL* on failure.
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+
 
 .. cfunction:: Py_ssize_t PyUnicode_AsWideChar(PyUnicodeObject *unicode, wchar_t *w, Py_ssize_t size)
 
@@ -366,6 +385,11 @@ the system's :ctype:`wchar_t`.
    to make sure that the :ctype:`wchar_t` string is 0-terminated in case this is
    required by the application.
 
+   .. versionchanged:: 2.5
+      This function returned an :ctype:`int` type and used an :ctype:`int`
+      type for *size*. This might require changes in your code for properly
+      supporting 64-bit systems.
+
 
 .. _builtincodecs:
 
@@ -405,6 +429,10 @@ These are the generic codec APIs:
    using the Python codec registry.  Return *NULL* if an exception was raised by
    the codec.
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+
 
 .. cfunction:: PyObject* PyUnicode_Encode(const Py_UNICODE *s, Py_ssize_t size, const char *encoding, const char *errors)
 
@@ -414,6 +442,10 @@ These are the generic codec APIs:
    to be used is looked up using the Python codec registry.  Return *NULL* if an
    exception was raised by the codec.
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+
 
 .. cfunction:: PyObject* PyUnicode_AsEncodedString(PyObject *unicode, const char *encoding, const char *errors)
 
@@ -433,6 +465,10 @@ These are the UTF-8 codec APIs:
    Create a Unicode object by decoding *size* bytes of the UTF-8 encoded string
    *s*. Return *NULL* if an exception was raised by the codec.
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+
 
 .. cfunction:: PyObject* PyUnicode_DecodeUTF8Stateful(const char *s, Py_ssize_t size, const char *errors, Py_ssize_t *consumed)
 
@@ -441,6 +477,10 @@ These are the UTF-8 codec APIs:
    treated as an error. Those bytes will not be decoded and the number of bytes
    that have been decoded will be stored in *consumed*.
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+
 
 .. cfunction:: PyObject* PyUnicode_EncodeUTF8(const Py_UNICODE *s, Py_ssize_t size, const char *errors)
 
@@ -448,6 +488,10 @@ These are the UTF-8 codec APIs:
    return a Python bytes object.  Return *NULL* if an exception was raised by
    the codec.
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+
 
 .. cfunction:: PyObject* PyUnicode_AsUTF8String(PyObject *unicode)
 
@@ -547,6 +591,10 @@ These are the UTF-16 codec APIs:
 
    Return *NULL* if an exception was raised by the codec.
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+
 
 .. cfunction:: PyObject* PyUnicode_DecodeUTF16Stateful(const char *s, Py_ssize_t size, const char *errors, int *byteorder, Py_ssize_t *consumed)
 
@@ -556,6 +604,11 @@ These are the UTF-16 codec APIs:
    split surrogate pair) as an error. Those bytes will not be decoded and the
    number of bytes that have been decoded will be stored in *consumed*.
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *size* and an :ctype:`int *`
+      type for *consumed*. This might require changes in your code for
+      properly supporting 64-bit systems.
+
 
 .. cfunction:: PyObject* PyUnicode_EncodeUTF16(const Py_UNICODE *s, Py_ssize_t size, const char *errors, int byteorder)
 
@@ -576,6 +629,10 @@ These are the UTF-16 codec APIs:
 
    Return *NULL* if an exception was raised by the codec.
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+
 
 .. cfunction:: PyObject* PyUnicode_AsUTF16String(PyObject *unicode)
 
@@ -593,6 +650,10 @@ These are the "Unicode Escape" codec APIs:
    Create a Unicode object by decoding *size* bytes of the Unicode-Escape encoded
    string *s*.  Return *NULL* if an exception was raised by the codec.
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+
 
 .. cfunction:: PyObject* PyUnicode_EncodeUnicodeEscape(const Py_UNICODE *s, Py_ssize_t size)
 
@@ -600,6 +661,10 @@ These are the "Unicode Escape" codec APIs:
    return a Python string object.  Return *NULL* if an exception was raised by the
    codec.
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+
 
 .. cfunction:: PyObject* PyUnicode_AsUnicodeEscapeString(PyObject *unicode)
 
@@ -617,6 +682,10 @@ These are the "Raw Unicode Escape" codec APIs:
    Create a Unicode object by decoding *size* bytes of the Raw-Unicode-Escape
    encoded string *s*.  Return *NULL* if an exception was raised by the codec.
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+
 
 .. cfunction:: PyObject* PyUnicode_EncodeRawUnicodeEscape(const Py_UNICODE *s, Py_ssize_t size, const char *errors)
 
@@ -624,6 +693,10 @@ These are the "Raw Unicode Escape" codec APIs:
    and return a Python string object.  Return *NULL* if an exception was raised by
    the codec.
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+
 
 .. cfunction:: PyObject* PyUnicode_AsRawUnicodeEscapeString(PyObject *unicode)
 
@@ -642,6 +715,10 @@ ordinals and only these are accepted by the codecs during encoding.
    Create a Unicode object by decoding *size* bytes of the Latin-1 encoded string
    *s*.  Return *NULL* if an exception was raised by the codec.
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+
 
 .. cfunction:: PyObject* PyUnicode_EncodeLatin1(const Py_UNICODE *s, Py_ssize_t size, const char *errors)
 
@@ -649,6 +726,10 @@ ordinals and only these are accepted by the codecs during encoding.
    return a Python bytes object.  Return *NULL* if an exception was raised by
    the codec.
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+
 
 .. cfunction:: PyObject* PyUnicode_AsLatin1String(PyObject *unicode)
 
@@ -667,6 +748,10 @@ codes generate errors.
    Create a Unicode object by decoding *size* bytes of the ASCII encoded string
    *s*.  Return *NULL* if an exception was raised by the codec.
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+
 
 .. cfunction:: PyObject* PyUnicode_EncodeASCII(const Py_UNICODE *s, Py_ssize_t size, const char *errors)
 
@@ -674,6 +759,10 @@ codes generate errors.
    return a Python bytes object.  Return *NULL* if an exception was raised by
    the codec.
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+
 
 .. cfunction:: PyObject* PyUnicode_AsASCIIString(PyObject *unicode)
 
@@ -716,6 +805,10 @@ characters to different code points.
    Byte values greater that the length of the string and U+FFFE "characters" are
    treated as "undefined mapping".
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+
 
 .. cfunction:: PyObject* PyUnicode_EncodeCharmap(const Py_UNICODE *s, Py_ssize_t size, PyObject *mapping, const char *errors)
 
@@ -723,6 +816,10 @@ characters to different code points.
    *mapping* object and return a Python string object. Return *NULL* if an
    exception was raised by the codec.
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+
 
 .. cfunction:: PyObject* PyUnicode_AsCharmapString(PyObject *unicode, PyObject *mapping)
 
@@ -746,6 +843,10 @@ The following codec API is special in that maps Unicode to Unicode.
    and sequences work well.  Unmapped character ordinals (ones which cause a
    :exc:`LookupError`) are left untouched and are copied as-is.
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+
 These are the MBCS codec APIs. They are currently only available on Windows and
 use the Win32 MBCS converters to implement the conversions.  Note that MBCS (or
 DBCS) is a class of encodings, not just one.  The target encoding is defined by
@@ -759,6 +860,10 @@ the user settings on the machine running the codec.
    Create a Unicode object by decoding *size* bytes of the MBCS encoded string *s*.
    Return *NULL* if an exception was raised by the codec.
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+
 
 .. cfunction:: PyObject* PyUnicode_DecodeMBCSStateful(const char *s, int size, const char *errors, int *consumed)
 
@@ -774,6 +879,10 @@ the user settings on the machine running the codec.
    a Python bytes object.  Return *NULL* if an exception was raised by the
    codec.
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *size*. This might require
+      changes in your code for properly supporting 64-bit systems.
+
 
 .. cfunction:: PyObject* PyUnicode_AsMBCSString(PyObject *unicode)
 
@@ -808,6 +917,10 @@ They all return *NULL* or ``-1`` if an exception occurs.
    separator.  At most *maxsplit* splits will be done.  If negative, no limit is
    set.  Separators are not included in the resulting list.
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *maxsplit*. This might require
+      changes in your code for properly supporting 64-bit systems.
+
 
 .. cfunction:: PyObject* PyUnicode_Splitlines(PyObject *s, int keepend)
 
@@ -844,6 +957,11 @@ They all return *NULL* or ``-1`` if an exception occurs.
    (*direction* == -1 means to do a prefix match, *direction* == 1 a suffix match),
    0 otherwise. Return ``-1`` if an error occurred.
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *start* and *end*. This
+      might require changes in your code for properly supporting 64-bit
+      systems.
+
 
 .. cfunction:: Py_ssize_t PyUnicode_Find(PyObject *str, PyObject *substr, Py_ssize_t start, Py_ssize_t end, int direction)
 
@@ -853,12 +971,22 @@ They all return *NULL* or ``-1`` if an exception occurs.
    ``-1`` indicates that no match was found, and ``-2`` indicates that an error
    occurred and an exception has been set.
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *start* and *end*. This
+      might require changes in your code for properly supporting 64-bit
+      systems.
+
 
 .. cfunction:: Py_ssize_t PyUnicode_Count(PyObject *str, PyObject *substr, Py_ssize_t start, Py_ssize_t end)
 
    Return the number of non-overlapping occurrences of *substr* in
    ``str[start:end]``.  Return ``-1`` if an error occurred.
 
+   .. versionchanged:: 2.5
+      This function returned an :ctype:`int` type and used an :ctype:`int`
+      type for *start* and *end*. This might require changes in your code for
+      properly supporting 64-bit systems.
+
 
 .. cfunction:: PyObject* PyUnicode_Replace(PyObject *str, PyObject *substr, PyObject *replstr, Py_ssize_t maxcount)
 
@@ -866,6 +994,10 @@ They all return *NULL* or ``-1`` if an exception occurs.
    return the resulting Unicode object. *maxcount* == -1 means replace all
    occurrences.
 
+   .. versionchanged:: 2.5
+      This function used an :ctype:`int` type for *maxcount*. This might
+      require changes in your code for properly supporting 64-bit systems.
+
 
 .. cfunction:: int PyUnicode_Compare(PyObject *left, PyObject *right)