third_party/cython/src/Cython/Utility/CythonFunction.c

   1
   2
   3 //////////////////// CythonFunction.proto ////////////////////
   4 #define __Pyx_CyFunction_USED 1
   5 #include <structmember.h>
   6
   7 #define __Pyx_CYFUNCTION_STATICMETHOD  0x01
   8 #define __Pyx_CYFUNCTION_CLASSMETHOD   0x02
   9 #define __Pyx_CYFUNCTION_CCLASS        0x04
  10
  11 #define __Pyx_CyFunction_GetClosure(f) \
  12     (((__pyx_CyFunctionObject *) (f))->func_closure)
  13 #define __Pyx_CyFunction_GetClassObj(f) \
  14     (((__pyx_CyFunctionObject *) (f))->func_classobj)
  15
  16 #define __Pyx_CyFunction_Defaults(type, f) \
  17     ((type *)(((__pyx_CyFunctionObject *) (f))->defaults))
  18 #define __Pyx_CyFunction_SetDefaultsGetter(f, g) \
  19     ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g)
  20
  21
  22 typedef struct {
  23     PyCFunctionObject func;
  24     PyObject *func_dict;
  25     PyObject *func_weakreflist;
  26     PyObject *func_name;
  27     PyObject *func_qualname;
  28     PyObject *func_doc;
  29     PyObject *func_globals;
  30     PyObject *func_code;
  31     PyObject *func_closure;
  32     PyObject *func_classobj; /* No-args super() class cell */
  33
  34     /* Dynamic default args and annotations */
  35     void *defaults;
  36     int defaults_pyobjects;
  37     int flags;
  38
  39     /* Defaults info */
  40     PyObject *defaults_tuple;   /* Const defaults tuple */
  41     PyObject *defaults_kwdict;  /* Const kwonly defaults dict */
  42     PyObject *(*defaults_getter)(PyObject *);
  43     PyObject *func_annotations; /* function annotations dict */
  44 } __pyx_CyFunctionObject;
  45
  46 static PyTypeObject *__pyx_CyFunctionType = 0;
  47
  48 #define __Pyx_CyFunction_NewEx(ml, flags, qualname, self, module, globals, code) \
  49     __Pyx_CyFunction_New(__pyx_CyFunctionType, ml, flags, qualname, self, module, globals, code)
  50
  51 static PyObject *__Pyx_CyFunction_New(PyTypeObject *, PyMethodDef *ml,
  52                                       int flags, PyObject* qualname,
  53                                       PyObject *self,
  54                                       PyObject *module, PyObject *globals,
  55                                       PyObject* code);
  56
  57 static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m,
  58                                                          size_t size,
  59                                                          int pyobjects);
  60 static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m,
  61                                                             PyObject *tuple);
  62 static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m,
  63                                                              PyObject *dict);
  64 static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m,
  65                                                               PyObject *dict);
  66
  67
  68 static int __Pyx_CyFunction_init(void);
  69
  70 //////////////////// CythonFunction ////////////////////
  71 //@substitute: naming
  72 //@requires: CommonTypes.c::FetchCommonType
  73 ////@requires: ObjectHandling.c::PyObjectGetAttrStr
  74
  75 static PyObject *
  76 __Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *closure)
  77 {
  78     if (unlikely(op->func_doc == NULL)) {
  79         if (op->func.m_ml->ml_doc) {
  80 #if PY_MAJOR_VERSION >= 3
  81             op->func_doc = PyUnicode_FromString(op->func.m_ml->ml_doc);
  82 #else
  83             op->func_doc = PyString_FromString(op->func.m_ml->ml_doc);
  84 #endif
  85             if (unlikely(op->func_doc == NULL))
  86                 return NULL;
  87         } else {
  88             Py_INCREF(Py_None);
  89             return Py_None;
  90         }
  91     }
  92     Py_INCREF(op->func_doc);
  93     return op->func_doc;
  94 }
  95
  96 static int
  97 __Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value)
  98 {
  99     PyObject *tmp = op->func_doc;
 100     if (value == NULL)
 101         value = Py_None; /* Mark as deleted */
 102     Py_INCREF(value);
 103     op->func_doc = value;
 104     Py_XDECREF(tmp);
 105     return 0;
 106 }
 107
 108 static PyObject *
 109 __Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op)
 110 {
 111     if (unlikely(op->func_name == NULL)) {
 112 #if PY_MAJOR_VERSION >= 3
 113         op->func_name = PyUnicode_InternFromString(op->func.m_ml->ml_name);
 114 #else
 115         op->func_name = PyString_InternFromString(op->func.m_ml->ml_name);
 116 #endif
 117         if (unlikely(op->func_name == NULL))
 118             return NULL;
 119     }
 120     Py_INCREF(op->func_name);
 121     return op->func_name;
 122 }
 123
 124 static int
 125 __Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value)
 126 {
 127     PyObject *tmp;
 128
 129 #if PY_MAJOR_VERSION >= 3
 130     if (unlikely(value == NULL || !PyUnicode_Check(value))) {
 131 #else
 132     if (unlikely(value == NULL || !PyString_Check(value))) {
 133 #endif
 134         PyErr_SetString(PyExc_TypeError,
 135                         "__name__ must be set to a string object");
 136         return -1;
 137     }
 138     tmp = op->func_name;
 139     Py_INCREF(value);
 140     op->func_name = value;
 141     Py_XDECREF(tmp);
 142     return 0;
 143 }
 144
 145 static PyObject *
 146 __Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op)
 147 {
 148     Py_INCREF(op->func_qualname);
 149     return op->func_qualname;
 150 }
 151
 152 static int
 153 __Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value)
 154 {
 155     PyObject *tmp;
 156
 157 #if PY_MAJOR_VERSION >= 3
 158     if (unlikely(value == NULL || !PyUnicode_Check(value))) {
 159 #else
 160     if (unlikely(value == NULL || !PyString_Check(value))) {
 161 #endif
 162         PyErr_SetString(PyExc_TypeError,
 163                         "__qualname__ must be set to a string object");
 164         return -1;
 165     }
 166     tmp = op->func_qualname;
 167     Py_INCREF(value);
 168     op->func_qualname = value;
 169     Py_XDECREF(tmp);
 170     return 0;
 171 }
 172
 173 static PyObject *
 174 __Pyx_CyFunction_get_self(__pyx_CyFunctionObject *m, CYTHON_UNUSED void *closure)
 175 {
 176     PyObject *self;
 177
 178     self = m->func_closure;
 179     if (self == NULL)
 180         self = Py_None;
 181     Py_INCREF(self);
 182     return self;
 183 }
 184
 185 static PyObject *
 186 __Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op)
 187 {
 188     if (unlikely(op->func_dict == NULL)) {
 189         op->func_dict = PyDict_New();
 190         if (unlikely(op->func_dict == NULL))
 191             return NULL;
 192     }
 193     Py_INCREF(op->func_dict);
 194     return op->func_dict;
 195 }
 196
 197 static int
 198 __Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value)
 199 {
 200     PyObject *tmp;
 201
 202     if (unlikely(value == NULL)) {
 203         PyErr_SetString(PyExc_TypeError,
 204                "function's dictionary may not be deleted");
 205         return -1;
 206     }
 207     if (unlikely(!PyDict_Check(value))) {
 208         PyErr_SetString(PyExc_TypeError,
 209                "setting function's dictionary to a non-dict");
 210         return -1;
 211     }
 212     tmp = op->func_dict;
 213     Py_INCREF(value);
 214     op->func_dict = value;
 215     Py_XDECREF(tmp);
 216     return 0;
 217 }
 218
 219 static PyObject *
 220 __Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op)
 221 {
 222     Py_INCREF(op->func_globals);
 223     return op->func_globals;
 224 }
 225
 226 static PyObject *
 227 __Pyx_CyFunction_get_closure(CYTHON_UNUSED __pyx_CyFunctionObject *op)
 228 {
 229     Py_INCREF(Py_None);
 230     return Py_None;
 231 }
 232
 233 static PyObject *
 234 __Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op)
 235 {
 236     PyObject* result = (op->func_code) ? op->func_code : Py_None;
 237     Py_INCREF(result);
 238     return result;
 239 }
 240
 241 static int
 242 __Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) {
 243     PyObject *res = op->defaults_getter((PyObject *) op);
 244     if (unlikely(!res))
 245         return -1;
 246
 247     /* Cache result */
 248     op->defaults_tuple = PyTuple_GET_ITEM(res, 0);
 249     Py_INCREF(op->defaults_tuple);
 250     op->defaults_kwdict = PyTuple_GET_ITEM(res, 1);
 251     Py_INCREF(op->defaults_kwdict);
 252     Py_DECREF(res);
 253     return 0;
 254 }
 255
 256 static int
 257 __Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value) {
 258     PyObject* tmp;
 259     if (!value) {
 260         // del => explicit None to prevent rebuilding
 261         value = Py_None;
 262     } else if (value != Py_None && !PyTuple_Check(value)) {
 263         PyErr_SetString(PyExc_TypeError,
 264                         "__defaults__ must be set to a tuple object");
 265         return -1;
 266     }
 267     Py_INCREF(value);
 268     tmp = op->defaults_tuple;
 269     op->defaults_tuple = value;
 270     Py_XDECREF(tmp);
 271     return 0;
 272 }
 273
 274 static PyObject *
 275 __Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op) {
 276     PyObject* result = op->defaults_tuple;
 277     if (unlikely(!result)) {
 278         if (op->defaults_getter) {
 279             if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL;
 280             result = op->defaults_tuple;
 281         } else {
 282             result = Py_None;
 283         }
 284     }
 285     Py_INCREF(result);
 286     return result;
 287 }
 288
 289 static int
 290 __Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value) {
 291     PyObject* tmp;
 292     if (!value) {
 293         // del => explicit None to prevent rebuilding
 294         value = Py_None;
 295     } else if (value != Py_None && !PyDict_Check(value)) {
 296         PyErr_SetString(PyExc_TypeError,
 297                         "__kwdefaults__ must be set to a dict object");
 298         return -1;
 299     }
 300     Py_INCREF(value);
 301     tmp = op->defaults_kwdict;
 302     op->defaults_kwdict = value;
 303     Py_XDECREF(tmp);
 304     return 0;
 305 }
 306
 307 static PyObject *
 308 __Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op) {
 309     PyObject* result = op->defaults_kwdict;
 310     if (unlikely(!result)) {
 311         if (op->defaults_getter) {
 312             if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL;
 313             result = op->defaults_kwdict;
 314         } else {
 315             result = Py_None;
 316         }
 317     }
 318     Py_INCREF(result);
 319     return result;
 320 }
 321
 322 static int
 323 __Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value) {
 324     PyObject* tmp;
 325     if (!value || value == Py_None) {
 326         value = NULL;
 327     } else if (!PyDict_Check(value)) {
 328         PyErr_SetString(PyExc_TypeError,
 329                         "__annotations__ must be set to a dict object");
 330         return -1;
 331     }
 332     Py_XINCREF(value);
 333     tmp = op->func_annotations;
 334     op->func_annotations = value;
 335     Py_XDECREF(tmp);
 336     return 0;
 337 }
 338
 339 static PyObject *
 340 __Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op) {
 341     PyObject* result = op->func_annotations;
 342     if (unlikely(!result)) {
 343         result = PyDict_New();
 344         if (unlikely(!result)) return NULL;
 345         op->func_annotations = result;
 346     }
 347     Py_INCREF(result);
 348     return result;
 349 }
 350
 351 //#if PY_VERSION_HEX >= 0x030400C1
 352 //static PyObject *
 353 //__Pyx_CyFunction_get_signature(__pyx_CyFunctionObject *op) {
 354 //    PyObject *inspect_module, *signature_class, *signature;
 355 //    // from inspect import Signature
 356 //    inspect_module = PyImport_ImportModuleLevelObject(PYIDENT("inspect"), NULL, NULL, NULL, 0);
 357 //    if (unlikely(!inspect_module))
 358 //        goto bad;
 359 //    signature_class = __Pyx_PyObject_GetAttrStr(inspect_module, PYIDENT("Signature"));
 360 //    Py_DECREF(inspect_module);
 361 //    if (unlikely(!signature_class))
 362 //        goto bad;
 363 //    // return Signature.from_function(op)
 364 //    signature = PyObject_CallMethodObjArgs(signature_class, PYIDENT("from_function"), op, NULL);
 365 //    Py_DECREF(signature_class);
 366 //    if (likely(signature))
 367 //        return signature;
 368 //bad:
 369 //    // make sure we raise an AttributeError from this property on any errors
 370 //    if (!PyErr_ExceptionMatches(PyExc_AttributeError))
 371 //        PyErr_SetString(PyExc_AttributeError, "failed to calculate __signature__");
 372 //    return NULL;
 373 //}
 374 //#endif
 375
 376 static PyGetSetDef __pyx_CyFunction_getsets[] = {
 377     {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
 378     {(char *) "__doc__",  (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
 379     {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
 380     {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
 381     {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0},
 382     {(char *) "__self__", (getter)__Pyx_CyFunction_get_self, 0, 0, 0},
 383     {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
 384     {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
 385     {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
 386     {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
 387     {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
 388     {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
 389     {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
 390     {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
 391     {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
 392     {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
 393     {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0},
 394     {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0},
 395 //#if PY_VERSION_HEX >= 0x030400C1
 396 //    {(char *) "__signature__", (getter)__Pyx_CyFunction_get_signature, 0, 0, 0},
 397 //#endif
 398     {0, 0, 0, 0, 0}
 399 };
 400
 401 #ifndef PY_WRITE_RESTRICTED /* < Py2.5 */
 402 #define PY_WRITE_RESTRICTED WRITE_RESTRICTED
 403 #endif
 404
 405 static PyMemberDef __pyx_CyFunction_members[] = {
 406     {(char *) "__module__", T_OBJECT, offsetof(__pyx_CyFunctionObject, func.m_module), PY_WRITE_RESTRICTED, 0},
 407     {0, 0, 0,  0, 0}
 408 };
 409
 410 static PyObject *
 411 __Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, CYTHON_UNUSED PyObject *args)
 412 {
 413 #if PY_MAJOR_VERSION >= 3
 414     return PyUnicode_FromString(m->func.m_ml->ml_name);
 415 #else
 416     return PyString_FromString(m->func.m_ml->ml_name);
 417 #endif
 418 }
 419
 420 static PyMethodDef __pyx_CyFunction_methods[] = {
 421     {__Pyx_NAMESTR("__reduce__"), (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0},
 422     {0, 0, 0, 0}
 423 };
 424
 425
 426 static PyObject *__Pyx_CyFunction_New(PyTypeObject *type, PyMethodDef *ml, int flags, PyObject* qualname,
 427                                       PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
 428     __pyx_CyFunctionObject *op = PyObject_GC_New(__pyx_CyFunctionObject, type);
 429     if (op == NULL)
 430         return NULL;
 431     op->flags = flags;
 432     op->func_weakreflist = NULL;
 433     op->func.m_ml = ml;
 434     op->func.m_self = (PyObject *) op;
 435     Py_XINCREF(closure);
 436     op->func_closure = closure;
 437     Py_XINCREF(module);
 438     op->func.m_module = module;
 439     op->func_dict = NULL;
 440     op->func_name = NULL;
 441     Py_INCREF(qualname);
 442     op->func_qualname = qualname;
 443     op->func_doc = NULL;
 444     op->func_classobj = NULL;
 445     op->func_globals = globals;
 446     Py_INCREF(op->func_globals);
 447     Py_XINCREF(code);
 448     op->func_code = code;
 449     /* Dynamic Default args */
 450     op->defaults_pyobjects = 0;
 451     op->defaults = NULL;
 452     op->defaults_tuple = NULL;
 453     op->defaults_kwdict = NULL;
 454     op->defaults_getter = NULL;
 455     op->func_annotations = NULL;
 456     PyObject_GC_Track(op);
 457     return (PyObject *) op;
 458 }
 459
 460 static int
 461 __Pyx_CyFunction_clear(__pyx_CyFunctionObject *m)
 462 {
 463     Py_CLEAR(m->func_closure);
 464     Py_CLEAR(m->func.m_module);
 465     Py_CLEAR(m->func_dict);
 466     Py_CLEAR(m->func_name);
 467     Py_CLEAR(m->func_qualname);
 468     Py_CLEAR(m->func_doc);
 469     Py_CLEAR(m->func_globals);
 470     Py_CLEAR(m->func_code);
 471     Py_CLEAR(m->func_classobj);
 472     Py_CLEAR(m->defaults_tuple);
 473     Py_CLEAR(m->defaults_kwdict);
 474     Py_CLEAR(m->func_annotations);
 475
 476     if (m->defaults) {
 477         PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
 478         int i;
 479
 480         for (i = 0; i < m->defaults_pyobjects; i++)
 481             Py_XDECREF(pydefaults[i]);
 482
 483         PyMem_Free(m->defaults);
 484         m->defaults = NULL;
 485     }
 486
 487     return 0;
 488 }
 489
 490 static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m)
 491 {
 492     PyObject_GC_UnTrack(m);
 493     if (m->func_weakreflist != NULL)
 494         PyObject_ClearWeakRefs((PyObject *) m);
 495     __Pyx_CyFunction_clear(m);
 496     PyObject_GC_Del(m);
 497 }
 498
 499 static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg)
 500 {
 501     Py_VISIT(m->func_closure);
 502     Py_VISIT(m->func.m_module);
 503     Py_VISIT(m->func_dict);
 504     Py_VISIT(m->func_name);
 505     Py_VISIT(m->func_qualname);
 506     Py_VISIT(m->func_doc);
 507     Py_VISIT(m->func_globals);
 508     Py_VISIT(m->func_code);
 509     Py_VISIT(m->func_classobj);
 510     Py_VISIT(m->defaults_tuple);
 511     Py_VISIT(m->defaults_kwdict);
 512
 513     if (m->defaults) {
 514         PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
 515         int i;
 516
 517         for (i = 0; i < m->defaults_pyobjects; i++)
 518             Py_VISIT(pydefaults[i]);
 519     }
 520
 521     return 0;
 522 }
 523
 524 static PyObject *__Pyx_CyFunction_descr_get(PyObject *func, PyObject *obj, PyObject *type)
 525 {
 526     __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
 527
 528     if (m->flags & __Pyx_CYFUNCTION_STATICMETHOD) {
 529         Py_INCREF(func);
 530         return func;
 531     }
 532
 533     if (m->flags & __Pyx_CYFUNCTION_CLASSMETHOD) {
 534         if (type == NULL)
 535             type = (PyObject *)(Py_TYPE(obj));
 536         return PyMethod_New(func,
 537                             type, (PyObject *)(Py_TYPE(type)));
 538     }
 539
 540     if (obj == Py_None)
 541         obj = NULL;
 542     return PyMethod_New(func, obj, type);
 543 }
 544
 545 static PyObject*
 546 __Pyx_CyFunction_repr(__pyx_CyFunctionObject *op)
 547 {
 548 #if PY_MAJOR_VERSION >= 3
 549     return PyUnicode_FromFormat("<cyfunction %U at %p>",
 550                                 op->func_qualname, (void *)op);
 551 #else
 552     return PyString_FromFormat("<cyfunction %s at %p>",
 553                                PyString_AsString(op->func_qualname), (void *)op);
 554 #endif
 555 }
 556
 557 #if CYTHON_COMPILING_IN_PYPY
 558 /* originally copied from PyCFunction_Call() in CPython's Objects/methodobject.c */
 559 /* PyPy does not have this function */
 560 static PyObject * __Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) {
 561     PyCFunctionObject* f = (PyCFunctionObject*)func;
 562     PyCFunction meth = PyCFunction_GET_FUNCTION(func);
 563     PyObject *self = PyCFunction_GET_SELF(func);
 564     Py_ssize_t size;
 565
 566     switch (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST)) {
 567     case METH_VARARGS:
 568         if (likely(kw == NULL) || PyDict_Size(kw) == 0)
 569             return (*meth)(self, arg);
 570         break;
 571     case METH_VARARGS | METH_KEYWORDS:
 572         return (*(PyCFunctionWithKeywords)meth)(self, arg, kw);
 573     case METH_NOARGS:
 574         if (likely(kw == NULL) || PyDict_Size(kw) == 0) {
 575             size = PyTuple_GET_SIZE(arg);
 576             if (size == 0)
 577                 return (*meth)(self, NULL);
 578             PyErr_Format(PyExc_TypeError,
 579                 "%.200s() takes no arguments (%zd given)",
 580                 f->m_ml->ml_name, size);
 581             return NULL;
 582         }
 583         break;
 584     case METH_O:
 585         if (likely(kw == NULL) || PyDict_Size(kw) == 0) {
 586             size = PyTuple_GET_SIZE(arg);
 587             if (size == 1)
 588                 return (*meth)(self, PyTuple_GET_ITEM(arg, 0));
 589             PyErr_Format(PyExc_TypeError,
 590                 "%.200s() takes exactly one argument (%zd given)",
 591                 f->m_ml->ml_name, size);
 592             return NULL;
 593         }
 594         break;
 595     default:
 596         PyErr_SetString(PyExc_SystemError, "Bad call flags in "
 597                         "__Pyx_CyFunction_Call. METH_OLDARGS is no "
 598                         "longer supported!");
 599
 600         return NULL;
 601     }
 602     PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
 603                  f->m_ml->ml_name);
 604     return NULL;
 605 }
 606 #else
 607 static PyObject * __Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) {
 608         return PyCFunction_Call(func, arg, kw);
 609 }
 610 #endif
 611
 612 static PyTypeObject __pyx_CyFunctionType_type = {
 613     PyVarObject_HEAD_INIT(0, 0)
 614     __Pyx_NAMESTR("cython_function_or_method"), /*tp_name*/
 615     sizeof(__pyx_CyFunctionObject),   /*tp_basicsize*/
 616     0,                                  /*tp_itemsize*/
 617     (destructor) __Pyx_CyFunction_dealloc, /*tp_dealloc*/
 618     0,                                  /*tp_print*/
 619     0,                                  /*tp_getattr*/
 620     0,                                  /*tp_setattr*/
 621 #if PY_MAJOR_VERSION < 3
 622     0,                                  /*tp_compare*/
 623 #else
 624     0,                                  /*reserved*/
 625 #endif
 626     (reprfunc) __Pyx_CyFunction_repr,   /*tp_repr*/
 627     0,                                  /*tp_as_number*/
 628     0,                                  /*tp_as_sequence*/
 629     0,                                  /*tp_as_mapping*/
 630     0,                                  /*tp_hash*/
 631     __Pyx_CyFunction_Call,              /*tp_call*/
 632     0,                                  /*tp_str*/
 633     0,                                  /*tp_getattro*/
 634     0,                                  /*tp_setattro*/
 635     0,                                  /*tp_as_buffer*/
 636     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags*/
 637     0,                                  /*tp_doc*/
 638     (traverseproc) __Pyx_CyFunction_traverse,   /*tp_traverse*/
 639     (inquiry) __Pyx_CyFunction_clear,   /*tp_clear*/
 640     0,                                  /*tp_richcompare*/
 641     offsetof(__pyx_CyFunctionObject, func_weakreflist), /* tp_weaklistoffse */
 642     0,                                  /*tp_iter*/
 643     0,                                  /*tp_iternext*/
 644     __pyx_CyFunction_methods,           /*tp_methods*/
 645     __pyx_CyFunction_members,           /*tp_members*/
 646     __pyx_CyFunction_getsets,           /*tp_getset*/
 647     0,                                  /*tp_base*/
 648     0,                                  /*tp_dict*/
 649     __Pyx_CyFunction_descr_get,         /*tp_descr_get*/
 650     0,                                  /*tp_descr_set*/
 651     offsetof(__pyx_CyFunctionObject, func_dict),/*tp_dictoffset*/
 652     0,                                  /*tp_init*/
 653     0,                                  /*tp_alloc*/
 654     0,                                  /*tp_new*/
 655     0,                                  /*tp_free*/
 656     0,                                  /*tp_is_gc*/
 657     0,                                  /*tp_bases*/
 658     0,                                  /*tp_mro*/
 659     0,                                  /*tp_cache*/
 660     0,                                  /*tp_subclasses*/
 661     0,                                  /*tp_weaklist*/
 662     0,                                  /*tp_del*/
 663 #if PY_VERSION_HEX >= 0x02060000
 664     0,                                  /*tp_version_tag*/
 665 #endif
 666 #if PY_VERSION_HEX >= 0x030400a1
 667     0,                                  /*tp_finalize*/
 668 #endif
 669 };
 670
 671
 672 static int __Pyx_CyFunction_init(void) {
 673 #if !CYTHON_COMPILING_IN_PYPY
 674     // avoid a useless level of call indirection
 675     __pyx_CyFunctionType_type.tp_call = PyCFunction_Call;
 676 #endif
 677     __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type);
 678     if (__pyx_CyFunctionType == NULL) {
 679         return -1;
 680     }
 681     return 0;
 682 }
 683
 684 static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) {
 685     __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
 686
 687     m->defaults = PyMem_Malloc(size);
 688     if (!m->defaults)
 689         return PyErr_NoMemory();
 690     memset(m->defaults, 0, size);
 691     m->defaults_pyobjects = pyobjects;
 692     return m->defaults;
 693 }
 694
 695 static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) {
 696     __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
 697     m->defaults_tuple = tuple;
 698     Py_INCREF(tuple);
 699 }
 700
 701 static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) {
 702     __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
 703     m->defaults_kwdict = dict;
 704     Py_INCREF(dict);
 705 }
 706
 707 static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) {
 708     __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
 709     m->func_annotations = dict;
 710     Py_INCREF(dict);
 711 }
 712
 713 //////////////////// CyFunctionClassCell.proto ////////////////////
 714 static CYTHON_INLINE void __Pyx_CyFunction_InitClassCell(PyObject *cyfunctions,
 715                                                          PyObject *classobj);
 716
 717 //////////////////// CyFunctionClassCell ////////////////////
 718 //@requires: CythonFunction
 719
 720 static CYTHON_INLINE void __Pyx_CyFunction_InitClassCell(PyObject *cyfunctions, PyObject *classobj) {
 721     int i;
 722
 723     for (i = 0; i < PyList_GET_SIZE(cyfunctions); i++) {
 724         __pyx_CyFunctionObject *m =
 725             (__pyx_CyFunctionObject *) PyList_GET_ITEM(cyfunctions, i);
 726         m->func_classobj = classobj;
 727         Py_INCREF(classobj);
 728     }
 729 }
 730
 731 //////////////////// FusedFunction.proto ////////////////////
 732 typedef struct {
 733     __pyx_CyFunctionObject func;
 734     PyObject *__signatures__;
 735     PyObject *type;
 736     PyObject *self;
 737 } __pyx_FusedFunctionObject;
 738
 739 #define __pyx_FusedFunction_NewEx(ml, flags, qualname, self, module, globals, code)         \
 740         __pyx_FusedFunction_New(__pyx_FusedFunctionType, ml, flags, qualname, self, module, globals, code)
 741 static PyObject *__pyx_FusedFunction_New(PyTypeObject *type,
 742                                          PyMethodDef *ml, int flags,
 743                                          PyObject *qualname, PyObject *self,
 744                                          PyObject *module, PyObject *globals,
 745                                          PyObject *code);
 746
 747 static int __pyx_FusedFunction_clear(__pyx_FusedFunctionObject *self);
 748 static PyTypeObject *__pyx_FusedFunctionType = NULL;
 749 static int __pyx_FusedFunction_init(void);
 750
 751 #define __Pyx_FusedFunction_USED
 752
 753 //////////////////// FusedFunction ////////////////////
 754 //@requires: CythonFunction
 755
 756 static PyObject *
 757 __pyx_FusedFunction_New(PyTypeObject *type, PyMethodDef *ml, int flags,
 758                         PyObject *qualname, PyObject *self,
 759                         PyObject *module, PyObject *globals,
 760                         PyObject *code)
 761 {
 762     __pyx_FusedFunctionObject *fusedfunc =
 763         (__pyx_FusedFunctionObject *) __Pyx_CyFunction_New(type, ml, flags, qualname,
 764                                                            self, module, globals, code);
 765     if (!fusedfunc)
 766         return NULL;
 767
 768     fusedfunc->__signatures__ = NULL;
 769     fusedfunc->type = NULL;
 770     fusedfunc->self = NULL;
 771     return (PyObject *) fusedfunc;
 772 }
 773
 774 static void __pyx_FusedFunction_dealloc(__pyx_FusedFunctionObject *self) {
 775     __pyx_FusedFunction_clear(self);
 776     __pyx_FusedFunctionType->tp_free((PyObject *) self);
 777 }
 778
 779 static int
 780 __pyx_FusedFunction_traverse(__pyx_FusedFunctionObject *self,
 781                              visitproc visit,
 782                              void *arg)
 783 {
 784     Py_VISIT(self->self);
 785     Py_VISIT(self->type);
 786     Py_VISIT(self->__signatures__);
 787     return __Pyx_CyFunction_traverse((__pyx_CyFunctionObject *) self, visit, arg);
 788 }
 789
 790 static int
 791 __pyx_FusedFunction_clear(__pyx_FusedFunctionObject *self)
 792 {
 793     Py_CLEAR(self->self);
 794     Py_CLEAR(self->type);
 795     Py_CLEAR(self->__signatures__);
 796     return __Pyx_CyFunction_clear((__pyx_CyFunctionObject *) self);
 797 }
 798
 799
 800 static PyObject *
 801 __pyx_FusedFunction_descr_get(PyObject *self, PyObject *obj, PyObject *type)
 802 {
 803     __pyx_FusedFunctionObject *func, *meth;
 804
 805     func = (__pyx_FusedFunctionObject *) self;
 806
 807     if (func->self || func->func.flags & __Pyx_CYFUNCTION_STATICMETHOD) {
 808         /* Do not allow rebinding and don't do anything for static methods */
 809         Py_INCREF(self);
 810         return self;
 811     }
 812
 813     if (obj == Py_None)
 814         obj = NULL;
 815
 816     meth = (__pyx_FusedFunctionObject *) __pyx_FusedFunction_NewEx(
 817                     ((PyCFunctionObject *) func)->m_ml,
 818                     ((__pyx_CyFunctionObject *) func)->flags,
 819                     ((__pyx_CyFunctionObject *) func)->func_qualname,
 820                     ((__pyx_CyFunctionObject *) func)->func_closure,
 821                     ((PyCFunctionObject *) func)->m_module,
 822                     ((__pyx_CyFunctionObject *) func)->func_globals,
 823                     ((__pyx_CyFunctionObject *) func)->func_code);
 824     if (!meth)
 825         return NULL;
 826
 827     Py_XINCREF(func->func.func_classobj);
 828     meth->func.func_classobj = func->func.func_classobj;
 829
 830     Py_XINCREF(func->__signatures__);
 831     meth->__signatures__ = func->__signatures__;
 832
 833     Py_XINCREF(type);
 834     meth->type = type;
 835
 836     Py_XINCREF(func->func.defaults_tuple);
 837     meth->func.defaults_tuple = func->func.defaults_tuple;
 838
 839     if (func->func.flags & __Pyx_CYFUNCTION_CLASSMETHOD)
 840         obj = type;
 841
 842     Py_XINCREF(obj);
 843     meth->self = obj;
 844
 845     return (PyObject *) meth;
 846 }
 847
 848 static PyObject *
 849 _obj_to_str(PyObject *obj)
 850 {
 851     if (PyType_Check(obj))
 852         return PyObject_GetAttr(obj, PYIDENT("__name__"));
 853     else
 854         return PyObject_Str(obj);
 855 }
 856
 857 static PyObject *
 858 __pyx_FusedFunction_getitem(__pyx_FusedFunctionObject *self, PyObject *idx)
 859 {
 860     PyObject *signature = NULL;
 861     PyObject *unbound_result_func;
 862     PyObject *result_func = NULL;
 863
 864     if (self->__signatures__ == NULL) {
 865         PyErr_SetString(PyExc_TypeError, "Function is not fused");
 866         return NULL;
 867     }
 868
 869     if (PyTuple_Check(idx)) {
 870         PyObject *list = PyList_New(0);
 871         Py_ssize_t n = PyTuple_GET_SIZE(idx);
 872         PyObject *string = NULL;
 873         PyObject *sep = NULL;
 874         int i;
 875
 876         if (!list)
 877             return NULL;
 878
 879         for (i = 0; i < n; i++) {
 880             PyObject *item = PyTuple_GET_ITEM(idx, i);
 881
 882             string = _obj_to_str(item);
 883             if (!string || PyList_Append(list, string) < 0)
 884                 goto __pyx_err;
 885
 886             Py_DECREF(string);
 887         }
 888
 889         sep = PyUnicode_FromString("|");
 890         if (sep)
 891             signature = PyUnicode_Join(sep, list);
 892 __pyx_err:
 893 ;
 894         Py_DECREF(list);
 895         Py_XDECREF(sep);
 896     } else {
 897         signature = _obj_to_str(idx);
 898     }
 899
 900     if (!signature)
 901         return NULL;
 902
 903     unbound_result_func = PyObject_GetItem(self->__signatures__, signature);
 904
 905     if (unbound_result_func) {
 906         if (self->self || self->type) {
 907             __pyx_FusedFunctionObject *unbound = (__pyx_FusedFunctionObject *) unbound_result_func;
 908
 909             /* Todo: move this to InitClassCell */
 910             Py_CLEAR(unbound->func.func_classobj);
 911             Py_XINCREF(self->func.func_classobj);
 912             unbound->func.func_classobj = self->func.func_classobj;
 913
 914             result_func = __pyx_FusedFunction_descr_get(unbound_result_func,
 915                                                         self->self, self->type);
 916         } else {
 917             result_func = unbound_result_func;
 918             Py_INCREF(result_func);
 919         }
 920     }
 921
 922     Py_DECREF(signature);
 923     Py_XDECREF(unbound_result_func);
 924
 925     return result_func;
 926 }
 927
 928 static PyObject *
 929 __pyx_FusedFunction_callfunction(PyObject *func, PyObject *args, PyObject *kw)
 930 {
 931      __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func;
 932     PyObject *result;
 933     int static_specialized = (cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD &&
 934                               !((__pyx_FusedFunctionObject *) func)->__signatures__);
 935
 936     if (cyfunc->flags & __Pyx_CYFUNCTION_CCLASS && !static_specialized) {
 937         Py_ssize_t argc;
 938         PyObject *new_args;
 939         PyObject *self;
 940         PyObject *m_self;
 941
 942         argc = PyTuple_GET_SIZE(args);
 943         new_args = PyTuple_GetSlice(args, 1, argc);
 944
 945         if (!new_args)
 946             return NULL;
 947
 948         self = PyTuple_GetItem(args, 0);
 949
 950         if (!self)
 951             return NULL;
 952
 953         m_self = cyfunc->func.m_self;
 954         cyfunc->func.m_self = self;
 955         result = __Pyx_CyFunction_Call(func, new_args, kw);
 956         cyfunc->func.m_self = m_self;
 957
 958         Py_DECREF(new_args);
 959     } else {
 960         result = __Pyx_CyFunction_Call(func, args, kw);
 961     }
 962
 963     return result;
 964 }
 965
 966 /* Note: the 'self' from method binding is passed in in the args tuple,
 967          whereas PyCFunctionObject's m_self is passed in as the first
 968          argument to the C function. For extension methods we need
 969          to pass 'self' as 'm_self' and not as the first element of the
 970          args tuple.
 971 */
 972 static PyObject *
 973 __pyx_FusedFunction_call(PyObject *func, PyObject *args, PyObject *kw)
 974 {
 975     __pyx_FusedFunctionObject *binding_func = (__pyx_FusedFunctionObject *) func;
 976     Py_ssize_t argc = PyTuple_GET_SIZE(args);
 977     PyObject *new_args = NULL;
 978     __pyx_FusedFunctionObject *new_func = NULL;
 979     PyObject *result = NULL;
 980     PyObject *self = NULL;
 981     int is_staticmethod = binding_func->func.flags & __Pyx_CYFUNCTION_STATICMETHOD;
 982     int is_classmethod = binding_func->func.flags & __Pyx_CYFUNCTION_CLASSMETHOD;
 983
 984     if (binding_func->self) {
 985         /* Bound method call, put 'self' in the args tuple */
 986         Py_ssize_t i;
 987         new_args = PyTuple_New(argc + 1);
 988         if (!new_args)
 989             return NULL;
 990
 991         self = binding_func->self;
 992         Py_INCREF(self);
 993         PyTuple_SET_ITEM(new_args, 0, self);
 994
 995         for (i = 0; i < argc; i++) {
 996             PyObject *item = PyTuple_GET_ITEM(args, i);
 997             Py_INCREF(item);
 998             PyTuple_SET_ITEM(new_args, i + 1, item);
 999         }
1000
1001         args = new_args;
1002     } else if (binding_func->type) {
1003         /* Unbound method call */
1004         if (argc < 1) {
1005             PyErr_SetString(PyExc_TypeError, "Need at least one argument, 0 given.");
1006             return NULL;
1007         }
1008         self = PyTuple_GET_ITEM(args, 0);
1009     }
1010
1011     if (self && !is_classmethod && !is_staticmethod &&
1012             !PyObject_IsInstance(self, binding_func->type)) {
1013         PyErr_Format(PyExc_TypeError,
1014                      "First argument should be of type %.200s, got %.200s.",
1015                      ((PyTypeObject *) binding_func->type)->tp_name,
1016                      self->ob_type->tp_name);
1017         goto __pyx_err;
1018     }
1019
1020     if (binding_func->__signatures__) {
1021         PyObject *tup = PyTuple_Pack(4, binding_func->__signatures__, args,
1022                                         kw == NULL ? Py_None : kw,
1023                                         binding_func->func.defaults_tuple);
1024         if (!tup)
1025             goto __pyx_err;
1026
1027         new_func = (__pyx_FusedFunctionObject *) __pyx_FusedFunction_callfunction(func, tup, NULL);
1028         Py_DECREF(tup);
1029
1030         if (!new_func)
1031             goto __pyx_err;
1032
1033         Py_XINCREF(binding_func->func.func_classobj);
1034         Py_CLEAR(new_func->func.func_classobj);
1035         new_func->func.func_classobj = binding_func->func.func_classobj;
1036
1037         func = (PyObject *) new_func;
1038     }
1039
1040     result = __pyx_FusedFunction_callfunction(func, args, kw);
1041 __pyx_err:
1042     Py_XDECREF(new_args);
1043     Py_XDECREF((PyObject *) new_func);
1044     return result;
1045 }
1046
1047 static PyMemberDef __pyx_FusedFunction_members[] = {
1048     {(char *) "__signatures__",
1049      T_OBJECT,
1050      offsetof(__pyx_FusedFunctionObject, __signatures__),
1051      READONLY,
1052      __Pyx_DOCSTR(0)},
1053     {0, 0, 0, 0, 0},
1054 };
1055
1056 static PyMappingMethods __pyx_FusedFunction_mapping_methods = {
1057     0,
1058     (binaryfunc) __pyx_FusedFunction_getitem,
1059     0,
1060 };
1061
1062 static PyTypeObject __pyx_FusedFunctionType_type = {
1063     PyVarObject_HEAD_INIT(0, 0)
1064     __Pyx_NAMESTR("fused_cython_function"), /*tp_name*/
1065     sizeof(__pyx_FusedFunctionObject), /*tp_basicsize*/
1066     0,                                  /*tp_itemsize*/
1067     (destructor) __pyx_FusedFunction_dealloc, /*tp_dealloc*/
1068     0,                                  /*tp_print*/
1069     0,                                  /*tp_getattr*/
1070     0,                                  /*tp_setattr*/
1071 #if PY_MAJOR_VERSION < 3
1072     0,                                  /*tp_compare*/
1073 #else
1074     0,                                  /*reserved*/
1075 #endif
1076     0,                                  /*tp_repr*/
1077     0,                                  /*tp_as_number*/
1078     0,                                  /*tp_as_sequence*/
1079     &__pyx_FusedFunction_mapping_methods, /*tp_as_mapping*/
1080     0,                                  /*tp_hash*/
1081     (ternaryfunc) __pyx_FusedFunction_call, /*tp_call*/
1082     0,                                  /*tp_str*/
1083     0,                                  /*tp_getattro*/
1084     0,                                  /*tp_setattro*/
1085     0,                                  /*tp_as_buffer*/
1086     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, /* tp_flags*/
1087     0,                                  /*tp_doc*/
1088     (traverseproc) __pyx_FusedFunction_traverse,   /*tp_traverse*/
1089     (inquiry) __pyx_FusedFunction_clear,/*tp_clear*/
1090     0,                                  /*tp_richcompare*/
1091     0,                                  /*tp_weaklistoffset*/
1092     0,                                  /*tp_iter*/
1093     0,                                  /*tp_iternext*/
1094     0,                                  /*tp_methods*/
1095     __pyx_FusedFunction_members,        /*tp_members*/
1096     /* __doc__ is None for the fused function type, but we need it to be */
1097     /* a descriptor for the instance's __doc__, so rebuild descriptors in our subclass */
1098     __pyx_CyFunction_getsets,           /*tp_getset*/
1099     &__pyx_CyFunctionType_type,         /*tp_base*/
1100     0,                                  /*tp_dict*/
1101     __pyx_FusedFunction_descr_get,      /*tp_descr_get*/
1102     0,                                  /*tp_descr_set*/
1103     0,                                  /*tp_dictoffset*/
1104     0,                                  /*tp_init*/
1105     0,                                  /*tp_alloc*/
1106     0,                                  /*tp_new*/
1107     0,                                  /*tp_free*/
1108     0,                                  /*tp_is_gc*/
1109     0,                                  /*tp_bases*/
1110     0,                                  /*tp_mro*/
1111     0,                                  /*tp_cache*/
1112     0,                                  /*tp_subclasses*/
1113     0,                                  /*tp_weaklist*/
1114     0,                                  /*tp_del*/
1115 #if PY_VERSION_HEX >= 0x02060000
1116     0,                                  /*tp_version_tag*/
1117 #endif
1118 #if PY_VERSION_HEX >= 0x030400a1
1119     0,                                  /*tp_finalize*/
1120 #endif
1121 };
1122
1123 static int __pyx_FusedFunction_init(void) {
1124     __pyx_FusedFunctionType = __Pyx_FetchCommonType(&__pyx_FusedFunctionType_type);
1125     if (__pyx_FusedFunctionType == NULL) {
1126         return -1;
1127     }
1128     return 0;
1129 }
1130
1131 //////////////////// ClassMethod.proto ////////////////////
1132
1133 #include "descrobject.h"
1134 static PyObject* __Pyx_Method_ClassMethod(PyObject *method); /*proto*/
1135
1136 //////////////////// ClassMethod ////////////////////
1137
1138 static PyObject* __Pyx_Method_ClassMethod(PyObject *method) {
1139 #if CYTHON_COMPILING_IN_PYPY
1140     if (PyObject_TypeCheck(method, &PyWrapperDescr_Type)) { /* cdef classes */
1141         return PyClassMethod_New(method);
1142     }
1143 #else
1144     /* It appears that PyMethodDescr_Type is not anywhere exposed in the Python/C API */
1145     static PyTypeObject *methoddescr_type = NULL;
1146     if (methoddescr_type == NULL) {
1147        PyObject *meth = __Pyx_GetAttrString((PyObject*)&PyList_Type, "append");
1148        if (!meth) return NULL;
1149        methoddescr_type = Py_TYPE(meth);
1150        Py_DECREF(meth);
1151     }
1152     if (PyObject_TypeCheck(method, methoddescr_type)) { /* cdef classes */
1153         PyMethodDescrObject *descr = (PyMethodDescrObject *)method;
1154         #if PY_VERSION_HEX < 0x03020000
1155         PyTypeObject *d_type = descr->d_type;
1156         #else
1157         PyTypeObject *d_type = descr->d_common.d_type;
1158         #endif
1159         return PyDescr_NewClassMethod(d_type, descr->d_method);
1160     }
1161 #endif
1162     else if (PyMethod_Check(method)) { /* python classes */
1163         return PyClassMethod_New(PyMethod_GET_FUNCTION(method));
1164     }
1165     else if (PyCFunction_Check(method)) {
1166         return PyClassMethod_New(method);
1167     }
1168 #ifdef __Pyx_CyFunction_USED
1169     else if (PyObject_TypeCheck(method, __pyx_CyFunctionType)) {
1170         return PyClassMethod_New(method);
1171     }
1172 #endif
1173     PyErr_SetString(PyExc_TypeError,
1174                    "Class-level classmethod() can only be called on "
1175                    "a method_descriptor or instance method.");
1176     return NULL;
1177 }