Victor Stinner | b6522d0 | 2016-12-19 13:12:08 +0100 | [diff] [blame] | 1 | /* Abstract Object Interface (many thanks to Jim Fulton) */ |
| 2 | |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 3 | #ifndef Py_ABSTRACTOBJECT_H |
| 4 | #define Py_ABSTRACTOBJECT_H |
| 5 | #ifdef __cplusplus |
| 6 | extern "C" { |
| 7 | #endif |
| 8 | |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 9 | /* === Object Protocol ================================================== */ |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 10 | |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 11 | /* Implemented elsewhere: |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 12 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 13 | int PyObject_Print(PyObject *o, FILE *fp, int flags); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 14 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 15 | Print an object 'o' on file 'fp'. Returns -1 on error. The flags argument |
| 16 | is used to enable certain printing options. The only option currently |
| 17 | supported is Py_Print_RAW. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 18 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 19 | (What should be said about Py_Print_RAW?). */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 20 | |
| 21 | |
| 22 | /* Implemented elsewhere: |
| 23 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 24 | int PyObject_HasAttrString(PyObject *o, const char *attr_name); |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 25 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 26 | Returns 1 if object 'o' has the attribute attr_name, and 0 otherwise. |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 27 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 28 | This is equivalent to the Python expression: hasattr(o,attr_name). |
| 29 | |
| 30 | This function always succeeds. */ |
| 31 | |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 32 | |
| 33 | /* Implemented elsewhere: |
| 34 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 35 | PyObject* PyObject_GetAttrString(PyObject *o, const char *attr_name); |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 36 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 37 | Retrieve an attributed named attr_name form object o. |
| 38 | Returns the attribute value on success, or NULL on failure. |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 39 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 40 | This is the equivalent of the Python expression: o.attr_name. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 41 | |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 42 | |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 43 | /* Implemented elsewhere: |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 44 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 45 | int PyObject_HasAttr(PyObject *o, PyObject *attr_name); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 46 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 47 | Returns 1 if o has the attribute attr_name, and 0 otherwise. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 48 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 49 | This is equivalent to the Python expression: hasattr(o,attr_name). |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 50 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 51 | This function always succeeds. */ |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 52 | |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 53 | /* Implemented elsewhere: |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 54 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 55 | PyObject* PyObject_GetAttr(PyObject *o, PyObject *attr_name); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 56 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 57 | Retrieve an attributed named 'attr_name' form object 'o'. |
| 58 | Returns the attribute value on success, or NULL on failure. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 59 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 60 | This is the equivalent of the Python expression: o.attr_name. */ |
Marc-André Lemburg | ad7c98e | 2001-01-17 17:09:53 +0000 | [diff] [blame] | 61 | |
Marc-André Lemburg | ad7c98e | 2001-01-17 17:09:53 +0000 | [diff] [blame] | 62 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 63 | /* Implemented elsewhere: |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 64 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 65 | int PyObject_SetAttrString(PyObject *o, const char *attr_name, PyObject *v); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 66 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 67 | Set the value of the attribute named attr_name, for object 'o', |
| 68 | to the value 'v'. Raise an exception and return -1 on failure; return 0 on |
| 69 | success. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 70 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 71 | This is the equivalent of the Python statement o.attr_name=v. */ |
| 72 | |
| 73 | |
| 74 | /* Implemented elsewhere: |
| 75 | |
| 76 | int PyObject_SetAttr(PyObject *o, PyObject *attr_name, PyObject *v); |
| 77 | |
| 78 | Set the value of the attribute named attr_name, for object 'o', to the value |
| 79 | 'v'. an exception and return -1 on failure; return 0 on success. |
| 80 | |
| 81 | This is the equivalent of the Python statement o.attr_name=v. */ |
| 82 | |
| 83 | /* Implemented as a macro: |
| 84 | |
| 85 | int PyObject_DelAttrString(PyObject *o, const char *attr_name); |
| 86 | |
| 87 | Delete attribute named attr_name, for object o. Returns |
| 88 | -1 on failure. |
| 89 | |
| 90 | This is the equivalent of the Python statement: del o.attr_name. */ |
| 91 | #define PyObject_DelAttrString(O,A) PyObject_SetAttrString((O),(A), NULL) |
| 92 | |
| 93 | |
| 94 | /* Implemented as a macro: |
| 95 | |
| 96 | int PyObject_DelAttr(PyObject *o, PyObject *attr_name); |
| 97 | |
| 98 | Delete attribute named attr_name, for object o. Returns -1 |
| 99 | on failure. This is the equivalent of the Python |
| 100 | statement: del o.attr_name. */ |
| 101 | #define PyObject_DelAttr(O,A) PyObject_SetAttr((O),(A), NULL) |
| 102 | |
| 103 | |
| 104 | /* Implemented elsewhere: |
| 105 | |
| 106 | PyObject *PyObject_Repr(PyObject *o); |
| 107 | |
| 108 | Compute the string representation of object 'o'. Returns the |
| 109 | string representation on success, NULL on failure. |
| 110 | |
| 111 | This is the equivalent of the Python expression: repr(o). |
| 112 | |
| 113 | Called by the repr() built-in function. */ |
| 114 | |
| 115 | |
| 116 | /* Implemented elsewhere: |
| 117 | |
| 118 | PyObject *PyObject_Str(PyObject *o); |
| 119 | |
| 120 | Compute the string representation of object, o. Returns the |
| 121 | string representation on success, NULL on failure. |
| 122 | |
| 123 | This is the equivalent of the Python expression: str(o). |
| 124 | |
| 125 | Called by the str() and print() built-in functions. */ |
| 126 | |
| 127 | |
| 128 | /* Declared elsewhere |
| 129 | |
| 130 | PyAPI_FUNC(int) PyCallable_Check(PyObject *o); |
| 131 | |
| 132 | Determine if the object, o, is callable. Return 1 if the object is callable |
| 133 | and 0 otherwise. |
| 134 | |
| 135 | This function always succeeds. */ |
| 136 | |
| 137 | |
| 138 | #ifdef PY_SSIZE_T_CLEAN |
| 139 | # define PyObject_CallFunction _PyObject_CallFunction_SizeT |
| 140 | # define PyObject_CallMethod _PyObject_CallMethod_SizeT |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 141 | #endif |
| 142 | |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 143 | |
Victor Stinner | 2ff58a2 | 2019-06-17 14:27:23 +0200 | [diff] [blame] | 144 | #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03090000 |
| 145 | /* Call a callable Python object without any arguments */ |
| 146 | PyAPI_FUNC(PyObject *) PyObject_CallNoArgs(PyObject *func); |
| 147 | #endif |
| 148 | |
| 149 | |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 150 | /* Call a callable Python object 'callable' with arguments given by the |
| 151 | tuple 'args' and keywords arguments given by the dictionary 'kwargs'. |
Tim Peters | 6d6c1a3 | 2001-08-02 04:15:00 +0000 | [diff] [blame] | 152 | |
Serhiy Storchaka | 25fc088 | 2019-10-30 12:03:20 +0200 | [diff] [blame] | 153 | 'args' must not be NULL, use an empty tuple if no arguments are |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 154 | needed. If no named arguments are needed, 'kwargs' can be NULL. |
Victor Stinner | 2d0eb65 | 2016-12-06 16:27:24 +0100 | [diff] [blame] | 155 | |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 156 | This is the equivalent of the Python expression: |
| 157 | callable(*args, **kwargs). */ |
| 158 | PyAPI_FUNC(PyObject *) PyObject_Call(PyObject *callable, |
| 159 | PyObject *args, PyObject *kwargs); |
| 160 | |
Victor Stinner | 2d0eb65 | 2016-12-06 16:27:24 +0100 | [diff] [blame] | 161 | |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 162 | /* Call a callable Python object 'callable', with arguments given by the |
Serhiy Storchaka | 25fc088 | 2019-10-30 12:03:20 +0200 | [diff] [blame] | 163 | tuple 'args'. If no arguments are needed, then 'args' can be NULL. |
Victor Stinner | 2d0eb65 | 2016-12-06 16:27:24 +0100 | [diff] [blame] | 164 | |
Serhiy Storchaka | 25fc088 | 2019-10-30 12:03:20 +0200 | [diff] [blame] | 165 | Returns the result of the call on success, or NULL on failure. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 166 | |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 167 | This is the equivalent of the Python expression: |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 168 | callable(*args). */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 169 | PyAPI_FUNC(PyObject *) PyObject_CallObject(PyObject *callable, |
| 170 | PyObject *args); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 171 | |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 172 | /* Call a callable Python object, callable, with a variable number of C |
| 173 | arguments. The C arguments are described using a mkvalue-style format |
| 174 | string. |
Victor Stinner | 2d0eb65 | 2016-12-06 16:27:24 +0100 | [diff] [blame] | 175 | |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 176 | The format may be NULL, indicating that no arguments are provided. |
Victor Stinner | 2d0eb65 | 2016-12-06 16:27:24 +0100 | [diff] [blame] | 177 | |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 178 | Returns the result of the call on success, or NULL on failure. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 179 | |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 180 | This is the equivalent of the Python expression: |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 181 | callable(arg1, arg2, ...). */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 182 | PyAPI_FUNC(PyObject *) PyObject_CallFunction(PyObject *callable, |
| 183 | const char *format, ...); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 184 | |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 185 | /* Call the method named 'name' of object 'obj' with a variable number of |
| 186 | C arguments. The C arguments are described by a mkvalue format string. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 187 | |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 188 | The format can be NULL, indicating that no arguments are provided. |
Victor Stinner | 2d0eb65 | 2016-12-06 16:27:24 +0100 | [diff] [blame] | 189 | |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 190 | Returns the result of the call on success, or NULL on failure. |
| 191 | |
| 192 | This is the equivalent of the Python expression: |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 193 | obj.name(arg1, arg2, ...). */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 194 | PyAPI_FUNC(PyObject *) PyObject_CallMethod(PyObject *obj, |
| 195 | const char *name, |
| 196 | const char *format, ...); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 197 | |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 198 | PyAPI_FUNC(PyObject *) _PyObject_CallFunction_SizeT(PyObject *callable, |
| 199 | const char *format, |
| 200 | ...); |
| 201 | |
| 202 | PyAPI_FUNC(PyObject *) _PyObject_CallMethod_SizeT(PyObject *obj, |
| 203 | const char *name, |
| 204 | const char *format, |
| 205 | ...); |
| 206 | |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 207 | /* Call a callable Python object 'callable' with a variable number of C |
| 208 | arguments. The C arguments are provided as PyObject* values, terminated |
| 209 | by a NULL. |
Victor Stinner | 2d0eb65 | 2016-12-06 16:27:24 +0100 | [diff] [blame] | 210 | |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 211 | Returns the result of the call on success, or NULL on failure. |
Victor Stinner | 2d0eb65 | 2016-12-06 16:27:24 +0100 | [diff] [blame] | 212 | |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 213 | This is the equivalent of the Python expression: |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 214 | callable(arg1, arg2, ...). */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 215 | PyAPI_FUNC(PyObject *) PyObject_CallFunctionObjArgs(PyObject *callable, |
| 216 | ...); |
Fred Drake | b421b8c | 2001-10-26 16:21:32 +0000 | [diff] [blame] | 217 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 218 | /* Call the method named 'name' of object 'obj' with a variable number of |
| 219 | C arguments. The C arguments are provided as PyObject* values, terminated |
| 220 | by NULL. |
| 221 | |
| 222 | Returns the result of the call on success, or NULL on failure. |
| 223 | |
| 224 | This is the equivalent of the Python expression: obj.name(*args). */ |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 225 | |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 226 | PyAPI_FUNC(PyObject *) PyObject_CallMethodObjArgs( |
| 227 | PyObject *obj, |
| 228 | PyObject *name, |
| 229 | ...); |
| 230 | |
Victor Stinner | 2d0eb65 | 2016-12-06 16:27:24 +0100 | [diff] [blame] | 231 | |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 232 | /* Implemented elsewhere: |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 233 | |
Andrew Svetlov | 9508402 | 2017-12-16 21:08:05 +0200 | [diff] [blame] | 234 | Py_hash_t PyObject_Hash(PyObject *o); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 235 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 236 | Compute and return the hash, hash_value, of an object, o. On |
| 237 | failure, return -1. |
| 238 | |
| 239 | This is the equivalent of the Python expression: hash(o). */ |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 240 | |
| 241 | |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 242 | /* Implemented elsewhere: |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 243 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 244 | int PyObject_IsTrue(PyObject *o); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 245 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 246 | Returns 1 if the object, o, is considered to be true, 0 if o is |
| 247 | considered to be false and -1 on failure. |
| 248 | |
| 249 | This is equivalent to the Python expression: not not o. */ |
| 250 | |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 251 | |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 252 | /* Implemented elsewhere: |
Guido van Rossum | c3d3f96 | 1998-04-09 17:53:59 +0000 | [diff] [blame] | 253 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 254 | int PyObject_Not(PyObject *o); |
Guido van Rossum | c3d3f96 | 1998-04-09 17:53:59 +0000 | [diff] [blame] | 255 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 256 | Returns 0 if the object, o, is considered to be true, 1 if o is |
| 257 | considered to be false and -1 on failure. |
Guido van Rossum | c3d3f96 | 1998-04-09 17:53:59 +0000 | [diff] [blame] | 258 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 259 | This is equivalent to the Python expression: not o. */ |
| 260 | |
| 261 | |
| 262 | /* Get the type of an object. |
| 263 | |
| 264 | On success, returns a type object corresponding to the object type of object |
| 265 | 'o'. On failure, returns NULL. |
| 266 | |
| 267 | This is equivalent to the Python expression: type(o) */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 268 | PyAPI_FUNC(PyObject *) PyObject_Type(PyObject *o); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 269 | |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 270 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 271 | /* Return the size of object 'o'. If the object 'o' provides both sequence and |
| 272 | mapping protocols, the sequence size is returned. |
| 273 | |
| 274 | On error, -1 is returned. |
| 275 | |
| 276 | This is the equivalent to the Python expression: len(o) */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 277 | PyAPI_FUNC(Py_ssize_t) PyObject_Size(PyObject *o); |
Jeremy Hylton | 6253f83 | 2000-07-12 12:56:19 +0000 | [diff] [blame] | 278 | |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 279 | |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 280 | /* For DLL compatibility */ |
Marc-André Lemburg | cf5f358 | 2000-07-17 09:22:55 +0000 | [diff] [blame] | 281 | #undef PyObject_Length |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 282 | PyAPI_FUNC(Py_ssize_t) PyObject_Length(PyObject *o); |
Marc-André Lemburg | cf5f358 | 2000-07-17 09:22:55 +0000 | [diff] [blame] | 283 | #define PyObject_Length PyObject_Size |
| 284 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 285 | /* Return element of 'o' corresponding to the object 'key'. Return NULL |
| 286 | on failure. |
Marc-André Lemburg | cf5f358 | 2000-07-17 09:22:55 +0000 | [diff] [blame] | 287 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 288 | This is the equivalent of the Python expression: o[key] */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 289 | PyAPI_FUNC(PyObject *) PyObject_GetItem(PyObject *o, PyObject *key); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 290 | |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 291 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 292 | /* Map the object 'key' to the value 'v' into 'o'. |
| 293 | |
| 294 | Raise an exception and return -1 on failure; return 0 on success. |
| 295 | |
| 296 | This is the equivalent of the Python statement: o[key]=v. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 297 | PyAPI_FUNC(int) PyObject_SetItem(PyObject *o, PyObject *key, PyObject *v); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 298 | |
Serhiy Storchaka | f5b1183 | 2018-05-22 11:02:44 +0300 | [diff] [blame] | 299 | /* Remove the mapping for the string 'key' from the object 'o'. |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 300 | Returns -1 on failure. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 301 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 302 | This is equivalent to the Python statement: del o[key]. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 303 | PyAPI_FUNC(int) PyObject_DelItemString(PyObject *o, const char *key); |
Martin v. Löwis | b0d71d0 | 2002-01-05 10:50:30 +0000 | [diff] [blame] | 304 | |
Serhiy Storchaka | f5b1183 | 2018-05-22 11:02:44 +0300 | [diff] [blame] | 305 | /* Delete the mapping for the object 'key' from the object 'o'. |
| 306 | Returns -1 on failure. |
Martin v. Löwis | b0d71d0 | 2002-01-05 10:50:30 +0000 | [diff] [blame] | 307 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 308 | This is the equivalent of the Python statement: del o[key]. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 309 | PyAPI_FUNC(int) PyObject_DelItem(PyObject *o, PyObject *key); |
Guido van Rossum | 6cdc6f4 | 1996-08-21 17:41:54 +0000 | [diff] [blame] | 310 | |
Guido van Rossum | 6cdc6f4 | 1996-08-21 17:41:54 +0000 | [diff] [blame] | 311 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 312 | /* === Old Buffer API ============================================ */ |
| 313 | |
| 314 | /* FIXME: usage of these should all be replaced in Python itself |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 315 | but for backwards compatibility we will implement them. |
| 316 | Their usage without a corresponding "unlock" mechanism |
| 317 | may create issues (but they would already be there). */ |
Travis E. Oliphant | b99f762 | 2007-08-18 11:21:56 +0000 | [diff] [blame] | 318 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 319 | /* Takes an arbitrary object which must support the (character, single segment) |
| 320 | buffer interface and returns a pointer to a read-only memory location |
| 321 | useable as character based input for subsequent processing. |
| 322 | |
| 323 | Return 0 on success. buffer and buffer_len are only set in case no error |
| 324 | occurs. Otherwise, -1 is returned and an exception set. */ |
Zackery Spytz | 3c8724f | 2019-05-28 09:16:33 -0600 | [diff] [blame] | 325 | Py_DEPRECATED(3.0) |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 326 | PyAPI_FUNC(int) PyObject_AsCharBuffer(PyObject *obj, |
| 327 | const char **buffer, |
Zackery Spytz | 3c8724f | 2019-05-28 09:16:33 -0600 | [diff] [blame] | 328 | Py_ssize_t *buffer_len); |
Guido van Rossum | fd9eed3 | 2000-03-10 22:35:06 +0000 | [diff] [blame] | 329 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 330 | /* Checks whether an arbitrary object supports the (character, single segment) |
| 331 | buffer interface. |
Guido van Rossum | fd9eed3 | 2000-03-10 22:35:06 +0000 | [diff] [blame] | 332 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 333 | Returns 1 on success, 0 on failure. */ |
Zackery Spytz | 3c8724f | 2019-05-28 09:16:33 -0600 | [diff] [blame] | 334 | Py_DEPRECATED(3.0) PyAPI_FUNC(int) PyObject_CheckReadBuffer(PyObject *obj); |
Jeremy Hylton | 89c3a22 | 2001-11-09 21:59:42 +0000 | [diff] [blame] | 335 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 336 | /* Same as PyObject_AsCharBuffer() except that this API expects (readable, |
| 337 | single segment) buffer interface and returns a pointer to a read-only memory |
| 338 | location which can contain arbitrary data. |
Jeremy Hylton | 89c3a22 | 2001-11-09 21:59:42 +0000 | [diff] [blame] | 339 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 340 | 0 is returned on success. buffer and buffer_len are only set in case no |
| 341 | error occurs. Otherwise, -1 is returned and an exception set. */ |
Zackery Spytz | 3c8724f | 2019-05-28 09:16:33 -0600 | [diff] [blame] | 342 | Py_DEPRECATED(3.0) |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 343 | PyAPI_FUNC(int) PyObject_AsReadBuffer(PyObject *obj, |
| 344 | const void **buffer, |
Zackery Spytz | 3c8724f | 2019-05-28 09:16:33 -0600 | [diff] [blame] | 345 | Py_ssize_t *buffer_len); |
Guido van Rossum | fd9eed3 | 2000-03-10 22:35:06 +0000 | [diff] [blame] | 346 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 347 | /* Takes an arbitrary object which must support the (writable, single segment) |
| 348 | buffer interface and returns a pointer to a writable memory location in |
| 349 | buffer of size 'buffer_len'. |
Guido van Rossum | fd9eed3 | 2000-03-10 22:35:06 +0000 | [diff] [blame] | 350 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 351 | Return 0 on success. buffer and buffer_len are only set in case no error |
| 352 | occurs. Otherwise, -1 is returned and an exception set. */ |
Zackery Spytz | 3c8724f | 2019-05-28 09:16:33 -0600 | [diff] [blame] | 353 | Py_DEPRECATED(3.0) |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 354 | PyAPI_FUNC(int) PyObject_AsWriteBuffer(PyObject *obj, |
| 355 | void **buffer, |
Zackery Spytz | 3c8724f | 2019-05-28 09:16:33 -0600 | [diff] [blame] | 356 | Py_ssize_t *buffer_len); |
Guido van Rossum | fd9eed3 | 2000-03-10 22:35:06 +0000 | [diff] [blame] | 357 | |
Guido van Rossum | fd9eed3 | 2000-03-10 22:35:06 +0000 | [diff] [blame] | 358 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 359 | /* === New Buffer API ============================================ */ |
Travis E. Oliphant | b99f762 | 2007-08-18 11:21:56 +0000 | [diff] [blame] | 360 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 361 | /* Takes an arbitrary object and returns the result of calling |
| 362 | obj.__format__(format_spec). */ |
| 363 | PyAPI_FUNC(PyObject *) PyObject_Format(PyObject *obj, |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 364 | PyObject *format_spec); |
Eric Smith | 8fd3eba | 2008-02-17 19:48:00 +0000 | [diff] [blame] | 365 | |
Guido van Rossum | 213c7a6 | 2001-04-23 14:08:49 +0000 | [diff] [blame] | 366 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 367 | /* ==== Iterators ================================================ */ |
| 368 | |
| 369 | /* Takes an object and returns an iterator for it. |
| 370 | This is typically a new iterator but if the argument is an iterator, this |
| 371 | returns itself. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 372 | PyAPI_FUNC(PyObject *) PyObject_GetIter(PyObject *); |
Guido van Rossum | 59d1d2b | 2001-04-20 19:13:02 +0000 | [diff] [blame] | 373 | |
Christian Tismer | ea62ce7 | 2018-06-09 20:32:25 +0200 | [diff] [blame] | 374 | /* Returns 1 if the object 'obj' provides iterator protocols, and 0 otherwise. |
| 375 | |
| 376 | This function always succeeds. */ |
Serhiy Storchaka | 5cbefa9 | 2018-06-11 15:01:47 +0300 | [diff] [blame] | 377 | PyAPI_FUNC(int) PyIter_Check(PyObject *); |
Guido van Rossum | 213c7a6 | 2001-04-23 14:08:49 +0000 | [diff] [blame] | 378 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 379 | /* Takes an iterator object and calls its tp_iternext slot, |
| 380 | returning the next value. |
| 381 | |
| 382 | If the iterator is exhausted, this returns NULL without setting an |
| 383 | exception. |
| 384 | |
| 385 | NULL with an exception means an error occurred. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 386 | PyAPI_FUNC(PyObject *) PyIter_Next(PyObject *); |
Guido van Rossum | 213c7a6 | 2001-04-23 14:08:49 +0000 | [diff] [blame] | 387 | |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 388 | |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 389 | /* === Number Protocol ================================================== */ |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 390 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 391 | /* Returns 1 if the object 'o' provides numeric protocols, and 0 otherwise. |
| 392 | |
| 393 | This function always succeeds. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 394 | PyAPI_FUNC(int) PyNumber_Check(PyObject *o); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 395 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 396 | /* Returns the result of adding o1 and o2, or NULL on failure. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 397 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 398 | This is the equivalent of the Python expression: o1 + o2. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 399 | PyAPI_FUNC(PyObject *) PyNumber_Add(PyObject *o1, PyObject *o2); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 400 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 401 | /* Returns the result of subtracting o2 from o1, or NULL on failure. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 402 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 403 | This is the equivalent of the Python expression: o1 - o2. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 404 | PyAPI_FUNC(PyObject *) PyNumber_Subtract(PyObject *o1, PyObject *o2); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 405 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 406 | /* Returns the result of multiplying o1 and o2, or NULL on failure. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 407 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 408 | This is the equivalent of the Python expression: o1 * o2. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 409 | PyAPI_FUNC(PyObject *) PyNumber_Multiply(PyObject *o1, PyObject *o2); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 410 | |
Serhiy Storchaka | 34d0ac8 | 2016-12-27 14:57:39 +0200 | [diff] [blame] | 411 | #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000 |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 412 | /* This is the equivalent of the Python expression: o1 @ o2. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 413 | PyAPI_FUNC(PyObject *) PyNumber_MatrixMultiply(PyObject *o1, PyObject *o2); |
Serhiy Storchaka | 34d0ac8 | 2016-12-27 14:57:39 +0200 | [diff] [blame] | 414 | #endif |
Benjamin Peterson | d51374e | 2014-04-09 23:55:56 -0400 | [diff] [blame] | 415 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 416 | /* Returns the result of dividing o1 by o2 giving an integral result, |
| 417 | or NULL on failure. |
Guido van Rossum | 4668b00 | 2001-08-08 05:00:18 +0000 | [diff] [blame] | 418 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 419 | This is the equivalent of the Python expression: o1 // o2. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 420 | PyAPI_FUNC(PyObject *) PyNumber_FloorDivide(PyObject *o1, PyObject *o2); |
Guido van Rossum | 4668b00 | 2001-08-08 05:00:18 +0000 | [diff] [blame] | 421 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 422 | /* Returns the result of dividing o1 by o2 giving a float result, or NULL on |
| 423 | failure. |
Guido van Rossum | 4668b00 | 2001-08-08 05:00:18 +0000 | [diff] [blame] | 424 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 425 | This is the equivalent of the Python expression: o1 / o2. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 426 | PyAPI_FUNC(PyObject *) PyNumber_TrueDivide(PyObject *o1, PyObject *o2); |
Guido van Rossum | 4668b00 | 2001-08-08 05:00:18 +0000 | [diff] [blame] | 427 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 428 | /* Returns the remainder of dividing o1 by o2, or NULL on failure. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 429 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 430 | This is the equivalent of the Python expression: o1 % o2. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 431 | PyAPI_FUNC(PyObject *) PyNumber_Remainder(PyObject *o1, PyObject *o2); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 432 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 433 | /* See the built-in function divmod. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 434 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 435 | Returns NULL on failure. |
| 436 | |
| 437 | This is the equivalent of the Python expression: divmod(o1, o2). */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 438 | PyAPI_FUNC(PyObject *) PyNumber_Divmod(PyObject *o1, PyObject *o2); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 439 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 440 | /* See the built-in function pow. Returns NULL on failure. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 441 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 442 | This is the equivalent of the Python expression: pow(o1, o2, o3), |
| 443 | where o3 is optional. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 444 | PyAPI_FUNC(PyObject *) PyNumber_Power(PyObject *o1, PyObject *o2, |
| 445 | PyObject *o3); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 446 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 447 | /* Returns the negation of o on success, or NULL on failure. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 448 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 449 | This is the equivalent of the Python expression: -o. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 450 | PyAPI_FUNC(PyObject *) PyNumber_Negative(PyObject *o); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 451 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 452 | /* Returns the positive of o on success, or NULL on failure. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 453 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 454 | This is the equivalent of the Python expression: +o. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 455 | PyAPI_FUNC(PyObject *) PyNumber_Positive(PyObject *o); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 456 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 457 | /* Returns the absolute value of 'o', or NULL on failure. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 458 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 459 | This is the equivalent of the Python expression: abs(o). */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 460 | PyAPI_FUNC(PyObject *) PyNumber_Absolute(PyObject *o); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 461 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 462 | /* Returns the bitwise negation of 'o' on success, or NULL on failure. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 463 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 464 | This is the equivalent of the Python expression: ~o. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 465 | PyAPI_FUNC(PyObject *) PyNumber_Invert(PyObject *o); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 466 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 467 | /* Returns the result of left shifting o1 by o2 on success, or NULL on failure. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 468 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 469 | This is the equivalent of the Python expression: o1 << o2. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 470 | PyAPI_FUNC(PyObject *) PyNumber_Lshift(PyObject *o1, PyObject *o2); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 471 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 472 | /* Returns the result of right shifting o1 by o2 on success, or NULL on |
| 473 | failure. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 474 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 475 | This is the equivalent of the Python expression: o1 >> o2. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 476 | PyAPI_FUNC(PyObject *) PyNumber_Rshift(PyObject *o1, PyObject *o2); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 477 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 478 | /* Returns the result of bitwise and of o1 and o2 on success, or NULL on |
| 479 | failure. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 480 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 481 | This is the equivalent of the Python expression: o1 & o2. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 482 | PyAPI_FUNC(PyObject *) PyNumber_And(PyObject *o1, PyObject *o2); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 483 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 484 | /* Returns the bitwise exclusive or of o1 by o2 on success, or NULL on failure. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 485 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 486 | This is the equivalent of the Python expression: o1 ^ o2. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 487 | PyAPI_FUNC(PyObject *) PyNumber_Xor(PyObject *o1, PyObject *o2); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 488 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 489 | /* Returns the result of bitwise or on o1 and o2 on success, or NULL on |
| 490 | failure. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 491 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 492 | This is the equivalent of the Python expression: o1 | o2. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 493 | PyAPI_FUNC(PyObject *) PyNumber_Or(PyObject *o1, PyObject *o2); |
| 494 | |
Christian Tismer | ea62ce7 | 2018-06-09 20:32:25 +0200 | [diff] [blame] | 495 | /* Returns 1 if obj is an index integer (has the nb_index slot of the |
| 496 | tp_as_number structure filled in), and 0 otherwise. */ |
Serhiy Storchaka | 5cbefa9 | 2018-06-11 15:01:47 +0300 | [diff] [blame] | 497 | PyAPI_FUNC(int) PyIndex_Check(PyObject *); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 498 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 499 | /* Returns the object 'o' converted to a Python int, or NULL with an exception |
| 500 | raised on failure. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 501 | PyAPI_FUNC(PyObject *) PyNumber_Index(PyObject *o); |
Guido van Rossum | 38fff8c | 2006-03-07 18:50:55 +0000 | [diff] [blame] | 502 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 503 | /* Returns the object 'o' converted to Py_ssize_t by going through |
| 504 | PyNumber_Index() first. |
Guido van Rossum | 38fff8c | 2006-03-07 18:50:55 +0000 | [diff] [blame] | 505 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 506 | If an overflow error occurs while converting the int to Py_ssize_t, then the |
| 507 | second argument 'exc' is the error-type to return. If it is NULL, then the |
| 508 | overflow error is cleared and the value is clipped. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 509 | PyAPI_FUNC(Py_ssize_t) PyNumber_AsSsize_t(PyObject *o, PyObject *exc); |
Thomas Wouters | 00ee7ba | 2006-08-21 19:07:27 +0000 | [diff] [blame] | 510 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 511 | /* Returns the object 'o' converted to an integer object on success, or NULL |
| 512 | on failure. |
Guido van Rossum | 38fff8c | 2006-03-07 18:50:55 +0000 | [diff] [blame] | 513 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 514 | This is the equivalent of the Python expression: int(o). */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 515 | PyAPI_FUNC(PyObject *) PyNumber_Long(PyObject *o); |
Mark Dickinson | d746768 | 2009-01-10 22:14:33 +0000 | [diff] [blame] | 516 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 517 | /* Returns the object 'o' converted to a float object on success, or NULL |
| 518 | on failure. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 519 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 520 | This is the equivalent of the Python expression: float(o). */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 521 | PyAPI_FUNC(PyObject *) PyNumber_Float(PyObject *o); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 522 | |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 523 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 524 | /* --- In-place variants of (some of) the above number protocol functions -- */ |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 525 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 526 | /* Returns the result of adding o2 to o1, possibly in-place, or NULL |
| 527 | on failure. |
Thomas Wouters | dd8dbdb | 2000-08-24 20:09:45 +0000 | [diff] [blame] | 528 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 529 | This is the equivalent of the Python expression: o1 += o2. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 530 | PyAPI_FUNC(PyObject *) PyNumber_InPlaceAdd(PyObject *o1, PyObject *o2); |
Thomas Wouters | dd8dbdb | 2000-08-24 20:09:45 +0000 | [diff] [blame] | 531 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 532 | /* Returns the result of subtracting o2 from o1, possibly in-place or |
| 533 | NULL on failure. |
Thomas Wouters | dd8dbdb | 2000-08-24 20:09:45 +0000 | [diff] [blame] | 534 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 535 | This is the equivalent of the Python expression: o1 -= o2. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 536 | PyAPI_FUNC(PyObject *) PyNumber_InPlaceSubtract(PyObject *o1, PyObject *o2); |
Thomas Wouters | dd8dbdb | 2000-08-24 20:09:45 +0000 | [diff] [blame] | 537 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 538 | /* Returns the result of multiplying o1 by o2, possibly in-place, or NULL on |
| 539 | failure. |
Thomas Wouters | dd8dbdb | 2000-08-24 20:09:45 +0000 | [diff] [blame] | 540 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 541 | This is the equivalent of the Python expression: o1 *= o2. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 542 | PyAPI_FUNC(PyObject *) PyNumber_InPlaceMultiply(PyObject *o1, PyObject *o2); |
Thomas Wouters | dd8dbdb | 2000-08-24 20:09:45 +0000 | [diff] [blame] | 543 | |
Serhiy Storchaka | 34d0ac8 | 2016-12-27 14:57:39 +0200 | [diff] [blame] | 544 | #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000 |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 545 | /* This is the equivalent of the Python expression: o1 @= o2. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 546 | PyAPI_FUNC(PyObject *) PyNumber_InPlaceMatrixMultiply(PyObject *o1, PyObject *o2); |
Serhiy Storchaka | 34d0ac8 | 2016-12-27 14:57:39 +0200 | [diff] [blame] | 547 | #endif |
Benjamin Peterson | d51374e | 2014-04-09 23:55:56 -0400 | [diff] [blame] | 548 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 549 | /* Returns the result of dividing o1 by o2 giving an integral result, possibly |
| 550 | in-place, or NULL on failure. |
Benjamin Peterson | d51374e | 2014-04-09 23:55:56 -0400 | [diff] [blame] | 551 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 552 | This is the equivalent of the Python expression: o1 /= o2. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 553 | PyAPI_FUNC(PyObject *) PyNumber_InPlaceFloorDivide(PyObject *o1, |
| 554 | PyObject *o2); |
Guido van Rossum | 4668b00 | 2001-08-08 05:00:18 +0000 | [diff] [blame] | 555 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 556 | /* Returns the result of dividing o1 by o2 giving a float result, possibly |
| 557 | in-place, or null on failure. |
Guido van Rossum | 4668b00 | 2001-08-08 05:00:18 +0000 | [diff] [blame] | 558 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 559 | This is the equivalent of the Python expression: o1 /= o2. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 560 | PyAPI_FUNC(PyObject *) PyNumber_InPlaceTrueDivide(PyObject *o1, |
| 561 | PyObject *o2); |
Guido van Rossum | 4668b00 | 2001-08-08 05:00:18 +0000 | [diff] [blame] | 562 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 563 | /* Returns the remainder of dividing o1 by o2, possibly in-place, or NULL on |
| 564 | failure. |
Guido van Rossum | 4668b00 | 2001-08-08 05:00:18 +0000 | [diff] [blame] | 565 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 566 | This is the equivalent of the Python expression: o1 %= o2. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 567 | PyAPI_FUNC(PyObject *) PyNumber_InPlaceRemainder(PyObject *o1, PyObject *o2); |
Thomas Wouters | dd8dbdb | 2000-08-24 20:09:45 +0000 | [diff] [blame] | 568 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 569 | /* Returns the result of raising o1 to the power of o2, possibly in-place, |
| 570 | or NULL on failure. |
Thomas Wouters | dd8dbdb | 2000-08-24 20:09:45 +0000 | [diff] [blame] | 571 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 572 | This is the equivalent of the Python expression: o1 **= o2, |
| 573 | or o1 = pow(o1, o2, o3) if o3 is present. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 574 | PyAPI_FUNC(PyObject *) PyNumber_InPlacePower(PyObject *o1, PyObject *o2, |
| 575 | PyObject *o3); |
Thomas Wouters | dd8dbdb | 2000-08-24 20:09:45 +0000 | [diff] [blame] | 576 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 577 | /* Returns the result of left shifting o1 by o2, possibly in-place, or NULL |
| 578 | on failure. |
Thomas Wouters | dd8dbdb | 2000-08-24 20:09:45 +0000 | [diff] [blame] | 579 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 580 | This is the equivalent of the Python expression: o1 <<= o2. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 581 | PyAPI_FUNC(PyObject *) PyNumber_InPlaceLshift(PyObject *o1, PyObject *o2); |
Thomas Wouters | dd8dbdb | 2000-08-24 20:09:45 +0000 | [diff] [blame] | 582 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 583 | /* Returns the result of right shifting o1 by o2, possibly in-place or NULL |
| 584 | on failure. |
Thomas Wouters | dd8dbdb | 2000-08-24 20:09:45 +0000 | [diff] [blame] | 585 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 586 | This is the equivalent of the Python expression: o1 >>= o2. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 587 | PyAPI_FUNC(PyObject *) PyNumber_InPlaceRshift(PyObject *o1, PyObject *o2); |
Thomas Wouters | dd8dbdb | 2000-08-24 20:09:45 +0000 | [diff] [blame] | 588 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 589 | /* Returns the result of bitwise and of o1 and o2, possibly in-place, or NULL |
| 590 | on failure. |
Thomas Wouters | dd8dbdb | 2000-08-24 20:09:45 +0000 | [diff] [blame] | 591 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 592 | This is the equivalent of the Python expression: o1 &= o2. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 593 | PyAPI_FUNC(PyObject *) PyNumber_InPlaceAnd(PyObject *o1, PyObject *o2); |
Thomas Wouters | dd8dbdb | 2000-08-24 20:09:45 +0000 | [diff] [blame] | 594 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 595 | /* Returns the bitwise exclusive or of o1 by o2, possibly in-place, or NULL |
| 596 | on failure. |
Thomas Wouters | dd8dbdb | 2000-08-24 20:09:45 +0000 | [diff] [blame] | 597 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 598 | This is the equivalent of the Python expression: o1 ^= o2. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 599 | PyAPI_FUNC(PyObject *) PyNumber_InPlaceXor(PyObject *o1, PyObject *o2); |
Thomas Wouters | dd8dbdb | 2000-08-24 20:09:45 +0000 | [diff] [blame] | 600 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 601 | /* Returns the result of bitwise or of o1 and o2, possibly in-place, |
| 602 | or NULL on failure. |
Thomas Wouters | dd8dbdb | 2000-08-24 20:09:45 +0000 | [diff] [blame] | 603 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 604 | This is the equivalent of the Python expression: o1 |= o2. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 605 | PyAPI_FUNC(PyObject *) PyNumber_InPlaceOr(PyObject *o1, PyObject *o2); |
Thomas Wouters | dd8dbdb | 2000-08-24 20:09:45 +0000 | [diff] [blame] | 606 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 607 | /* Returns the integer n converted to a string with a base, with a base |
| 608 | marker of 0b, 0o or 0x prefixed if applicable. |
Thomas Wouters | dd8dbdb | 2000-08-24 20:09:45 +0000 | [diff] [blame] | 609 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 610 | If n is not an int object, it is converted with PyNumber_Index first. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 611 | PyAPI_FUNC(PyObject *) PyNumber_ToBase(PyObject *n, int base); |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 612 | |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 613 | |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 614 | /* === Sequence protocol ================================================ */ |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 615 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 616 | /* Return 1 if the object provides sequence protocol, and zero |
| 617 | otherwise. |
| 618 | |
| 619 | This function always succeeds. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 620 | PyAPI_FUNC(int) PySequence_Check(PyObject *o); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 621 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 622 | /* Return the size of sequence object o, or -1 on failure. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 623 | PyAPI_FUNC(Py_ssize_t) PySequence_Size(PyObject *o); |
Jeremy Hylton | 6253f83 | 2000-07-12 12:56:19 +0000 | [diff] [blame] | 624 | |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 625 | /* For DLL compatibility */ |
Marc-André Lemburg | cf5f358 | 2000-07-17 09:22:55 +0000 | [diff] [blame] | 626 | #undef PySequence_Length |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 627 | PyAPI_FUNC(Py_ssize_t) PySequence_Length(PyObject *o); |
Marc-André Lemburg | cf5f358 | 2000-07-17 09:22:55 +0000 | [diff] [blame] | 628 | #define PySequence_Length PySequence_Size |
| 629 | |
| 630 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 631 | /* Return the concatenation of o1 and o2 on success, and NULL on failure. |
| 632 | |
| 633 | This is the equivalent of the Python expression: o1 + o2. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 634 | PyAPI_FUNC(PyObject *) PySequence_Concat(PyObject *o1, PyObject *o2); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 635 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 636 | /* Return the result of repeating sequence object 'o' 'count' times, |
| 637 | or NULL on failure. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 638 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 639 | This is the equivalent of the Python expression: o * count. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 640 | PyAPI_FUNC(PyObject *) PySequence_Repeat(PyObject *o, Py_ssize_t count); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 641 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 642 | /* Return the ith element of o, or NULL on failure. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 643 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 644 | This is the equivalent of the Python expression: o[i]. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 645 | PyAPI_FUNC(PyObject *) PySequence_GetItem(PyObject *o, Py_ssize_t i); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 646 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 647 | /* Return the slice of sequence object o between i1 and i2, or NULL on failure. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 648 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 649 | This is the equivalent of the Python expression: o[i1:i2]. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 650 | PyAPI_FUNC(PyObject *) PySequence_GetSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 651 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 652 | /* Assign object 'v' to the ith element of the sequence 'o'. Raise an exception |
| 653 | and return -1 on failure; return 0 on success. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 654 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 655 | This is the equivalent of the Python statement o[i] = v. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 656 | PyAPI_FUNC(int) PySequence_SetItem(PyObject *o, Py_ssize_t i, PyObject *v); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 657 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 658 | /* Delete the 'i'-th element of the sequence 'v'. Returns -1 on failure. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 659 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 660 | This is the equivalent of the Python statement: del o[i]. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 661 | PyAPI_FUNC(int) PySequence_DelItem(PyObject *o, Py_ssize_t i); |
Guido van Rossum | 6cdc6f4 | 1996-08-21 17:41:54 +0000 | [diff] [blame] | 662 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 663 | /* Assign the sequence object 'v' to the slice in sequence object 'o', |
| 664 | from 'i1' to 'i2'. Returns -1 on failure. |
Guido van Rossum | 6cdc6f4 | 1996-08-21 17:41:54 +0000 | [diff] [blame] | 665 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 666 | This is the equivalent of the Python statement: o[i1:i2] = v. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 667 | PyAPI_FUNC(int) PySequence_SetSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2, |
| 668 | PyObject *v); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 669 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 670 | /* Delete the slice in sequence object 'o' from 'i1' to 'i2'. |
| 671 | Returns -1 on failure. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 672 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 673 | This is the equivalent of the Python statement: del o[i1:i2]. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 674 | PyAPI_FUNC(int) PySequence_DelSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2); |
Guido van Rossum | 6cdc6f4 | 1996-08-21 17:41:54 +0000 | [diff] [blame] | 675 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 676 | /* Returns the sequence 'o' as a tuple on success, and NULL on failure. |
Guido van Rossum | 6cdc6f4 | 1996-08-21 17:41:54 +0000 | [diff] [blame] | 677 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 678 | This is equivalent to the Python expression: tuple(o). */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 679 | PyAPI_FUNC(PyObject *) PySequence_Tuple(PyObject *o); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 680 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 681 | /* Returns the sequence 'o' as a list on success, and NULL on failure. |
| 682 | This is equivalent to the Python expression: list(o) */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 683 | PyAPI_FUNC(PyObject *) PySequence_List(PyObject *o); |
Guido van Rossum | f39fc43 | 1997-03-04 18:31:47 +0000 | [diff] [blame] | 684 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 685 | /* Return the sequence 'o' as a list, unless it's already a tuple or list. |
| 686 | |
| 687 | Use PySequence_Fast_GET_ITEM to access the members of this list, and |
| 688 | PySequence_Fast_GET_SIZE to get its length. |
| 689 | |
| 690 | Returns NULL on failure. If the object does not support iteration, raises a |
| 691 | TypeError exception with 'm' as the message text. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 692 | PyAPI_FUNC(PyObject *) PySequence_Fast(PyObject *o, const char* m); |
Andrew M. Kuchling | 74042d6 | 2000-06-18 18:43:14 +0000 | [diff] [blame] | 693 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 694 | /* Return the size of the sequence 'o', assuming that 'o' was returned by |
| 695 | PySequence_Fast and is not NULL. */ |
Tim Peters | 1fc240e | 2001-10-26 05:06:50 +0000 | [diff] [blame] | 696 | #define PySequence_Fast_GET_SIZE(o) \ |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 697 | (PyList_Check(o) ? PyList_GET_SIZE(o) : PyTuple_GET_SIZE(o)) |
Tim Peters | 1fc240e | 2001-10-26 05:06:50 +0000 | [diff] [blame] | 698 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 699 | /* Return the 'i'-th element of the sequence 'o', assuming that o was returned |
| 700 | by PySequence_Fast, and that i is within bounds. */ |
Andrew M. Kuchling | 74042d6 | 2000-06-18 18:43:14 +0000 | [diff] [blame] | 701 | #define PySequence_Fast_GET_ITEM(o, i)\ |
| 702 | (PyList_Check(o) ? PyList_GET_ITEM(o, i) : PyTuple_GET_ITEM(o, i)) |
Andrew M. Kuchling | 74042d6 | 2000-06-18 18:43:14 +0000 | [diff] [blame] | 703 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 704 | /* Return a pointer to the underlying item array for |
Min ho Kim | c4cacc8 | 2019-07-31 08:16:13 +1000 | [diff] [blame] | 705 | an object returned by PySequence_Fast */ |
Raymond Hettinger | 42bec93 | 2004-03-12 16:38:17 +0000 | [diff] [blame] | 706 | #define PySequence_Fast_ITEMS(sf) \ |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 707 | (PyList_Check(sf) ? ((PyListObject *)(sf))->ob_item \ |
| 708 | : ((PyTupleObject *)(sf))->ob_item) |
Raymond Hettinger | c1e4f9d | 2004-03-12 08:04:00 +0000 | [diff] [blame] | 709 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 710 | /* Return the number of occurrences on value on 'o', that is, return |
| 711 | the number of keys for which o[key] == value. |
| 712 | |
| 713 | On failure, return -1. This is equivalent to the Python expression: |
| 714 | o.count(value). */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 715 | PyAPI_FUNC(Py_ssize_t) PySequence_Count(PyObject *o, PyObject *value); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 716 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 717 | /* Return 1 if 'ob' is in the sequence 'seq'; 0 if 'ob' is not in the sequence |
| 718 | 'seq'; -1 on error. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 719 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 720 | Use __contains__ if possible, else _PySequence_IterSearch(). */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 721 | PyAPI_FUNC(int) PySequence_Contains(PyObject *seq, PyObject *ob); |
Tim Peters | cb8d368 | 2001-05-05 21:05:01 +0000 | [diff] [blame] | 722 | |
Guido van Rossum | 8368453 | 1999-03-17 18:44:39 +0000 | [diff] [blame] | 723 | /* For DLL-level backwards compatibility */ |
| 724 | #undef PySequence_In |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 725 | /* Determine if the sequence 'o' contains 'value'. If an item in 'o' is equal |
| 726 | to 'value', return 1, otherwise return 0. On error, return -1. |
| 727 | |
| 728 | This is equivalent to the Python expression: value in o. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 729 | PyAPI_FUNC(int) PySequence_In(PyObject *o, PyObject *value); |
Guido van Rossum | 8368453 | 1999-03-17 18:44:39 +0000 | [diff] [blame] | 730 | |
| 731 | /* For source-level backwards compatibility */ |
Guido van Rossum | f1536db | 1998-08-23 22:06:59 +0000 | [diff] [blame] | 732 | #define PySequence_In PySequence_Contains |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 733 | |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 734 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 735 | /* Return the first index for which o[i] == value. |
| 736 | On error, return -1. |
| 737 | |
| 738 | This is equivalent to the Python expression: o.index(value). */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 739 | PyAPI_FUNC(Py_ssize_t) PySequence_Index(PyObject *o, PyObject *value); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 740 | |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 741 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 742 | /* --- In-place versions of some of the above Sequence functions --- */ |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 743 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 744 | /* Append sequence 'o2' to sequence 'o1', in-place when possible. Return the |
| 745 | resulting object, which could be 'o1', or NULL on failure. |
Thomas Wouters | dd8dbdb | 2000-08-24 20:09:45 +0000 | [diff] [blame] | 746 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 747 | This is the equivalent of the Python expression: o1 += o2. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 748 | PyAPI_FUNC(PyObject *) PySequence_InPlaceConcat(PyObject *o1, PyObject *o2); |
Thomas Wouters | dd8dbdb | 2000-08-24 20:09:45 +0000 | [diff] [blame] | 749 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 750 | /* Repeat sequence 'o' by 'count', in-place when possible. Return the resulting |
| 751 | object, which could be 'o', or NULL on failure. |
Thomas Wouters | dd8dbdb | 2000-08-24 20:09:45 +0000 | [diff] [blame] | 752 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 753 | This is the equivalent of the Python expression: o1 *= count. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 754 | PyAPI_FUNC(PyObject *) PySequence_InPlaceRepeat(PyObject *o, Py_ssize_t count); |
Thomas Wouters | dd8dbdb | 2000-08-24 20:09:45 +0000 | [diff] [blame] | 755 | |
Thomas Wouters | dd8dbdb | 2000-08-24 20:09:45 +0000 | [diff] [blame] | 756 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 757 | /* === Mapping protocol ================================================= */ |
Thomas Wouters | dd8dbdb | 2000-08-24 20:09:45 +0000 | [diff] [blame] | 758 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 759 | /* Return 1 if the object provides mapping protocol, and 0 otherwise. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 760 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 761 | This function always succeeds. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 762 | PyAPI_FUNC(int) PyMapping_Check(PyObject *o); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 763 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 764 | /* Returns the number of keys in mapping object 'o' on success, and -1 on |
Serhiy Storchaka | f5b1183 | 2018-05-22 11:02:44 +0300 | [diff] [blame] | 765 | failure. This is equivalent to the Python expression: len(o). */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 766 | PyAPI_FUNC(Py_ssize_t) PyMapping_Size(PyObject *o); |
Jeremy Hylton | 6253f83 | 2000-07-12 12:56:19 +0000 | [diff] [blame] | 767 | |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 768 | /* For DLL compatibility */ |
Marc-André Lemburg | cf5f358 | 2000-07-17 09:22:55 +0000 | [diff] [blame] | 769 | #undef PyMapping_Length |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 770 | PyAPI_FUNC(Py_ssize_t) PyMapping_Length(PyObject *o); |
Marc-André Lemburg | cf5f358 | 2000-07-17 09:22:55 +0000 | [diff] [blame] | 771 | #define PyMapping_Length PyMapping_Size |
| 772 | |
| 773 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 774 | /* Implemented as a macro: |
Guido van Rossum | a25e5e9 | 1996-09-06 13:48:38 +0000 | [diff] [blame] | 775 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 776 | int PyMapping_DelItemString(PyObject *o, const char *key); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 777 | |
Serhiy Storchaka | f5b1183 | 2018-05-22 11:02:44 +0300 | [diff] [blame] | 778 | Remove the mapping for the string 'key' from the mapping 'o'. Returns -1 on |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 779 | failure. |
| 780 | |
| 781 | This is equivalent to the Python statement: del o[key]. */ |
Jeremy Hylton | 7c7ee5f | 2001-11-28 16:20:07 +0000 | [diff] [blame] | 782 | #define PyMapping_DelItemString(O,K) PyObject_DelItemString((O),(K)) |
Guido van Rossum | a25e5e9 | 1996-09-06 13:48:38 +0000 | [diff] [blame] | 783 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 784 | /* Implemented as a macro: |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 785 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 786 | int PyMapping_DelItem(PyObject *o, PyObject *key); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 787 | |
Serhiy Storchaka | f5b1183 | 2018-05-22 11:02:44 +0300 | [diff] [blame] | 788 | Remove the mapping for the object 'key' from the mapping object 'o'. |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 789 | Returns -1 on failure. |
| 790 | |
| 791 | This is equivalent to the Python statement: del o[key]. */ |
Jeremy Hylton | 7c7ee5f | 2001-11-28 16:20:07 +0000 | [diff] [blame] | 792 | #define PyMapping_DelItem(O,K) PyObject_DelItem((O),(K)) |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 793 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 794 | /* On success, return 1 if the mapping object 'o' has the key 'key', |
| 795 | and 0 otherwise. |
| 796 | |
| 797 | This is equivalent to the Python expression: key in o. |
| 798 | |
| 799 | This function always succeeds. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 800 | PyAPI_FUNC(int) PyMapping_HasKeyString(PyObject *o, const char *key); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 801 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 802 | /* Return 1 if the mapping object has the key 'key', and 0 otherwise. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 803 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 804 | This is equivalent to the Python expression: key in o. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 805 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 806 | This function always succeeds. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 807 | PyAPI_FUNC(int) PyMapping_HasKey(PyObject *o, PyObject *key); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 808 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 809 | /* On success, return a list or tuple of the keys in mapping object 'o'. |
| 810 | On failure, return NULL. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 811 | PyAPI_FUNC(PyObject *) PyMapping_Keys(PyObject *o); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 812 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 813 | /* On success, return a list or tuple of the values in mapping object 'o'. |
| 814 | On failure, return NULL. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 815 | PyAPI_FUNC(PyObject *) PyMapping_Values(PyObject *o); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 816 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 817 | /* On success, return a list or tuple of the items in mapping object 'o', |
| 818 | where each item is a tuple containing a key-value pair. On failure, return |
| 819 | NULL. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 820 | PyAPI_FUNC(PyObject *) PyMapping_Items(PyObject *o); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 821 | |
Serhiy Storchaka | f5b1183 | 2018-05-22 11:02:44 +0300 | [diff] [blame] | 822 | /* Return element of 'o' corresponding to the string 'key' or NULL on failure. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 823 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 824 | This is the equivalent of the Python expression: o[key]. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 825 | PyAPI_FUNC(PyObject *) PyMapping_GetItemString(PyObject *o, |
| 826 | const char *key); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 827 | |
Serhiy Storchaka | f5b1183 | 2018-05-22 11:02:44 +0300 | [diff] [blame] | 828 | /* Map the string 'key' to the value 'v' in the mapping 'o'. |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 829 | Returns -1 on failure. |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 830 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 831 | This is the equivalent of the Python statement: o[key]=v. */ |
Victor Stinner | 2a358f8 | 2016-12-06 16:55:39 +0100 | [diff] [blame] | 832 | PyAPI_FUNC(int) PyMapping_SetItemString(PyObject *o, const char *key, |
| 833 | PyObject *value); |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 834 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 835 | /* isinstance(object, typeorclass) */ |
Mark Hammond | 91a681d | 2002-08-12 07:21:58 +0000 | [diff] [blame] | 836 | PyAPI_FUNC(int) PyObject_IsInstance(PyObject *object, PyObject *typeorclass); |
Guido van Rossum | 823649d | 2001-03-21 18:40:58 +0000 | [diff] [blame] | 837 | |
Victor Stinner | 5bef7cd | 2016-12-15 09:14:25 +0100 | [diff] [blame] | 838 | /* issubclass(object, typeorclass) */ |
Mark Hammond | 91a681d | 2002-08-12 07:21:58 +0000 | [diff] [blame] | 839 | PyAPI_FUNC(int) PyObject_IsSubclass(PyObject *object, PyObject *typeorclass); |
Guido van Rossum | 823649d | 2001-03-21 18:40:58 +0000 | [diff] [blame] | 840 | |
Martin v. Löwis | 4d0d471 | 2010-12-03 20:14:31 +0000 | [diff] [blame] | 841 | #ifndef Py_LIMITED_API |
Victor Stinner | 4060283 | 2018-11-26 22:42:04 +0100 | [diff] [blame] | 842 | # define Py_CPYTHON_ABSTRACTOBJECT_H |
| 843 | # include "cpython/abstract.h" |
| 844 | # undef Py_CPYTHON_ABSTRACTOBJECT_H |
| 845 | #endif |
Antoine Pitrou | f68c2a7 | 2010-09-01 12:58:21 +0000 | [diff] [blame] | 846 | |
Guido van Rossum | 8ca687a | 1995-09-18 21:20:02 +0000 | [diff] [blame] | 847 | #ifdef __cplusplus |
| 848 | } |
| 849 | #endif |
Guido van Rossum | a827537 | 1995-07-18 14:07:00 +0000 | [diff] [blame] | 850 | #endif /* Py_ABSTRACTOBJECT_H */ |