mirror of
https://github.com/python/cpython.git
synced 2025-08-03 16:39:00 +00:00
Merge ssize_t branch.
This commit is contained in:
Martin v. Löwis
parent
4482929734
commit
18e165558b
102 changed files with 2659 additions and 1677 deletions
|
|
@ -407,7 +407,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
|
|||
equivalent to the Python expression: type(o).
|
||||
*/
|
||||
|
||||
PyAPI_FUNC(int) PyObject_Size(PyObject *o);
|
||||
PyAPI_FUNC(Py_ssize_t) PyObject_Size(PyObject *o);
|
||||
|
||||
/*
|
||||
Return the size of object o. If the object, o, provides
|
||||
|
|
@ -419,10 +419,10 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
|
|||
|
||||
/* For DLL compatibility */
|
||||
#undef PyObject_Length
|
||||
PyAPI_FUNC(int) PyObject_Length(PyObject *o);
|
||||
PyAPI_FUNC(Py_ssize_t) PyObject_Length(PyObject *o);
|
||||
#define PyObject_Length PyObject_Size
|
||||
|
||||
PyAPI_FUNC(int) _PyObject_LengthHint(PyObject *o);
|
||||
PyAPI_FUNC(Py_ssize_t) _PyObject_LengthHint(PyObject *o);
|
||||
|
||||
/*
|
||||
Return the size of object o. If the object, o, provides
|
||||
|
|
@ -477,7 +477,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
|
|||
|
||||
PyAPI_FUNC(int) PyObject_AsCharBuffer(PyObject *obj,
|
||||
const char **buffer,
|
||||
int *buffer_len);
|
||||
Py_ssize_t *buffer_len);
|
||||
|
||||
/*
|
||||
Takes an arbitrary object which must support the (character,
|
||||
|
|
@ -502,7 +502,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
|
|||
|
||||
PyAPI_FUNC(int) PyObject_AsReadBuffer(PyObject *obj,
|
||||
const void **buffer,
|
||||
int *buffer_len);
|
||||
Py_ssize_t *buffer_len);
|
||||
|
||||
/*
|
||||
Same as PyObject_AsCharBuffer() except that this API expects
|
||||
|
|
@ -518,7 +518,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
|
|||
|
||||
PyAPI_FUNC(int) PyObject_AsWriteBuffer(PyObject *obj,
|
||||
void **buffer,
|
||||
int *buffer_len);
|
||||
Py_ssize_t *buffer_len);
|
||||
|
||||
/*
|
||||
Takes an arbitrary object which must support the (writeable,
|
||||
|
|
@ -911,7 +911,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
|
|||
|
||||
*/
|
||||
|
||||
PyAPI_FUNC(int) PySequence_Size(PyObject *o);
|
||||
PyAPI_FUNC(Py_ssize_t) PySequence_Size(PyObject *o);
|
||||
|
||||
/*
|
||||
Return the size of sequence object o, or -1 on failure.
|
||||
|
|
@ -920,7 +920,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
|
|||
|
||||
/* For DLL compatibility */
|
||||
#undef PySequence_Length
|
||||
PyAPI_FUNC(int) PySequence_Length(PyObject *o);
|
||||
PyAPI_FUNC(Py_ssize_t) PySequence_Length(PyObject *o);
|
||||
#define PySequence_Length PySequence_Size
|
||||
|
||||
|
||||
|
|
@ -933,7 +933,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
|
|||
|
||||
*/
|
||||
|
||||
PyAPI_FUNC(PyObject *) PySequence_Repeat(PyObject *o, int count);
|
||||
PyAPI_FUNC(PyObject *) PySequence_Repeat(PyObject *o, Py_ssize_t count);
|
||||
|
||||
/*
|
||||
Return the result of repeating sequence object o count times,
|
||||
|
|
@ -942,14 +942,14 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
|
|||
|
||||
*/
|
||||
|
||||
PyAPI_FUNC(PyObject *) PySequence_GetItem(PyObject *o, int i);
|
||||
PyAPI_FUNC(PyObject *) PySequence_GetItem(PyObject *o, Py_ssize_t i);
|
||||
|
||||
/*
|
||||
Return the ith element of o, or NULL on failure. This is the
|
||||
equivalent of the Python expression: o[i].
|
||||
*/
|
||||
|
||||
PyAPI_FUNC(PyObject *) PySequence_GetSlice(PyObject *o, int i1, int i2);
|
||||
PyAPI_FUNC(PyObject *) PySequence_GetSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2);
|
||||
|
||||
/*
|
||||
Return the slice of sequence object o between i1 and i2, or
|
||||
|
|
@ -958,7 +958,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
|
|||
|
||||
*/
|
||||
|
||||
PyAPI_FUNC(int) PySequence_SetItem(PyObject *o, int i, PyObject *v);
|
||||
PyAPI_FUNC(int) PySequence_SetItem(PyObject *o, Py_ssize_t i, PyObject *v);
|
||||
|
||||
/*
|
||||
Assign object v to the ith element of o. Returns
|
||||
|
|
@ -967,7 +967,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
|
|||
|
||||
*/
|
||||
|
||||
PyAPI_FUNC(int) PySequence_DelItem(PyObject *o, int i);
|
||||
PyAPI_FUNC(int) PySequence_DelItem(PyObject *o, Py_ssize_t i);
|
||||
|
||||
/*
|
||||
Delete the ith element of object v. Returns
|
||||
|
|
@ -975,7 +975,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
|
|||
statement: del o[i].
|
||||
*/
|
||||
|
||||
PyAPI_FUNC(int) PySequence_SetSlice(PyObject *o, int i1, int i2,
|
||||
PyAPI_FUNC(int) PySequence_SetSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2,
|
||||
PyObject *v);
|
||||
|
||||
/*
|
||||
|
|
@ -984,7 +984,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
|
|||
equivalent of the Python statement: o[i1:i2]=v.
|
||||
*/
|
||||
|
||||
PyAPI_FUNC(int) PySequence_DelSlice(PyObject *o, int i1, int i2);
|
||||
PyAPI_FUNC(int) PySequence_DelSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2);
|
||||
|
||||
/*
|
||||
Delete the slice in sequence object, o, from i1 to i2.
|
||||
|
|
@ -1105,7 +1105,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
|
|||
|
||||
*/
|
||||
|
||||
PyAPI_FUNC(PyObject *) PySequence_InPlaceRepeat(PyObject *o, int count);
|
||||
PyAPI_FUNC(PyObject *) PySequence_InPlaceRepeat(PyObject *o, Py_ssize_t count);
|
||||
|
||||
/*
|
||||
Repeat o1 by count, in-place when possible. Return the resulting
|
||||
|
|
@ -1125,7 +1125,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
|
|||
This function always succeeds.
|
||||
*/
|
||||
|
||||
PyAPI_FUNC(int) PyMapping_Size(PyObject *o);
|
||||
PyAPI_FUNC(Py_ssize_t) PyMapping_Size(PyObject *o);
|
||||
|
||||
/*
|
||||
Returns the number of keys in object o on success, and -1 on
|
||||
|
|
@ -1135,7 +1135,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
|
|||
|
||||
/* For DLL compatibility */
|
||||
#undef PyMapping_Length
|
||||
PyAPI_FUNC(int) PyMapping_Length(PyObject *o);
|
||||
PyAPI_FUNC(Py_ssize_t) PyMapping_Length(PyObject *o);
|
||||
#define PyMapping_Length PyMapping_Size
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -17,15 +17,15 @@ PyAPI_DATA(PyTypeObject) PyBuffer_Type;
|
|||
#define Py_END_OF_BUFFER (-1)
|
||||
|
||||
PyAPI_FUNC(PyObject *) PyBuffer_FromObject(PyObject *base,
|
||||
int offset, int size);
|
||||
Py_ssize_t offset, Py_ssize_t size);
|
||||
PyAPI_FUNC(PyObject *) PyBuffer_FromReadWriteObject(PyObject *base,
|
||||
int offset,
|
||||
int size);
|
||||
Py_ssize_t offset,
|
||||
Py_ssize_t size);
|
||||
|
||||
PyAPI_FUNC(PyObject *) PyBuffer_FromMemory(void *ptr, int size);
|
||||
PyAPI_FUNC(PyObject *) PyBuffer_FromReadWriteMemory(void *ptr, int size);
|
||||
PyAPI_FUNC(PyObject *) PyBuffer_FromMemory(void *ptr, Py_ssize_t size);
|
||||
PyAPI_FUNC(PyObject *) PyBuffer_FromReadWriteMemory(void *ptr, Py_ssize_t size);
|
||||
|
||||
PyAPI_FUNC(PyObject *) PyBuffer_New(int size);
|
||||
PyAPI_FUNC(PyObject *) PyBuffer_New(Py_ssize_t size);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
|||
|
|
@ -29,7 +29,7 @@ static struct PycStringIO_CAPI {
|
|||
/* Read a string from an input object. If the last argument
|
||||
is -1, the remainder will be read.
|
||||
*/
|
||||
int(*cread)(PyObject *, char **, int);
|
||||
int(*cread)(PyObject *, char **, Py_ssize_t);
|
||||
|
||||
/* Read a line from an input object. Returns the length of the read
|
||||
line as an int and a pointer inside the object buffer as char** (so
|
||||
|
|
@ -38,7 +38,7 @@ static struct PycStringIO_CAPI {
|
|||
int(*creadline)(PyObject *, char **);
|
||||
|
||||
/* Write a string to an output object*/
|
||||
int(*cwrite)(PyObject *, const char *, int);
|
||||
int(*cwrite)(PyObject *, const char *, Py_ssize_t);
|
||||
|
||||
/* Get the output object as a Python string (returns new reference). */
|
||||
PyObject *(*cgetvalue)(PyObject *);
|
||||
|
|
|
|||
|
|
@ -148,7 +148,7 @@ PyAPI_FUNC(void) PyEval_ReInitThreads(void);
|
|||
|
||||
#endif /* !WITH_THREAD */
|
||||
|
||||
PyAPI_FUNC(int) _PyEval_SliceIndex(PyObject *, int *);
|
||||
PyAPI_FUNC(int) _PyEval_SliceIndex(PyObject *, Py_ssize_t *);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
|
|
|||
|
|
@ -95,11 +95,11 @@ PyAPI_FUNC(int) PyDict_SetItem(PyObject *mp, PyObject *key, PyObject *item);
|
|||
PyAPI_FUNC(int) PyDict_DelItem(PyObject *mp, PyObject *key);
|
||||
PyAPI_FUNC(void) PyDict_Clear(PyObject *mp);
|
||||
PyAPI_FUNC(int) PyDict_Next(
|
||||
PyObject *mp, int *pos, PyObject **key, PyObject **value);
|
||||
PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value);
|
||||
PyAPI_FUNC(PyObject *) PyDict_Keys(PyObject *mp);
|
||||
PyAPI_FUNC(PyObject *) PyDict_Values(PyObject *mp);
|
||||
PyAPI_FUNC(PyObject *) PyDict_Items(PyObject *mp);
|
||||
PyAPI_FUNC(int) PyDict_Size(PyObject *mp);
|
||||
PyAPI_FUNC(Py_ssize_t) PyDict_Size(PyObject *mp);
|
||||
PyAPI_FUNC(PyObject *) PyDict_Copy(PyObject *mp);
|
||||
PyAPI_FUNC(int) PyDict_Contains(PyObject *mp, PyObject *key);
|
||||
|
||||
|
|
|
|||
|
|
@ -32,10 +32,13 @@ PyAPI_DATA(PyTypeObject) PyInt_Type;
|
|||
|
||||
PyAPI_FUNC(PyObject *) PyInt_FromString(char*, char**, int);
|
||||
#ifdef Py_USING_UNICODE
|
||||
PyAPI_FUNC(PyObject *) PyInt_FromUnicode(Py_UNICODE*, int, int);
|
||||
PyAPI_FUNC(PyObject *) PyInt_FromUnicode(Py_UNICODE*, Py_ssize_t, int);
|
||||
#endif
|
||||
PyAPI_FUNC(PyObject *) PyInt_FromLong(long);
|
||||
PyAPI_FUNC(PyObject *) PyInt_FromSize_t(size_t);
|
||||
PyAPI_FUNC(PyObject *) PyInt_FromSsize_t(Py_ssize_t);
|
||||
PyAPI_FUNC(long) PyInt_AsLong(PyObject *);
|
||||
PyAPI_FUNC(Py_ssize_t) PyInt_AsSsize_t(PyObject *);
|
||||
PyAPI_FUNC(unsigned long) PyInt_AsUnsignedLongMask(PyObject *);
|
||||
#ifdef HAVE_LONG_LONG
|
||||
PyAPI_FUNC(unsigned PY_LONG_LONG) PyInt_AsUnsignedLongLongMask(PyObject *);
|
||||
|
|
|
|||
|
|
@ -35,7 +35,7 @@ typedef struct {
|
|||
* Items must normally not be NULL, except during construction when
|
||||
* the list is not yet visible outside the function that builds it.
|
||||
*/
|
||||
int allocated;
|
||||
Py_ssize_t allocated;
|
||||
} PyListObject;
|
||||
|
||||
PyAPI_DATA(PyTypeObject) PyList_Type;
|
||||
|
|
@ -43,14 +43,14 @@ PyAPI_DATA(PyTypeObject) PyList_Type;
|
|||
#define PyList_Check(op) PyObject_TypeCheck(op, &PyList_Type)
|
||||
#define PyList_CheckExact(op) ((op)->ob_type == &PyList_Type)
|
||||
|
||||
PyAPI_FUNC(PyObject *) PyList_New(int size);
|
||||
PyAPI_FUNC(int) PyList_Size(PyObject *);
|
||||
PyAPI_FUNC(PyObject *) PyList_GetItem(PyObject *, int);
|
||||
PyAPI_FUNC(int) PyList_SetItem(PyObject *, int, PyObject *);
|
||||
PyAPI_FUNC(int) PyList_Insert(PyObject *, int, PyObject *);
|
||||
PyAPI_FUNC(PyObject *) PyList_New(Py_ssize_t size);
|
||||
PyAPI_FUNC(Py_ssize_t) PyList_Size(PyObject *);
|
||||
PyAPI_FUNC(PyObject *) PyList_GetItem(PyObject *, Py_ssize_t);
|
||||
PyAPI_FUNC(int) PyList_SetItem(PyObject *, Py_ssize_t, PyObject *);
|
||||
PyAPI_FUNC(int) PyList_Insert(PyObject *, Py_ssize_t, PyObject *);
|
||||
PyAPI_FUNC(int) PyList_Append(PyObject *, PyObject *);
|
||||
PyAPI_FUNC(PyObject *) PyList_GetSlice(PyObject *, int, int);
|
||||
PyAPI_FUNC(int) PyList_SetSlice(PyObject *, int, int, PyObject *);
|
||||
PyAPI_FUNC(PyObject *) PyList_GetSlice(PyObject *, Py_ssize_t, Py_ssize_t);
|
||||
PyAPI_FUNC(int) PyList_SetSlice(PyObject *, Py_ssize_t, Py_ssize_t, PyObject *);
|
||||
PyAPI_FUNC(int) PyList_Sort(PyObject *);
|
||||
PyAPI_FUNC(int) PyList_Reverse(PyObject *);
|
||||
PyAPI_FUNC(PyObject *) PyList_AsTuple(PyObject *);
|
||||
|
|
|
|||
|
|
@ -52,7 +52,7 @@ struct _longobject {
|
|||
digit ob_digit[1];
|
||||
};
|
||||
|
||||
PyAPI_FUNC(PyLongObject *) _PyLong_New(int);
|
||||
PyAPI_FUNC(PyLongObject *) _PyLong_New(Py_ssize_t);
|
||||
|
||||
/* Return a copy of src. */
|
||||
PyAPI_FUNC(PyObject *) _PyLong_Copy(PyLongObject *src);
|
||||
|
|
|
|||
|
|
@ -21,6 +21,11 @@ PyAPI_FUNC(long) PyLong_AsLong(PyObject *);
|
|||
PyAPI_FUNC(unsigned long) PyLong_AsUnsignedLong(PyObject *);
|
||||
PyAPI_FUNC(unsigned long) PyLong_AsUnsignedLongMask(PyObject *);
|
||||
|
||||
/* For use by intobject.c only */
|
||||
PyAPI_FUNC(Py_ssize_t) _PyLong_AsSsize_t(PyObject *);
|
||||
PyAPI_FUNC(PyObject *) _PyLong_FromSize_t(size_t);
|
||||
PyAPI_FUNC(PyObject *) _PyLong_FromSsize_t(Py_ssize_t);
|
||||
|
||||
/* _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
|
||||
|
|
@ -43,7 +48,7 @@ PyAPI_FUNC(unsigned PY_LONG_LONG) PyLong_AsUnsignedLongLongMask(PyObject *);
|
|||
|
||||
PyAPI_FUNC(PyObject *) PyLong_FromString(char *, char **, int);
|
||||
#ifdef Py_USING_UNICODE
|
||||
PyAPI_FUNC(PyObject *) PyLong_FromUnicode(Py_UNICODE*, int, int);
|
||||
PyAPI_FUNC(PyObject *) PyLong_FromUnicode(Py_UNICODE*, Py_ssize_t, int);
|
||||
#endif
|
||||
|
||||
/* _PyLong_Sign. Return 0 if v is 0, -1 if v < 0, +1 if v > 0.
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ PyAPI_FUNC(long) PyMarshal_ReadLongFromFile(FILE *);
|
|||
PyAPI_FUNC(int) PyMarshal_ReadShortFromFile(FILE *);
|
||||
PyAPI_FUNC(PyObject *) PyMarshal_ReadObjectFromFile(FILE *);
|
||||
PyAPI_FUNC(PyObject *) PyMarshal_ReadLastObjectFromFile(FILE *);
|
||||
PyAPI_FUNC(PyObject *) PyMarshal_ReadObjectFromString(char *, int);
|
||||
PyAPI_FUNC(PyObject *) PyMarshal_ReadObjectFromString(char *, Py_ssize_t);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
|||
|
|
@ -9,6 +9,18 @@ extern "C" {
|
|||
|
||||
#include <stdarg.h>
|
||||
|
||||
/* If PY_SSIZE_T_CLEAN is defined, each functions treats #-specifier
|
||||
to mean Py_ssize_t */
|
||||
#ifdef PY_SSIZE_T_CLEAN
|
||||
#define PyArg_Parse _PyArg_Parse_SizeT
|
||||
#define PyArg_ParseTuple _PyArg_ParseTuple_SizeT
|
||||
#define PyArg_ParseTupleAndKeywords _PyArg_ParseTupleAndKeywords_SizeT
|
||||
#define PyArg_VaParse _PyArg_VaParse_SizeT
|
||||
#define PyArg_VaParseTupleAndKeywords _PyArg_VaParseTupleAndKeywords_SizeT
|
||||
#define PyArg_BuildValue _PyArg_BuildValue_SizeT
|
||||
#define PyArg_VaBuildValue _PyArg_VaBuildValue_SizeT
|
||||
#endif
|
||||
|
||||
PyAPI_FUNC(int) PyArg_Parse(PyObject *, const char *, ...);
|
||||
PyAPI_FUNC(int) PyArg_ParseTuple(PyObject *, const char *, ...);
|
||||
PyAPI_FUNC(int) PyArg_ParseTupleAndKeywords(PyObject *, PyObject *,
|
||||
|
|
@ -26,6 +38,7 @@ PyAPI_FUNC(int) PyModule_AddObject(PyObject *, const char *, PyObject *);
|
|||
PyAPI_FUNC(int) PyModule_AddIntConstant(PyObject *, const char *, long);
|
||||
PyAPI_FUNC(int) PyModule_AddStringConstant(PyObject *, const char *, const char *);
|
||||
|
||||
|
||||
#define PYTHON_API_VERSION 1012
|
||||
#define PYTHON_API_STRING "1012"
|
||||
/* The API version is maintained (independently from the Python version)
|
||||
|
|
@ -77,11 +90,22 @@ PyAPI_FUNC(int) PyModule_AddStringConstant(PyObject *, const char *, const char
|
|||
without actually needing a recompile. */
|
||||
#endif /* MS_WINDOWS */
|
||||
|
||||
#if SIZEOF_SIZE_T != SIZEOF_INT
|
||||
/* On a 64-bit system, rename the Py_InitModule4 so that 2.4
|
||||
modules cannot get loaded into a 2.5 interpreter */
|
||||
#define Py_InitModule4 Py_InitModule4_64
|
||||
#endif
|
||||
|
||||
#ifdef Py_TRACE_REFS
|
||||
/* When we are tracing reference counts, rename Py_InitModule4 so
|
||||
modules compiled with incompatible settings will generate a
|
||||
link-time error. */
|
||||
#define Py_InitModule4 Py_InitModule4TraceRefs
|
||||
/* When we are tracing reference counts, rename Py_InitModule4 so
|
||||
modules compiled with incompatible settings will generate a
|
||||
link-time error. */
|
||||
#if SIZEOF_SIZE_T != SIZEOF_INT
|
||||
#undef Py_InitModule4
|
||||
#define Py_InitModule4 Py_InitModule4TraceRefs_64
|
||||
#else
|
||||
#define Py_InitModule4 Py_InitModule4TraceRefs
|
||||
#endif
|
||||
#endif
|
||||
|
||||
PyAPI_FUNC(PyObject *) Py_InitModule4(const char *name, PyMethodDef *methods,
|
||||
|
|
|
|||
|
|
@ -92,7 +92,8 @@ whose size is determined when the object is allocated.
|
|||
*/
|
||||
#define PyObject_VAR_HEAD \
|
||||
PyObject_HEAD \
|
||||
int ob_size; /* Number of items in variable part */
|
||||
Py_ssize_t ob_size; /* Number of items in variable part */
|
||||
#define Py_INVALID_SIZE (Py_ssize_t)-1
|
||||
|
||||
/* Nothing is actually declared to be a PyObject, but every pointer to
|
||||
* a Python object can be cast to a PyObject*. This is inheritance built
|
||||
|
|
@ -127,16 +128,29 @@ typedef PyObject * (*unaryfunc)(PyObject *);
|
|||
typedef PyObject * (*binaryfunc)(PyObject *, PyObject *);
|
||||
typedef PyObject * (*ternaryfunc)(PyObject *, PyObject *, PyObject *);
|
||||
typedef int (*inquiry)(PyObject *);
|
||||
typedef Py_ssize_t (*lenfunc)(PyObject *);
|
||||
typedef int (*coercion)(PyObject **, PyObject **);
|
||||
typedef PyObject *(*intargfunc)(PyObject *, int);
|
||||
typedef PyObject *(*intintargfunc)(PyObject *, int, int);
|
||||
typedef PyObject *(*intargfunc)(PyObject *, int) Py_DEPRECATED(2.5);
|
||||
typedef PyObject *(*intintargfunc)(PyObject *, int, int) Py_DEPRECATED(2.5);
|
||||
typedef PyObject *(*ssizeargfunc)(PyObject *, Py_ssize_t);
|
||||
typedef PyObject *(*ssizessizeargfunc)(PyObject *, Py_ssize_t, Py_ssize_t);
|
||||
typedef int(*intobjargproc)(PyObject *, int, PyObject *);
|
||||
typedef int(*intintobjargproc)(PyObject *, int, int, PyObject *);
|
||||
typedef int(*ssizeobjargproc)(PyObject *, Py_ssize_t, PyObject *);
|
||||
typedef int(*ssizessizeobjargproc)(PyObject *, Py_ssize_t, Py_ssize_t, PyObject *);
|
||||
typedef int(*objobjargproc)(PyObject *, PyObject *, PyObject *);
|
||||
|
||||
/* int-based buffer interface */
|
||||
typedef int (*getreadbufferproc)(PyObject *, int, void **);
|
||||
typedef int (*getwritebufferproc)(PyObject *, int, void **);
|
||||
typedef int (*getsegcountproc)(PyObject *, int *);
|
||||
typedef int (*getcharbufferproc)(PyObject *, int, const char **);
|
||||
/* ssize_t-based buffer interface */
|
||||
typedef Py_ssize_t (*readbufferproc)(PyObject *, Py_ssize_t, void **);
|
||||
typedef Py_ssize_t (*writebufferproc)(PyObject *, Py_ssize_t, void **);
|
||||
typedef Py_ssize_t (*segcountproc)(PyObject *, Py_ssize_t *);
|
||||
typedef Py_ssize_t (*charbufferproc)(PyObject *, Py_ssize_t, const char **);
|
||||
|
||||
typedef int (*objobjproc)(PyObject *, PyObject *);
|
||||
typedef int (*visitproc)(PyObject *, void *);
|
||||
typedef int (*traverseproc)(PyObject *, visitproc, void *);
|
||||
|
|
@ -195,30 +209,30 @@ typedef struct {
|
|||
} PyNumberMethods;
|
||||
|
||||
typedef struct {
|
||||
inquiry sq_length;
|
||||
lenfunc sq_length;
|
||||
binaryfunc sq_concat;
|
||||
intargfunc sq_repeat;
|
||||
intargfunc sq_item;
|
||||
intintargfunc sq_slice;
|
||||
intobjargproc sq_ass_item;
|
||||
intintobjargproc sq_ass_slice;
|
||||
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;
|
||||
intargfunc sq_inplace_repeat;
|
||||
ssizeargfunc sq_inplace_repeat;
|
||||
} PySequenceMethods;
|
||||
|
||||
typedef struct {
|
||||
inquiry mp_length;
|
||||
lenfunc mp_length;
|
||||
binaryfunc mp_subscript;
|
||||
objobjargproc mp_ass_subscript;
|
||||
} PyMappingMethods;
|
||||
|
||||
typedef struct {
|
||||
getreadbufferproc bf_getreadbuffer;
|
||||
getwritebufferproc bf_getwritebuffer;
|
||||
getsegcountproc bf_getsegcount;
|
||||
getcharbufferproc bf_getcharbuffer;
|
||||
readbufferproc bf_getreadbuffer;
|
||||
writebufferproc bf_getwritebuffer;
|
||||
segcountproc bf_getsegcount;
|
||||
charbufferproc bf_getcharbuffer;
|
||||
} PyBufferProcs;
|
||||
|
||||
|
||||
|
|
@ -239,7 +253,7 @@ typedef PyObject *(*descrgetfunc) (PyObject *, PyObject *, PyObject *);
|
|||
typedef int (*descrsetfunc) (PyObject *, PyObject *, PyObject *);
|
||||
typedef int (*initproc)(PyObject *, PyObject *, PyObject *);
|
||||
typedef PyObject *(*newfunc)(struct _typeobject *, PyObject *, PyObject *);
|
||||
typedef PyObject *(*allocfunc)(struct _typeobject *, int);
|
||||
typedef PyObject *(*allocfunc)(struct _typeobject *, Py_ssize_t);
|
||||
|
||||
typedef struct _typeobject {
|
||||
PyObject_VAR_HEAD
|
||||
|
|
@ -362,7 +376,7 @@ PyAPI_DATA(PyTypeObject) PySuper_Type; /* built-in 'super' */
|
|||
#define PyType_CheckExact(op) ((op)->ob_type == &PyType_Type)
|
||||
|
||||
PyAPI_FUNC(int) PyType_Ready(PyTypeObject *);
|
||||
PyAPI_FUNC(PyObject *) PyType_GenericAlloc(PyTypeObject *, int);
|
||||
PyAPI_FUNC(PyObject *) PyType_GenericAlloc(PyTypeObject *, Py_ssize_t);
|
||||
PyAPI_FUNC(PyObject *) PyType_GenericNew(PyTypeObject *,
|
||||
PyObject *, PyObject *);
|
||||
PyAPI_FUNC(PyObject *) _PyType_Lookup(PyTypeObject *, PyObject *);
|
||||
|
|
|
|||
|
|
@ -146,9 +146,9 @@ PyAPI_FUNC(void) _PyObject_DebugMallocStats(void);
|
|||
/* Functions */
|
||||
PyAPI_FUNC(PyObject *) PyObject_Init(PyObject *, PyTypeObject *);
|
||||
PyAPI_FUNC(PyVarObject *) PyObject_InitVar(PyVarObject *,
|
||||
PyTypeObject *, int);
|
||||
PyTypeObject *, Py_ssize_t);
|
||||
PyAPI_FUNC(PyObject *) _PyObject_New(PyTypeObject *);
|
||||
PyAPI_FUNC(PyVarObject *) _PyObject_NewVar(PyTypeObject *, int);
|
||||
PyAPI_FUNC(PyVarObject *) _PyObject_NewVar(PyTypeObject *, Py_ssize_t);
|
||||
|
||||
#define PyObject_New(type, typeobj) \
|
||||
( (type *) _PyObject_New(typeobj) )
|
||||
|
|
@ -291,7 +291,7 @@ extern PyGC_Head *_PyGC_generation0;
|
|||
|
||||
PyAPI_FUNC(PyObject *) _PyObject_GC_Malloc(size_t);
|
||||
PyAPI_FUNC(PyObject *) _PyObject_GC_New(PyTypeObject *);
|
||||
PyAPI_FUNC(PyVarObject *) _PyObject_GC_NewVar(PyTypeObject *, int);
|
||||
PyAPI_FUNC(PyVarObject *) _PyObject_GC_NewVar(PyTypeObject *, Py_ssize_t);
|
||||
PyAPI_FUNC(void) PyObject_GC_Track(void *);
|
||||
PyAPI_FUNC(void) PyObject_GC_UnTrack(void *);
|
||||
PyAPI_FUNC(void) PyObject_GC_Del(void *);
|
||||
|
|
|
|||
|
|
@ -156,15 +156,15 @@ PyAPI_FUNC(PyObject *) PyErr_ProgramText(const char *, int);
|
|||
|
||||
/* create a UnicodeDecodeError object */
|
||||
PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_Create(
|
||||
const char *, const char *, int, int, int, 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 *, int, int, int, 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 *, int, int, int, const char *);
|
||||
const Py_UNICODE *, Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *);
|
||||
|
||||
/* get the encoding attribute */
|
||||
PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_GetEncoding(PyObject *);
|
||||
|
|
@ -177,27 +177,27 @@ PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_GetObject(PyObject *);
|
|||
|
||||
/* get the value of the start attribute (the int * may not be NULL)
|
||||
return 0 on success, -1 on failure */
|
||||
PyAPI_FUNC(int) PyUnicodeEncodeError_GetStart(PyObject *, int *);
|
||||
PyAPI_FUNC(int) PyUnicodeDecodeError_GetStart(PyObject *, int *);
|
||||
PyAPI_FUNC(int) PyUnicodeTranslateError_GetStart(PyObject *, int *);
|
||||
PyAPI_FUNC(int) PyUnicodeEncodeError_GetStart(PyObject *, Py_ssize_t *);
|
||||
PyAPI_FUNC(int) PyUnicodeDecodeError_GetStart(PyObject *, Py_ssize_t *);
|
||||
PyAPI_FUNC(int) PyUnicodeTranslateError_GetStart(PyObject *, Py_ssize_t *);
|
||||
|
||||
/* assign a new value to the start attribute
|
||||
return 0 on success, -1 on failure */
|
||||
PyAPI_FUNC(int) PyUnicodeEncodeError_SetStart(PyObject *, int);
|
||||
PyAPI_FUNC(int) PyUnicodeDecodeError_SetStart(PyObject *, int);
|
||||
PyAPI_FUNC(int) PyUnicodeTranslateError_SetStart(PyObject *, int);
|
||||
PyAPI_FUNC(int) PyUnicodeEncodeError_SetStart(PyObject *, Py_ssize_t);
|
||||
PyAPI_FUNC(int) PyUnicodeDecodeError_SetStart(PyObject *, Py_ssize_t);
|
||||
PyAPI_FUNC(int) PyUnicodeTranslateError_SetStart(PyObject *, Py_ssize_t);
|
||||
|
||||
/* get the value of the end attribute (the int *may not be NULL)
|
||||
return 0 on success, -1 on failure */
|
||||
PyAPI_FUNC(int) PyUnicodeEncodeError_GetEnd(PyObject *, int *);
|
||||
PyAPI_FUNC(int) PyUnicodeDecodeError_GetEnd(PyObject *, int *);
|
||||
PyAPI_FUNC(int) PyUnicodeTranslateError_GetEnd(PyObject *, int *);
|
||||
PyAPI_FUNC(int) PyUnicodeEncodeError_GetEnd(PyObject *, Py_ssize_t *);
|
||||
PyAPI_FUNC(int) PyUnicodeDecodeError_GetEnd(PyObject *, Py_ssize_t *);
|
||||
PyAPI_FUNC(int) PyUnicodeTranslateError_GetEnd(PyObject *, Py_ssize_t *);
|
||||
|
||||
/* assign a new value to the end attribute
|
||||
return 0 on success, -1 on failure */
|
||||
PyAPI_FUNC(int) PyUnicodeEncodeError_SetEnd(PyObject *, int);
|
||||
PyAPI_FUNC(int) PyUnicodeDecodeError_SetEnd(PyObject *, int);
|
||||
PyAPI_FUNC(int) PyUnicodeTranslateError_SetEnd(PyObject *, int);
|
||||
PyAPI_FUNC(int) PyUnicodeEncodeError_SetEnd(PyObject *, Py_ssize_t);
|
||||
PyAPI_FUNC(int) PyUnicodeDecodeError_SetEnd(PyObject *, Py_ssize_t);
|
||||
PyAPI_FUNC(int) PyUnicodeTranslateError_SetEnd(PyObject *, Py_ssize_t);
|
||||
|
||||
/* get the value of the reason attribute */
|
||||
PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_GetReason(PyObject *);
|
||||
|
|
|
|||
|
|
@ -85,6 +85,15 @@ typedef PY_LONG_LONG Py_intptr_t;
|
|||
# error "Python needs a typedef for Py_uintptr_t in pyport.h."
|
||||
#endif /* HAVE_UINTPTR_T */
|
||||
|
||||
#ifdef HAVE_SSIZE_T
|
||||
typedef ssize_t Py_ssize_t;
|
||||
#elif SIZEOF_VOID_P == SIZEOF_SIZE_T
|
||||
typedef Py_uintptr_t Py_ssize_t;
|
||||
#else
|
||||
# error "Python needs a typedef for Py_ssize_t in pyport.h."
|
||||
#endif
|
||||
#define PY_SSIZE_T_MAX ((Py_ssize_t)(((size_t)-1)>>1))
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include <math.h> /* Moved here from the math section, before extern "C" */
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ extern "C" {
|
|||
|
||||
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, int buf_len, const char *format, double d);
|
||||
PyAPI_FUNC(char *) PyOS_ascii_formatd(char *buffer, size_t buf_len, const char *format, double d);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
|
|
|||
|
|
@ -30,11 +30,11 @@ PyAPI_DATA(PyTypeObject) PySlice_Type;
|
|||
|
||||
PyAPI_FUNC(PyObject *) PySlice_New(PyObject* start, PyObject* stop,
|
||||
PyObject* step);
|
||||
PyAPI_FUNC(int) PySlice_GetIndices(PySliceObject *r, int length,
|
||||
int *start, int *stop, int *step);
|
||||
PyAPI_FUNC(int) PySlice_GetIndicesEx(PySliceObject *r, int length,
|
||||
int *start, int *stop,
|
||||
int *step, int *slicelength);
|
||||
PyAPI_FUNC(int) PySlice_GetIndices(PySliceObject *r, Py_ssize_t length,
|
||||
Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step);
|
||||
PyAPI_FUNC(int) PySlice_GetIndicesEx(PySliceObject *r, Py_ssize_t length,
|
||||
Py_ssize_t *start, Py_ssize_t *stop,
|
||||
Py_ssize_t *step, Py_ssize_t *slicelength);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
|||
|
|
@ -58,24 +58,24 @@ PyAPI_DATA(PyTypeObject) PyString_Type;
|
|||
#define PyString_Check(op) PyObject_TypeCheck(op, &PyString_Type)
|
||||
#define PyString_CheckExact(op) ((op)->ob_type == &PyString_Type)
|
||||
|
||||
PyAPI_FUNC(PyObject *) PyString_FromStringAndSize(const char *, int);
|
||||
PyAPI_FUNC(PyObject *) PyString_FromStringAndSize(const char *, Py_ssize_t);
|
||||
PyAPI_FUNC(PyObject *) PyString_FromString(const char *);
|
||||
PyAPI_FUNC(PyObject *) PyString_FromFormatV(const char*, va_list)
|
||||
Py_GCC_ATTRIBUTE((format(printf, 1, 0)));
|
||||
PyAPI_FUNC(PyObject *) PyString_FromFormat(const char*, ...)
|
||||
Py_GCC_ATTRIBUTE((format(printf, 1, 2)));
|
||||
PyAPI_FUNC(int) PyString_Size(PyObject *);
|
||||
PyAPI_FUNC(Py_ssize_t) PyString_Size(PyObject *);
|
||||
PyAPI_FUNC(char *) PyString_AsString(PyObject *);
|
||||
PyAPI_FUNC(PyObject *) PyString_Repr(PyObject *, int);
|
||||
PyAPI_FUNC(void) PyString_Concat(PyObject **, PyObject *);
|
||||
PyAPI_FUNC(void) PyString_ConcatAndDel(PyObject **, PyObject *);
|
||||
PyAPI_FUNC(int) _PyString_Resize(PyObject **, int);
|
||||
PyAPI_FUNC(int) _PyString_Resize(PyObject **, Py_ssize_t);
|
||||
PyAPI_FUNC(int) _PyString_Eq(PyObject *, PyObject*);
|
||||
PyAPI_FUNC(PyObject *) PyString_Format(PyObject *, PyObject *);
|
||||
PyAPI_FUNC(PyObject *) _PyString_FormatLong(PyObject*, int, int,
|
||||
int, char**, int*);
|
||||
PyAPI_FUNC(PyObject *) PyString_DecodeEscape(const char *, int,
|
||||
const char *, int,
|
||||
PyAPI_FUNC(PyObject *) PyString_DecodeEscape(const char *, Py_ssize_t,
|
||||
const char *, Py_ssize_t,
|
||||
const char *);
|
||||
|
||||
PyAPI_FUNC(void) PyString_InternInPlace(PyObject **);
|
||||
|
|
@ -101,7 +101,7 @@ PyAPI_FUNC(PyObject *) _PyString_Join(PyObject *sep, PyObject *x);
|
|||
|
||||
PyAPI_FUNC(PyObject*) PyString_Decode(
|
||||
const char *s, /* encoded string */
|
||||
int size, /* size of buffer */
|
||||
Py_ssize_t size, /* size of buffer */
|
||||
const char *encoding, /* encoding */
|
||||
const char *errors /* error handling */
|
||||
);
|
||||
|
|
@ -111,7 +111,7 @@ PyAPI_FUNC(PyObject*) PyString_Decode(
|
|||
|
||||
PyAPI_FUNC(PyObject*) PyString_Encode(
|
||||
const char *s, /* string char buffer */
|
||||
int size, /* number of chars to encode */
|
||||
Py_ssize_t size, /* number of chars to encode */
|
||||
const char *encoding, /* encoding */
|
||||
const char *errors /* error handling */
|
||||
);
|
||||
|
|
@ -171,7 +171,7 @@ PyAPI_FUNC(PyObject*) PyString_AsDecodedString(
|
|||
PyAPI_FUNC(int) PyString_AsStringAndSize(
|
||||
register PyObject *obj, /* string or Unicode object */
|
||||
register char **s, /* pointer to buffer variable */
|
||||
register int *len /* pointer to length variable or NULL
|
||||
register Py_ssize_t *len /* pointer to length variable or NULL
|
||||
(only possible for 0-terminated
|
||||
strings) */
|
||||
);
|
||||
|
|
|
|||
|
|
@ -36,13 +36,13 @@ PyAPI_DATA(PyTypeObject) PyTuple_Type;
|
|||
#define PyTuple_Check(op) PyObject_TypeCheck(op, &PyTuple_Type)
|
||||
#define PyTuple_CheckExact(op) ((op)->ob_type == &PyTuple_Type)
|
||||
|
||||
PyAPI_FUNC(PyObject *) PyTuple_New(int size);
|
||||
PyAPI_FUNC(int) PyTuple_Size(PyObject *);
|
||||
PyAPI_FUNC(PyObject *) PyTuple_GetItem(PyObject *, int);
|
||||
PyAPI_FUNC(int) PyTuple_SetItem(PyObject *, int, PyObject *);
|
||||
PyAPI_FUNC(PyObject *) PyTuple_GetSlice(PyObject *, int, int);
|
||||
PyAPI_FUNC(int) _PyTuple_Resize(PyObject **, int);
|
||||
PyAPI_FUNC(PyObject *) PyTuple_Pack(int, ...);
|
||||
PyAPI_FUNC(PyObject *) PyTuple_New(Py_ssize_t size);
|
||||
PyAPI_FUNC(Py_ssize_t) PyTuple_Size(PyObject *);
|
||||
PyAPI_FUNC(PyObject *) PyTuple_GetItem(PyObject *, Py_ssize_t);
|
||||
PyAPI_FUNC(int) PyTuple_SetItem(PyObject *, Py_ssize_t, PyObject *);
|
||||
PyAPI_FUNC(PyObject *) PyTuple_GetSlice(PyObject *, Py_ssize_t, Py_ssize_t);
|
||||
PyAPI_FUNC(int) _PyTuple_Resize(PyObject **, Py_ssize_t);
|
||||
PyAPI_FUNC(PyObject *) PyTuple_Pack(Py_ssize_t, ...);
|
||||
|
||||
/* Macro, trading safety for speed */
|
||||
#define PyTuple_GET_ITEM(op, i) (((PyTupleObject *)(op))->ob_item[i])
|
||||
|
|
|
|||
|
|
@ -372,7 +372,7 @@ extern "C" {
|
|||
|
||||
typedef struct {
|
||||
PyObject_HEAD
|
||||
int length; /* Length of raw Unicode data in buffer */
|
||||
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
|
||||
|
|
@ -420,7 +420,7 @@ PyAPI_DATA(PyTypeObject) PyUnicode_Type;
|
|||
|
||||
PyAPI_FUNC(PyObject*) PyUnicode_FromUnicode(
|
||||
const Py_UNICODE *u, /* Unicode buffer */
|
||||
int size /* size of buffer */
|
||||
Py_ssize_t size /* size of buffer */
|
||||
);
|
||||
|
||||
/* Return a read-only pointer to the Unicode object's internal
|
||||
|
|
@ -432,7 +432,7 @@ PyAPI_FUNC(Py_UNICODE *) PyUnicode_AsUnicode(
|
|||
|
||||
/* Get the length of the Unicode object. */
|
||||
|
||||
PyAPI_FUNC(int) PyUnicode_GetSize(
|
||||
PyAPI_FUNC(Py_ssize_t) PyUnicode_GetSize(
|
||||
PyObject *unicode /* Unicode object */
|
||||
);
|
||||
|
||||
|
|
@ -455,7 +455,7 @@ PyAPI_FUNC(Py_UNICODE) PyUnicode_GetMax(void);
|
|||
|
||||
PyAPI_FUNC(int) PyUnicode_Resize(
|
||||
PyObject **unicode, /* Pointer to the Unicode object */
|
||||
int length /* New length */
|
||||
Py_ssize_t length /* New length */
|
||||
);
|
||||
|
||||
/* Coerce obj to an Unicode object and return a reference with
|
||||
|
|
@ -509,7 +509,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_FromObject(
|
|||
|
||||
PyAPI_FUNC(PyObject*) PyUnicode_FromWideChar(
|
||||
register const wchar_t *w, /* wchar_t buffer */
|
||||
int size /* size of buffer */
|
||||
Py_ssize_t size /* size of buffer */
|
||||
);
|
||||
|
||||
/* Copies the Unicode Object contents into the wchar_t buffer w. At
|
||||
|
|
@ -524,10 +524,10 @@ PyAPI_FUNC(PyObject*) PyUnicode_FromWideChar(
|
|||
possibly trailing 0-termination character) or -1 in case of an
|
||||
error. */
|
||||
|
||||
PyAPI_FUNC(int) PyUnicode_AsWideChar(
|
||||
PyAPI_FUNC(Py_ssize_t) PyUnicode_AsWideChar(
|
||||
PyUnicodeObject *unicode, /* Unicode object */
|
||||
register wchar_t *w, /* wchar_t buffer */
|
||||
int size /* size of buffer */
|
||||
Py_ssize_t size /* size of buffer */
|
||||
);
|
||||
|
||||
#endif
|
||||
|
|
@ -609,7 +609,7 @@ PyAPI_FUNC(int) PyUnicode_SetDefaultEncoding(
|
|||
|
||||
PyAPI_FUNC(PyObject*) PyUnicode_Decode(
|
||||
const char *s, /* encoded string */
|
||||
int size, /* size of buffer */
|
||||
Py_ssize_t size, /* size of buffer */
|
||||
const char *encoding, /* encoding */
|
||||
const char *errors /* error handling */
|
||||
);
|
||||
|
|
@ -619,7 +619,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_Decode(
|
|||
|
||||
PyAPI_FUNC(PyObject*) PyUnicode_Encode(
|
||||
const Py_UNICODE *s, /* Unicode char buffer */
|
||||
int size, /* number of Py_UNICODE chars to encode */
|
||||
Py_ssize_t size, /* number of Py_UNICODE chars to encode */
|
||||
const char *encoding, /* encoding */
|
||||
const char *errors /* error handling */
|
||||
);
|
||||
|
|
@ -646,13 +646,13 @@ PyAPI_FUNC(PyObject*) PyUnicode_AsEncodedString(
|
|||
|
||||
PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF7(
|
||||
const char *string, /* UTF-7 encoded string */
|
||||
int length, /* size of string */
|
||||
Py_ssize_t length, /* size of string */
|
||||
const char *errors /* error handling */
|
||||
);
|
||||
|
||||
PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF7(
|
||||
const Py_UNICODE *data, /* Unicode char buffer */
|
||||
int length, /* number of Py_UNICODE chars to encode */
|
||||
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,
|
||||
|
|
@ -664,15 +664,15 @@ PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF7(
|
|||
|
||||
PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF8(
|
||||
const char *string, /* UTF-8 encoded string */
|
||||
int length, /* size of 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 */
|
||||
int length, /* size of string */
|
||||
Py_ssize_t length, /* size of string */
|
||||
const char *errors, /* error handling */
|
||||
int *consumed /* bytes consumed */
|
||||
Py_ssize_t *consumed /* bytes consumed */
|
||||
);
|
||||
|
||||
PyAPI_FUNC(PyObject*) PyUnicode_AsUTF8String(
|
||||
|
|
@ -681,7 +681,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_AsUTF8String(
|
|||
|
||||
PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF8(
|
||||
const Py_UNICODE *data, /* Unicode char buffer */
|
||||
int length, /* number of Py_UNICODE chars to encode */
|
||||
Py_ssize_t length, /* number of Py_UNICODE chars to encode */
|
||||
const char *errors /* error handling */
|
||||
);
|
||||
|
||||
|
|
@ -712,7 +712,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF8(
|
|||
|
||||
PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF16(
|
||||
const char *string, /* UTF-16 encoded string */
|
||||
int length, /* size of string */
|
||||
Py_ssize_t length, /* size of string */
|
||||
const char *errors, /* error handling */
|
||||
int *byteorder /* pointer to byteorder to use
|
||||
0=native;-1=LE,1=BE; updated on
|
||||
|
|
@ -721,12 +721,12 @@ PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF16(
|
|||
|
||||
PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF16Stateful(
|
||||
const char *string, /* UTF-16 encoded string */
|
||||
int length, /* size of string */
|
||||
Py_ssize_t length, /* size of string */
|
||||
const char *errors, /* error handling */
|
||||
int *byteorder, /* pointer to byteorder to use
|
||||
0=native;-1=LE,1=BE; updated on
|
||||
exit */
|
||||
int *consumed /* bytes consumed */
|
||||
Py_ssize_t *consumed /* bytes consumed */
|
||||
);
|
||||
|
||||
/* Returns a Python string using the UTF-16 encoding in native byte
|
||||
|
|
@ -758,7 +758,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_AsUTF16String(
|
|||
|
||||
PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF16(
|
||||
const Py_UNICODE *data, /* Unicode char buffer */
|
||||
int length, /* number of Py_UNICODE chars to encode */
|
||||
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 */
|
||||
);
|
||||
|
|
@ -767,7 +767,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF16(
|
|||
|
||||
PyAPI_FUNC(PyObject*) PyUnicode_DecodeUnicodeEscape(
|
||||
const char *string, /* Unicode-Escape encoded string */
|
||||
int length, /* size of string */
|
||||
Py_ssize_t length, /* size of string */
|
||||
const char *errors /* error handling */
|
||||
);
|
||||
|
||||
|
|
@ -777,14 +777,14 @@ PyAPI_FUNC(PyObject*) PyUnicode_AsUnicodeEscapeString(
|
|||
|
||||
PyAPI_FUNC(PyObject*) PyUnicode_EncodeUnicodeEscape(
|
||||
const Py_UNICODE *data, /* Unicode char buffer */
|
||||
int length /* Number of Py_UNICODE chars to encode */
|
||||
Py_ssize_t length /* Number of Py_UNICODE chars to encode */
|
||||
);
|
||||
|
||||
/* --- Raw-Unicode-Escape Codecs ------------------------------------------ */
|
||||
|
||||
PyAPI_FUNC(PyObject*) PyUnicode_DecodeRawUnicodeEscape(
|
||||
const char *string, /* Raw-Unicode-Escape encoded string */
|
||||
int length, /* size of string */
|
||||
Py_ssize_t length, /* size of string */
|
||||
const char *errors /* error handling */
|
||||
);
|
||||
|
||||
|
|
@ -794,7 +794,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_AsRawUnicodeEscapeString(
|
|||
|
||||
PyAPI_FUNC(PyObject*) PyUnicode_EncodeRawUnicodeEscape(
|
||||
const Py_UNICODE *data, /* Unicode char buffer */
|
||||
int length /* Number of Py_UNICODE chars to encode */
|
||||
Py_ssize_t length /* Number of Py_UNICODE chars to encode */
|
||||
);
|
||||
|
||||
/* --- Unicode Internal Codec ---------------------------------------------
|
||||
|
|
@ -803,7 +803,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_EncodeRawUnicodeEscape(
|
|||
|
||||
PyObject *_PyUnicode_DecodeUnicodeInternal(
|
||||
const char *string,
|
||||
int length,
|
||||
Py_ssize_t length,
|
||||
const char *errors
|
||||
);
|
||||
|
||||
|
|
@ -815,7 +815,7 @@ PyObject *_PyUnicode_DecodeUnicodeInternal(
|
|||
|
||||
PyAPI_FUNC(PyObject*) PyUnicode_DecodeLatin1(
|
||||
const char *string, /* Latin-1 encoded string */
|
||||
int length, /* size of string */
|
||||
Py_ssize_t length, /* size of string */
|
||||
const char *errors /* error handling */
|
||||
);
|
||||
|
||||
|
|
@ -825,7 +825,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_AsLatin1String(
|
|||
|
||||
PyAPI_FUNC(PyObject*) PyUnicode_EncodeLatin1(
|
||||
const Py_UNICODE *data, /* Unicode char buffer */
|
||||
int length, /* Number of Py_UNICODE chars to encode */
|
||||
Py_ssize_t length, /* Number of Py_UNICODE chars to encode */
|
||||
const char *errors /* error handling */
|
||||
);
|
||||
|
||||
|
|
@ -837,7 +837,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_EncodeLatin1(
|
|||
|
||||
PyAPI_FUNC(PyObject*) PyUnicode_DecodeASCII(
|
||||
const char *string, /* ASCII encoded string */
|
||||
int length, /* size of string */
|
||||
Py_ssize_t length, /* size of string */
|
||||
const char *errors /* error handling */
|
||||
);
|
||||
|
||||
|
|
@ -847,7 +847,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_AsASCIIString(
|
|||
|
||||
PyAPI_FUNC(PyObject*) PyUnicode_EncodeASCII(
|
||||
const Py_UNICODE *data, /* Unicode char buffer */
|
||||
int length, /* Number of Py_UNICODE chars to encode */
|
||||
Py_ssize_t length, /* Number of Py_UNICODE chars to encode */
|
||||
const char *errors /* error handling */
|
||||
);
|
||||
|
||||
|
|
@ -875,7 +875,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_EncodeASCII(
|
|||
|
||||
PyAPI_FUNC(PyObject*) PyUnicode_DecodeCharmap(
|
||||
const char *string, /* Encoded string */
|
||||
int length, /* size of string */
|
||||
Py_ssize_t length, /* size of string */
|
||||
PyObject *mapping, /* character mapping
|
||||
(char ordinal -> unicode ordinal) */
|
||||
const char *errors /* error handling */
|
||||
|
|
@ -889,7 +889,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_AsCharmapString(
|
|||
|
||||
PyAPI_FUNC(PyObject*) PyUnicode_EncodeCharmap(
|
||||
const Py_UNICODE *data, /* Unicode char buffer */
|
||||
int length, /* Number of Py_UNICODE chars to encode */
|
||||
Py_ssize_t length, /* Number of Py_UNICODE chars to encode */
|
||||
PyObject *mapping, /* character mapping
|
||||
(unicode ordinal -> char ordinal) */
|
||||
const char *errors /* error handling */
|
||||
|
|
@ -910,7 +910,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_EncodeCharmap(
|
|||
|
||||
PyAPI_FUNC(PyObject *) PyUnicode_TranslateCharmap(
|
||||
const Py_UNICODE *data, /* Unicode char buffer */
|
||||
int length, /* Number of Py_UNICODE chars to encode */
|
||||
Py_ssize_t length, /* Number of Py_UNICODE chars to encode */
|
||||
PyObject *table, /* Translate table */
|
||||
const char *errors /* error handling */
|
||||
);
|
||||
|
|
@ -921,7 +921,7 @@ PyAPI_FUNC(PyObject *) PyUnicode_TranslateCharmap(
|
|||
|
||||
PyAPI_FUNC(PyObject*) PyUnicode_DecodeMBCS(
|
||||
const char *string, /* MBCS encoded string */
|
||||
int length, /* size of string */
|
||||
Py_ssize_t length, /* size of string */
|
||||
const char *errors /* error handling */
|
||||
);
|
||||
|
||||
|
|
@ -931,7 +931,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_AsMBCSString(
|
|||
|
||||
PyAPI_FUNC(PyObject*) PyUnicode_EncodeMBCS(
|
||||
const Py_UNICODE *data, /* Unicode char buffer */
|
||||
int length, /* Number of Py_UNICODE chars to encode */
|
||||
Py_ssize_t length, /* Number of Py_UNICODE chars to encode */
|
||||
const char *errors /* error handling */
|
||||
);
|
||||
|
||||
|
|
@ -963,7 +963,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_EncodeMBCS(
|
|||
|
||||
PyAPI_FUNC(int) PyUnicode_EncodeDecimal(
|
||||
Py_UNICODE *s, /* Unicode buffer */
|
||||
int length, /* Number of Py_UNICODE chars to encode */
|
||||
Py_ssize_t length, /* Number of Py_UNICODE chars to encode */
|
||||
char *output, /* Output buffer; must have size >= length */
|
||||
const char *errors /* error handling */
|
||||
);
|
||||
|
|
@ -995,7 +995,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_Concat(
|
|||
PyAPI_FUNC(PyObject*) PyUnicode_Split(
|
||||
PyObject *s, /* String to split */
|
||||
PyObject *sep, /* String separator */
|
||||
int maxsplit /* Maxsplit count */
|
||||
Py_ssize_t maxsplit /* Maxsplit count */
|
||||
);
|
||||
|
||||
/* Dito, but split at line breaks.
|
||||
|
|
@ -1024,7 +1024,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_Splitlines(
|
|||
PyAPI_FUNC(PyObject*) PyUnicode_RSplit(
|
||||
PyObject *s, /* String to split */
|
||||
PyObject *sep, /* String separator */
|
||||
int maxsplit /* Maxsplit count */
|
||||
Py_ssize_t maxsplit /* Maxsplit count */
|
||||
);
|
||||
|
||||
/* Translate a string by applying a character mapping table to it and
|
||||
|
|
@ -1056,11 +1056,11 @@ PyAPI_FUNC(PyObject*) PyUnicode_Join(
|
|||
/* Return 1 if substr matches str[start:end] at the given tail end, 0
|
||||
otherwise. */
|
||||
|
||||
PyAPI_FUNC(int) PyUnicode_Tailmatch(
|
||||
PyAPI_FUNC(Py_ssize_t) PyUnicode_Tailmatch(
|
||||
PyObject *str, /* String */
|
||||
PyObject *substr, /* Prefix or Suffix string */
|
||||
int start, /* Start index */
|
||||
int end, /* Stop index */
|
||||
Py_ssize_t start, /* Start index */
|
||||
Py_ssize_t end, /* Stop index */
|
||||
int direction /* Tail end: -1 prefix, +1 suffix */
|
||||
);
|
||||
|
||||
|
|
@ -1068,21 +1068,21 @@ PyAPI_FUNC(int) PyUnicode_Tailmatch(
|
|||
given search direction or -1 if not found. -2 is returned in case
|
||||
an error occurred and an exception is set. */
|
||||
|
||||
PyAPI_FUNC(int) PyUnicode_Find(
|
||||
PyAPI_FUNC(Py_ssize_t) PyUnicode_Find(
|
||||
PyObject *str, /* String */
|
||||
PyObject *substr, /* Substring to find */
|
||||
int start, /* Start index */
|
||||
int end, /* Stop index */
|
||||
Py_ssize_t start, /* Start index */
|
||||
Py_ssize_t end, /* Stop index */
|
||||
int direction /* Find direction: +1 forward, -1 backward */
|
||||
);
|
||||
|
||||
/* Count the number of occurrences of substr in str[start:end]. */
|
||||
|
||||
PyAPI_FUNC(int) PyUnicode_Count(
|
||||
PyAPI_FUNC(Py_ssize_t) PyUnicode_Count(
|
||||
PyObject *str, /* String */
|
||||
PyObject *substr, /* Substring to count */
|
||||
int start, /* Start index */
|
||||
int end /* Stop index */
|
||||
Py_ssize_t start, /* Start index */
|
||||
Py_ssize_t end /* Stop index */
|
||||
);
|
||||
|
||||
/* Replace at most maxcount occurrences of substr in str with replstr
|
||||
|
|
@ -1092,7 +1092,7 @@ PyAPI_FUNC(PyObject *) PyUnicode_Replace(
|
|||
PyObject *str, /* String */
|
||||
PyObject *substr, /* Substring to find */
|
||||
PyObject *replstr, /* Substring to replace */
|
||||
int maxcount /* Max. number of replacements to apply;
|
||||
Py_ssize_t maxcount /* Max. number of replacements to apply;
|
||||
-1 = all */
|
||||
);
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue