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)
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)
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)
.. 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)
.. 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)
.. 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
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
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
.. 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
.. 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
.. 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
.. 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)
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)
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)
.. 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.
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)
.. 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.
+
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)
: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)
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)
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)
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)
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
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)
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)
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)
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)
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:
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
*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)
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
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)
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)
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)
(*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)
``-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)
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)
projects / python / commitdiff