--- /dev/null
+/*[clinic input]
+preserve
+[clinic start generated code]*/
+
+PyDoc_STRVAR(type___instancecheck____doc__,
+"__instancecheck__($self, instance, /)\n"
+"--\n"
+"\n"
+"Check if an object is an instance.");
+
+#define TYPE___INSTANCECHECK___METHODDEF \
+ {"__instancecheck__", (PyCFunction)type___instancecheck__, METH_O, type___instancecheck____doc__},
+
+static int
+type___instancecheck___impl(PyTypeObject *self, PyObject *instance);
+
+static PyObject *
+type___instancecheck__(PyTypeObject *self, PyObject *instance)
+{
+ PyObject *return_value = NULL;
+ int _return_value;
+
+ _return_value = type___instancecheck___impl(self, instance);
+ if ((_return_value == -1) && PyErr_Occurred()) {
+ goto exit;
+ }
+ return_value = PyBool_FromLong((long)_return_value);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(type___subclasscheck____doc__,
+"__subclasscheck__($self, subclass, /)\n"
+"--\n"
+"\n"
+"Check if a class is a subclass.");
+
+#define TYPE___SUBCLASSCHECK___METHODDEF \
+ {"__subclasscheck__", (PyCFunction)type___subclasscheck__, METH_O, type___subclasscheck____doc__},
+
+static int
+type___subclasscheck___impl(PyTypeObject *self, PyObject *subclass);
+
+static PyObject *
+type___subclasscheck__(PyTypeObject *self, PyObject *subclass)
+{
+ PyObject *return_value = NULL;
+ int _return_value;
+
+ _return_value = type___subclasscheck___impl(self, subclass);
+ if ((_return_value == -1) && PyErr_Occurred()) {
+ goto exit;
+ }
+ return_value = PyBool_FromLong((long)_return_value);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(type_mro__doc__,
+"mro($self, /)\n"
+"--\n"
+"\n"
+"Return a type\'s method resolution order.");
+
+#define TYPE_MRO_METHODDEF \
+ {"mro", (PyCFunction)type_mro, METH_NOARGS, type_mro__doc__},
+
+static PyObject *
+type_mro_impl(PyTypeObject *self);
+
+static PyObject *
+type_mro(PyTypeObject *self, PyObject *Py_UNUSED(ignored))
+{
+ return type_mro_impl(self);
+}
+
+PyDoc_STRVAR(type___subclasses____doc__,
+"__subclasses__($self, /)\n"
+"--\n"
+"\n"
+"Return a list of immediate subclasses.");
+
+#define TYPE___SUBCLASSES___METHODDEF \
+ {"__subclasses__", (PyCFunction)type___subclasses__, METH_NOARGS, type___subclasses____doc__},
+
+static PyObject *
+type___subclasses___impl(PyTypeObject *self);
+
+static PyObject *
+type___subclasses__(PyTypeObject *self, PyObject *Py_UNUSED(ignored))
+{
+ return type___subclasses___impl(self);
+}
+
+PyDoc_STRVAR(type___dir____doc__,
+"__dir__($self, /)\n"
+"--\n"
+"\n"
+"Specialized __dir__ implementation for types.");
+
+#define TYPE___DIR___METHODDEF \
+ {"__dir__", (PyCFunction)type___dir__, METH_NOARGS, type___dir____doc__},
+
+static PyObject *
+type___dir___impl(PyTypeObject *self);
+
+static PyObject *
+type___dir__(PyTypeObject *self, PyObject *Py_UNUSED(ignored))
+{
+ return type___dir___impl(self);
+}
+
+PyDoc_STRVAR(type___sizeof____doc__,
+"__sizeof__($self, /)\n"
+"--\n"
+"\n"
+"Return memory consumption of the type object.");
+
+#define TYPE___SIZEOF___METHODDEF \
+ {"__sizeof__", (PyCFunction)type___sizeof__, METH_NOARGS, type___sizeof____doc__},
+
+static PyObject *
+type___sizeof___impl(PyTypeObject *self);
+
+static PyObject *
+type___sizeof__(PyTypeObject *self, PyObject *Py_UNUSED(ignored))
+{
+ return type___sizeof___impl(self);
+}
+
+PyDoc_STRVAR(object___reduce____doc__,
+"__reduce__($self, protocol=0, /)\n"
+"--\n"
+"\n"
+"Helper for pickle.");
+
+#define OBJECT___REDUCE___METHODDEF \
+ {"__reduce__", (PyCFunction)object___reduce__, METH_FASTCALL, object___reduce____doc__},
+
+static PyObject *
+object___reduce___impl(PyObject *self, int protocol);
+
+static PyObject *
+object___reduce__(PyObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ int protocol = 0;
+
+ if (!_PyArg_ParseStack(args, nargs, "|i:__reduce__",
+ &protocol)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("__reduce__", kwnames)) {
+ goto exit;
+ }
+ return_value = object___reduce___impl(self, protocol);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(object___reduce_ex____doc__,
+"__reduce_ex__($self, protocol=0, /)\n"
+"--\n"
+"\n"
+"Helper for pickle.");
+
+#define OBJECT___REDUCE_EX___METHODDEF \
+ {"__reduce_ex__", (PyCFunction)object___reduce_ex__, METH_FASTCALL, object___reduce_ex____doc__},
+
+static PyObject *
+object___reduce_ex___impl(PyObject *self, int protocol);
+
+static PyObject *
+object___reduce_ex__(PyObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ int protocol = 0;
+
+ if (!_PyArg_ParseStack(args, nargs, "|i:__reduce_ex__",
+ &protocol)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("__reduce_ex__", kwnames)) {
+ goto exit;
+ }
+ return_value = object___reduce_ex___impl(self, protocol);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(object___format____doc__,
+"__format__($self, format_spec, /)\n"
+"--\n"
+"\n"
+"Default object formatter.");
+
+#define OBJECT___FORMAT___METHODDEF \
+ {"__format__", (PyCFunction)object___format__, METH_O, object___format____doc__},
+
+static PyObject *
+object___format___impl(PyObject *self, PyObject *format_spec);
+
+static PyObject *
+object___format__(PyObject *self, PyObject *arg)
+{
+ PyObject *return_value = NULL;
+ PyObject *format_spec;
+
+ if (!PyArg_Parse(arg, "U:__format__", &format_spec)) {
+ goto exit;
+ }
+ return_value = object___format___impl(self, format_spec);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(object___sizeof____doc__,
+"__sizeof__($self, /)\n"
+"--\n"
+"\n"
+"Size of object in memory, in bytes.");
+
+#define OBJECT___SIZEOF___METHODDEF \
+ {"__sizeof__", (PyCFunction)object___sizeof__, METH_NOARGS, object___sizeof____doc__},
+
+static PyObject *
+object___sizeof___impl(PyObject *self);
+
+static PyObject *
+object___sizeof__(PyObject *self, PyObject *Py_UNUSED(ignored))
+{
+ return object___sizeof___impl(self);
+}
+
+PyDoc_STRVAR(object___dir____doc__,
+"__dir__($self, /)\n"
+"--\n"
+"\n"
+"Default dir() implementation.");
+
+#define OBJECT___DIR___METHODDEF \
+ {"__dir__", (PyCFunction)object___dir__, METH_NOARGS, object___dir____doc__},
+
+static PyObject *
+object___dir___impl(PyObject *self);
+
+static PyObject *
+object___dir__(PyObject *self, PyObject *Py_UNUSED(ignored))
+{
+ return object___dir___impl(self);
+}
+/*[clinic end generated code: output=ce354e436e2360a0 input=a9049054013a1b77]*/
#include <ctype.h>
+/*[clinic input]
+class type "PyTypeObject *" "&PyType_Type"
+class object "PyObject *" "&PyBaseObject_Type"
+[clinic start generated code]*/
+/*[clinic end generated code: output=da39a3ee5e6b4b0d input=4b94608d231c434b]*/
+
+#include "clinic/typeobject.c.h"
/* Support type attribute cache */
update_callback callback, void *data);
static int recurse_down_subclasses(PyTypeObject *type, PyObject *name,
update_callback callback, void *data);
-static PyObject *type_subclasses(PyTypeObject *type, PyObject *ignored);
static int
mro_hierarchy(PyTypeObject *type, PyObject *temp)
Finally, this makes things simple avoiding the need to deal
with dictionary iterators and weak references.
*/
- subclasses = type_subclasses(type, NULL);
+ subclasses = type___subclasses___impl(type);
if (subclasses == NULL)
return -1;
n = PyList_GET_SIZE(subclasses);
return _PyDict_SetItemId(type->tp_dict, &PyId___doc__, value);
}
-static PyObject *
-type___instancecheck__(PyObject *type, PyObject *inst)
+/*[clinic input]
+type.__instancecheck__ -> bool
+
+ instance: object
+ /
+
+Check if an object is an instance.
+[clinic start generated code]*/
+
+static int
+type___instancecheck___impl(PyTypeObject *self, PyObject *instance)
+/*[clinic end generated code: output=08b6bf5f591c3618 input=cdbfeaee82c01a0f]*/
{
- switch (_PyObject_RealIsInstance(inst, type)) {
- case -1:
- return NULL;
- case 0:
- Py_RETURN_FALSE;
- default:
- Py_RETURN_TRUE;
- }
+ return _PyObject_RealIsInstance(instance, (PyObject *)self);
}
+/*[clinic input]
+type.__subclasscheck__ -> bool
-static PyObject *
-type___subclasscheck__(PyObject *type, PyObject *inst)
+ subclass: object
+ /
+
+Check if a class is a subclass.
+[clinic start generated code]*/
+
+static int
+type___subclasscheck___impl(PyTypeObject *self, PyObject *subclass)
+/*[clinic end generated code: output=97a4e51694500941 input=071b2ca9e03355f4]*/
{
- switch (_PyObject_RealIsSubclass(inst, type)) {
- case -1:
- return NULL;
- case 0:
- Py_RETURN_FALSE;
- default:
- Py_RETURN_TRUE;
- }
+ return _PyObject_RealIsSubclass(subclass, (PyObject *)self);
}
return result;
}
+/*[clinic input]
+type.mro
+
+Return a type's method resolution order.
+[clinic start generated code]*/
+
static PyObject *
-mro_external(PyObject *self)
+type_mro_impl(PyTypeObject *self)
+/*[clinic end generated code: output=bffc4a39b5b57027 input=28414f4e156db28d]*/
{
- PyTypeObject *type = (PyTypeObject *)self;
-
- return mro_implementation(type);
+ return mro_implementation(self);
}
static int
Py_TYPE(type)->tp_free((PyObject *)type);
}
+/*[clinic input]
+type.__subclasses__
+
+Return a list of immediate subclasses.
+[clinic start generated code]*/
+
static PyObject *
-type_subclasses(PyTypeObject *type, PyObject *args_ignored)
+type___subclasses___impl(PyTypeObject *self)
+/*[clinic end generated code: output=eb5eb54485942819 input=5af66132436f9a7b]*/
{
PyObject *list, *raw, *ref;
Py_ssize_t i;
list = PyList_New(0);
if (list == NULL)
return NULL;
- raw = type->tp_subclasses;
+ raw = self->tp_subclasses;
if (raw == NULL)
return list;
assert(PyDict_CheckExact(raw));
We deliberately don't suck up its __class__, as methods belonging to the
metaclass would probably be more confusing than helpful.
*/
+/*[clinic input]
+type.__dir__
+
+Specialized __dir__ implementation for types.
+[clinic start generated code]*/
+
static PyObject *
-type_dir(PyObject *self, PyObject *args)
+type___dir___impl(PyTypeObject *self)
+/*[clinic end generated code: output=69d02fe92c0f15fa input=7733befbec645968]*/
{
PyObject *result = NULL;
PyObject *dict = PyDict_New();
- if (dict != NULL && merge_class_dict(dict, self) == 0)
+ if (dict != NULL && merge_class_dict(dict, (PyObject *)self) == 0)
result = PyDict_Keys(dict);
Py_XDECREF(dict);
return result;
}
-static PyObject*
-type_sizeof(PyObject *self, PyObject *args_unused)
+/*[clinic input]
+type.__sizeof__
+
+Return memory consumption of the type object.
+[clinic start generated code]*/
+
+static PyObject *
+type___sizeof___impl(PyTypeObject *self)
+/*[clinic end generated code: output=766f4f16cd3b1854 input=99398f24b9cf45d6]*/
{
Py_ssize_t size;
- PyTypeObject *type = (PyTypeObject*)self;
- if (type->tp_flags & Py_TPFLAGS_HEAPTYPE) {
- PyHeapTypeObject* et = (PyHeapTypeObject*)type;
+ if (self->tp_flags & Py_TPFLAGS_HEAPTYPE) {
+ PyHeapTypeObject* et = (PyHeapTypeObject*)self;
size = sizeof(PyHeapTypeObject);
if (et->ht_cached_keys)
size += _PyDict_KeysSize(et->ht_cached_keys);
}
static PyMethodDef type_methods[] = {
- {"mro", (PyCFunction)mro_external, METH_NOARGS,
- PyDoc_STR("mro() -> list\nreturn a type's method resolution order")},
- {"__subclasses__", (PyCFunction)type_subclasses, METH_NOARGS,
- PyDoc_STR("__subclasses__() -> list of immediate subclasses")},
+ TYPE_MRO_METHODDEF
+ TYPE___SUBCLASSES___METHODDEF
{"__prepare__", (PyCFunction)type_prepare,
METH_FASTCALL | METH_CLASS,
PyDoc_STR("__prepare__() -> dict\n"
"used to create the namespace for the class statement")},
- {"__instancecheck__", type___instancecheck__, METH_O,
- PyDoc_STR("__instancecheck__() -> bool\ncheck if an object is an instance")},
- {"__subclasscheck__", type___subclasscheck__, METH_O,
- PyDoc_STR("__subclasscheck__() -> bool\ncheck if a class is a subclass")},
- {"__dir__", type_dir, METH_NOARGS,
- PyDoc_STR("__dir__() -> list\nspecialized __dir__ implementation for types")},
- {"__sizeof__", type_sizeof, METH_NOARGS,
- "__sizeof__() -> int\nreturn memory consumption of the type object"},
+ TYPE___INSTANCECHECK___METHODDEF
+ TYPE___SUBCLASSCHECK___METHODDEF
+ TYPE___DIR___METHODDEF
+ TYPE___SIZEOF___METHODDEF
{0}
};
return res;
}
+/*[clinic input]
+object.__reduce__
+
+ protocol: int = 0
+ /
+
+Helper for pickle.
+[clinic start generated code]*/
+
static PyObject *
-object_reduce(PyObject *self, PyObject *args)
+object___reduce___impl(PyObject *self, int protocol)
+/*[clinic end generated code: output=5572e699c467dd5b input=227f37ed68bd938a]*/
{
- int proto = 0;
+ return _common_reduce(self, protocol);
+}
- if (!PyArg_ParseTuple(args, "|i:__reduce__", &proto))
- return NULL;
+/*[clinic input]
+object.__reduce_ex__
- return _common_reduce(self, proto);
-}
+ protocol: int = 0
+ /
+
+Helper for pickle.
+[clinic start generated code]*/
static PyObject *
-object_reduce_ex(PyObject *self, PyObject *args)
+object___reduce_ex___impl(PyObject *self, int protocol)
+/*[clinic end generated code: output=2e157766f6b50094 input=8dd6a9602a12749e]*/
{
static PyObject *objreduce;
PyObject *reduce, *res;
- int proto = 0;
_Py_IDENTIFIER(__reduce__);
- if (!PyArg_ParseTuple(args, "|i:__reduce_ex__", &proto))
- return NULL;
-
if (objreduce == NULL) {
objreduce = _PyDict_GetItemId(PyBaseObject_Type.tp_dict,
&PyId___reduce__);
Py_DECREF(reduce);
}
- return _common_reduce(self, proto);
+ return _common_reduce(self, protocol);
}
static PyObject *
"The default implementation does nothing. It may be\n"
"overridden to extend subclasses.\n");
+/*[clinic input]
+object.__format__
+
+ format_spec: unicode
+ /
+
+Default object formatter.
+[clinic start generated code]*/
+
static PyObject *
-object_format(PyObject *self, PyObject *args)
+object___format___impl(PyObject *self, PyObject *format_spec)
+/*[clinic end generated code: output=34897efb543a974b input=7c3b3bc53a6fb7fa]*/
{
- PyObject *format_spec;
PyObject *self_as_str = NULL;
PyObject *result = NULL;
- if (!PyArg_ParseTuple(args, "U:__format__", &format_spec))
- return NULL;
-
/* Issue 7994: If we're converting to a string, we
should reject format specifications */
if (PyUnicode_GET_LENGTH(format_spec) > 0) {
return result;
}
+/*[clinic input]
+object.__sizeof__
+
+Size of object in memory, in bytes.
+[clinic start generated code]*/
+
static PyObject *
-object_sizeof(PyObject *self, PyObject *args)
+object___sizeof___impl(PyObject *self)
+/*[clinic end generated code: output=73edab332f97d550 input=1200ff3dfe485306]*/
{
Py_ssize_t res, isize;
/* __dir__ for generic objects: returns __dict__, __class__,
and recursively up the __class__.__bases__ chain.
*/
+/*[clinic input]
+object.__dir__
+
+Default dir() implementation.
+[clinic start generated code]*/
+
static PyObject *
-object_dir(PyObject *self, PyObject *args)
+object___dir___impl(PyObject *self)
+/*[clinic end generated code: output=66dd48ea62f26c90 input=0a89305bec669b10]*/
{
PyObject *result = NULL;
PyObject *dict = NULL;
}
static PyMethodDef object_methods[] = {
- {"__reduce_ex__", object_reduce_ex, METH_VARARGS,
- PyDoc_STR("helper for pickle")},
- {"__reduce__", object_reduce, METH_VARARGS,
- PyDoc_STR("helper for pickle")},
+ OBJECT___REDUCE_EX___METHODDEF
+ OBJECT___REDUCE___METHODDEF
{"__subclasshook__", object_subclasshook, METH_CLASS | METH_VARARGS,
object_subclasshook_doc},
{"__init_subclass__", object_init_subclass, METH_CLASS | METH_NOARGS,
object_init_subclass_doc},
- {"__format__", object_format, METH_VARARGS,
- PyDoc_STR("default object formatter")},
- {"__sizeof__", object_sizeof, METH_NOARGS,
- PyDoc_STR("__sizeof__() -> int\nsize of object in memory, in bytes")},
- {"__dir__", object_dir, METH_NOARGS,
- PyDoc_STR("__dir__() -> list\ndefault dir() implementation")},
+ OBJECT___FORMAT___METHODDEF
+ OBJECT___SIZEOF___METHODDEF
+ OBJECT___DIR___METHODDEF
{0}
};
projects / thirdparty / Python / cpython.git / commitdiff
