Objects/funcobject.c

   1
   2 /* Function object implementation */
   3
   4 #include "Python.h"
   5 #include "code.h"
   6 #include "eval.h"
   7 #include "structmember.h"
   8
   9 PyObject *
  10 PyFunction_New(PyObject *code, PyObject *globals)
  11 {
  12         PyFunctionObject *op = PyObject_GC_New(PyFunctionObject,
  13                                             &PyFunction_Type);
  14         static PyObject *__name__ = 0;
  15         if (op != NULL) {
  16                 PyObject *doc;
  17                 PyObject *consts;
  18                 PyObject *module;
  19                 op->func_weakreflist = NULL;
  20                 Py_INCREF(code);
  21                 op->func_code = code;
  22                 Py_INCREF(globals);
  23                 op->func_globals = globals;
  24                 op->func_name = ((PyCodeObject *)code)->co_name;
  25                 Py_INCREF(op->func_name);
  26                 op->func_defaults = NULL; /* No default arguments */
  27                 op->func_closure = NULL;
  28                 consts = ((PyCodeObject *)code)->co_consts;
  29                 if (PyTuple_Size(consts) >= 1) {
  30                         doc = PyTuple_GetItem(consts, 0);
  31                         if (!PyString_Check(doc) && !PyUnicode_Check(doc))
  32                                 doc = Py_None;
  33                 }
  34                 else
  35                         doc = Py_None;
  36                 Py_INCREF(doc);
  37                 op->func_doc = doc;
  38                 op->func_dict = NULL;
  39                 op->func_module = NULL;
  40
  41                 /* __module__: If module name is in globals, use it.
  42                    Otherwise, use None.
  43                 */
  44                 if (!__name__) {
  45                         __name__ = PyString_InternFromString("__name__");
  46                         if (!__name__) {
  47                                 Py_DECREF(op);
  48                                 return NULL;
  49                         }
  50                 }
  51                 module = PyDict_GetItem(globals, __name__);
  52                 if (module) {
  53                     Py_INCREF(module);
  54                     op->func_module = module;
  55                 }
  56         }
  57         else
  58                 return NULL;
  59         _PyObject_GC_TRACK(op);
  60         return (PyObject *)op;
  61 }
  62
  63 PyObject *
  64 PyFunction_GetCode(PyObject *op)
  65 {
  66         if (!PyFunction_Check(op)) {
  67                 PyErr_BadInternalCall();
  68                 return NULL;
  69         }
  70         return ((PyFunctionObject *) op) -> func_code;
  71 }
  72
  73 PyObject *
  74 PyFunction_GetGlobals(PyObject *op)
  75 {
  76         if (!PyFunction_Check(op)) {
  77                 PyErr_BadInternalCall();
  78                 return NULL;
  79         }
  80         return ((PyFunctionObject *) op) -> func_globals;
  81 }
  82
  83 PyObject *
  84 PyFunction_GetModule(PyObject *op)
  85 {
  86         if (!PyFunction_Check(op)) {
  87                 PyErr_BadInternalCall();
  88                 return NULL;
  89         }
  90         return ((PyFunctionObject *) op) -> func_module;
  91 }
  92
  93 PyObject *
  94 PyFunction_GetDefaults(PyObject *op)
  95 {
  96         if (!PyFunction_Check(op)) {
  97                 PyErr_BadInternalCall();
  98                 return NULL;
  99         }
 100         return ((PyFunctionObject *) op) -> func_defaults;
 101 }
 102
 103 int
 104 PyFunction_SetDefaults(PyObject *op, PyObject *defaults)
 105 {
 106         if (!PyFunction_Check(op)) {
 107                 PyErr_BadInternalCall();
 108                 return -1;
 109         }
 110         if (defaults == Py_None)
 111                 defaults = NULL;
 112         else if (defaults && PyTuple_Check(defaults)) {
 113                 Py_INCREF(defaults);
 114         }
 115         else {
 116                 PyErr_SetString(PyExc_SystemError, "non-tuple default args");
 117                 return -1;
 118         }
 119         Py_XDECREF(((PyFunctionObject *) op) -> func_defaults);
 120         ((PyFunctionObject *) op) -> func_defaults = defaults;
 121         return 0;
 122 }
 123
 124 PyObject *
 125 PyFunction_GetClosure(PyObject *op)
 126 {
 127         if (!PyFunction_Check(op)) {
 128                 PyErr_BadInternalCall();
 129                 return NULL;
 130         }
 131         return ((PyFunctionObject *) op) -> func_closure;
 132 }
 133
 134 int
 135 PyFunction_SetClosure(PyObject *op, PyObject *closure)
 136 {
 137         if (!PyFunction_Check(op)) {
 138                 PyErr_BadInternalCall();
 139                 return -1;
 140         }
 141         if (closure == Py_None)
 142                 closure = NULL;
 143         else if (PyTuple_Check(closure)) {
 144                 Py_INCREF(closure);
 145         }
 146         else {
 147                 PyErr_Format(PyExc_SystemError,
 148                              "expected tuple for closure, got '%.100s'",
 149                              closure->ob_type->tp_name);
 150                 return -1;
 151         }
 152         Py_XDECREF(((PyFunctionObject *) op) -> func_closure);
 153         ((PyFunctionObject *) op) -> func_closure = closure;
 154         return 0;
 155 }
 156
 157 /* Methods */
 158
 159 #define OFF(x) offsetof(PyFunctionObject, x)
 160
 161 static PyMemberDef func_memberlist[] = {
 162         {"func_closure",  T_OBJECT,     OFF(func_closure),
 163          RESTRICTED|READONLY},
 164         {"func_doc",      T_OBJECT,     OFF(func_doc), WRITE_RESTRICTED},
 165         {"__doc__",       T_OBJECT,     OFF(func_doc), WRITE_RESTRICTED},
 166         {"func_globals",  T_OBJECT,     OFF(func_globals),
 167          RESTRICTED|READONLY},
 168         {"__module__",    T_OBJECT,     OFF(func_module), WRITE_RESTRICTED},
 169         {NULL}  /* Sentinel */
 170 };
 171
 172 static int
 173 restricted(void)
 174 {
 175         if (!PyEval_GetRestricted())
 176                 return 0;
 177         PyErr_SetString(PyExc_RuntimeError,
 178                 "function attributes not accessible in restricted mode");
 179         return 1;
 180 }
 181
 182 static PyObject *
 183 func_get_dict(PyFunctionObject *op)
 184 {
 185         if (restricted())
 186                 return NULL;
 187         if (op->func_dict == NULL) {
 188                 op->func_dict = PyDict_New();
 189                 if (op->func_dict == NULL)
 190                         return NULL;
 191         }
 192         Py_INCREF(op->func_dict);
 193         return op->func_dict;
 194 }
 195
 196 static int
 197 func_set_dict(PyFunctionObject *op, PyObject *value)
 198 {
 199         PyObject *tmp;
 200
 201         if (restricted())
 202                 return -1;
 203         /* It is illegal to del f.func_dict */
 204         if (value == NULL) {
 205                 PyErr_SetString(PyExc_TypeError,
 206                                 "function's dictionary may not be deleted");
 207                 return -1;
 208         }
 209         /* Can only set func_dict to a dictionary */
 210         if (!PyDict_Check(value)) {
 211                 PyErr_SetString(PyExc_TypeError,
 212                                 "setting function's dictionary to a non-dict");
 213                 return -1;
 214         }
 215         tmp = op->func_dict;
 216         Py_INCREF(value);
 217         op->func_dict = value;
 218         Py_XDECREF(tmp);
 219         return 0;
 220 }
 221
 222 static PyObject *
 223 func_get_code(PyFunctionObject *op)
 224 {
 225         if (restricted())
 226                 return NULL;
 227         Py_INCREF(op->func_code);
 228         return op->func_code;
 229 }
 230
 231 static int
 232 func_set_code(PyFunctionObject *op, PyObject *value)
 233 {
 234         PyObject *tmp;
 235         Py_ssize_t nfree, nclosure;
 236
 237         if (restricted())
 238                 return -1;
 239         /* Not legal to del f.func_code or to set it to anything
 240          * other than a code object. */
 241         if (value == NULL || !PyCode_Check(value)) {
 242                 PyErr_SetString(PyExc_TypeError,
 243                                 "func_code must be set to a code object");
 244                 return -1;
 245         }
 246         nfree = PyCode_GetNumFree((PyCodeObject *)value);
 247         nclosure = (op->func_closure == NULL ? 0 :
 248                     PyTuple_GET_SIZE(op->func_closure));
 249         if (nclosure != nfree) {
 250                 PyErr_Format(PyExc_ValueError,
 251                              "%s() requires a code object with %zd free vars,"
 252                              " not %zd",
 253                              PyString_AsString(op->func_name),
 254                              nclosure, nfree);
 255                 return -1;
 256         }
 257         tmp = op->func_code;
 258         Py_INCREF(value);
 259         op->func_code = value;
 260         Py_DECREF(tmp);
 261         return 0;
 262 }
 263
 264 static PyObject *
 265 func_get_name(PyFunctionObject *op)
 266 {
 267         Py_INCREF(op->func_name);
 268         return op->func_name;
 269 }
 270
 271 static int
 272 func_set_name(PyFunctionObject *op, PyObject *value)
 273 {
 274         PyObject *tmp;
 275
 276         if (restricted())
 277                 return -1;
 278         /* Not legal to del f.func_name or to set it to anything
 279          * other than a string object. */
 280         if (value == NULL || !PyString_Check(value)) {
 281                 PyErr_SetString(PyExc_TypeError,
 282                                 "func_name must be set to a string object");
 283                 return -1;
 284         }
 285         tmp = op->func_name;
 286         Py_INCREF(value);
 287         op->func_name = value;
 288         Py_DECREF(tmp);
 289         return 0;
 290 }
 291
 292 static PyObject *
 293 func_get_defaults(PyFunctionObject *op)
 294 {
 295         if (restricted())
 296                 return NULL;
 297         if (op->func_defaults == NULL) {
 298                 Py_INCREF(Py_None);
 299                 return Py_None;
 300         }
 301         Py_INCREF(op->func_defaults);
 302         return op->func_defaults;
 303 }
 304
 305 static int
 306 func_set_defaults(PyFunctionObject *op, PyObject *value)
 307 {
 308         PyObject *tmp;
 309
 310         if (restricted())
 311                 return -1;
 312         /* Legal to del f.func_defaults.
 313          * Can only set func_defaults to NULL or a tuple. */
 314         if (value == Py_None)
 315                 value = NULL;
 316         if (value != NULL && !PyTuple_Check(value)) {
 317                 PyErr_SetString(PyExc_TypeError,
 318                                 "func_defaults must be set to a tuple object");
 319                 return -1;
 320         }
 321         tmp = op->func_defaults;
 322         Py_XINCREF(value);
 323         op->func_defaults = value;
 324         Py_XDECREF(tmp);
 325         return 0;
 326 }
 327
 328 static PyGetSetDef func_getsetlist[] = {
 329         {"func_code", (getter)func_get_code, (setter)func_set_code},
 330         {"func_defaults", (getter)func_get_defaults,
 331          (setter)func_set_defaults},
 332         {"func_dict", (getter)func_get_dict, (setter)func_set_dict},
 333         {"__dict__", (getter)func_get_dict, (setter)func_set_dict},
 334         {"func_name", (getter)func_get_name, (setter)func_set_name},
 335         {"__name__", (getter)func_get_name, (setter)func_set_name},
 336         {NULL} /* Sentinel */
 337 };
 338
 339 PyDoc_STRVAR(func_doc,
 340 "function(code, globals[, name[, argdefs[, closure]]])\n\
 341 \n\
 342 Create a function object from a code object and a dictionary.\n\
 343 The optional name string overrides the name from the code object.\n\
 344 The optional argdefs tuple specifies the default argument values.\n\
 345 The optional closure tuple supplies the bindings for free variables.");
 346
 347 /* func_new() maintains the following invariants for closures.  The
 348    closure must correspond to the free variables of the code object.
 349
 350    if len(code.co_freevars) == 0:
 351            closure = NULL
 352    else:
 353            len(closure) == len(code.co_freevars)
 354    for every elt in closure, type(elt) == cell
 355 */
 356
 357 static PyObject *
 358 func_new(PyTypeObject* type, PyObject* args, PyObject* kw)
 359 {
 360         PyCodeObject *code;
 361         PyObject *globals;
 362         PyObject *name = Py_None;
 363         PyObject *defaults = Py_None;
 364         PyObject *closure = Py_None;
 365         PyFunctionObject *newfunc;
 366         Py_ssize_t nfree, nclosure;
 367         static char *kwlist[] = {"code", "globals", "name",
 368                                  "argdefs", "closure", 0};
 369
 370         if (!PyArg_ParseTupleAndKeywords(args, kw, "O!O!|OOO:function",
 371                               kwlist,
 372                               &PyCode_Type, &code,
 373                               &PyDict_Type, &globals,
 374                               &name, &defaults, &closure))
 375                 return NULL;
 376         if (name != Py_None && !PyString_Check(name)) {
 377                 PyErr_SetString(PyExc_TypeError,
 378                                 "arg 3 (name) must be None or string");
 379                 return NULL;
 380         }
 381         if (defaults != Py_None && !PyTuple_Check(defaults)) {
 382                 PyErr_SetString(PyExc_TypeError,
 383                                 "arg 4 (defaults) must be None or tuple");
 384                 return NULL;
 385         }
 386         nfree = PyTuple_GET_SIZE(code->co_freevars);
 387         if (!PyTuple_Check(closure)) {
 388                 if (nfree && closure == Py_None) {
 389                         PyErr_SetString(PyExc_TypeError,
 390                                         "arg 5 (closure) must be tuple");
 391                         return NULL;
 392                 }
 393                 else if (closure != Py_None) {
 394                         PyErr_SetString(PyExc_TypeError,
 395                                 "arg 5 (closure) must be None or tuple");
 396                         return NULL;
 397                 }
 398         }
 399
 400         /* check that the closure is well-formed */
 401         nclosure = closure == Py_None ? 0 : PyTuple_GET_SIZE(closure);
 402         if (nfree != nclosure)
 403                 return PyErr_Format(PyExc_ValueError,
 404                                     "%s requires closure of length %zd, not %zd",
 405                                     PyString_AS_STRING(code->co_name),
 406                                     nfree, nclosure);
 407         if (nclosure) {
 408                 Py_ssize_t i;
 409                 for (i = 0; i < nclosure; i++) {
 410                         PyObject *o = PyTuple_GET_ITEM(closure, i);
 411                         if (!PyCell_Check(o)) {
 412                                 return PyErr_Format(PyExc_TypeError,
 413                                     "arg 5 (closure) expected cell, found %s",
 414                                                     o->ob_type->tp_name);
 415                         }
 416                 }
 417         }
 418
 419         newfunc = (PyFunctionObject *)PyFunction_New((PyObject *)code,
 420                                                      globals);
 421         if (newfunc == NULL)
 422                 return NULL;
 423
 424         if (name != Py_None) {
 425                 Py_INCREF(name);
 426                 Py_DECREF(newfunc->func_name);
 427                 newfunc->func_name = name;
 428         }
 429         if (defaults != Py_None) {
 430                 Py_INCREF(defaults);
 431                 newfunc->func_defaults  = defaults;
 432         }
 433         if (closure != Py_None) {
 434                 Py_INCREF(closure);
 435                 newfunc->func_closure = closure;
 436         }
 437
 438         return (PyObject *)newfunc;
 439 }
 440
 441 static void
 442 func_dealloc(PyFunctionObject *op)
 443 {
 444         _PyObject_GC_UNTRACK(op);
 445         if (op->func_weakreflist != NULL)
 446                 PyObject_ClearWeakRefs((PyObject *) op);
 447         Py_DECREF(op->func_code);
 448         Py_DECREF(op->func_globals);
 449         Py_XDECREF(op->func_module);
 450         Py_DECREF(op->func_name);
 451         Py_XDECREF(op->func_defaults);
 452         Py_XDECREF(op->func_doc);
 453         Py_XDECREF(op->func_dict);
 454         Py_XDECREF(op->func_closure);
 455         PyObject_GC_Del(op);
 456 }
 457
 458 static PyObject*
 459 func_repr(PyFunctionObject *op)
 460 {
 461         return PyString_FromFormat("<function %s at %p>",
 462                                    PyString_AsString(op->func_name),
 463                                    op);
 464 }
 465
 466 static int
 467 func_traverse(PyFunctionObject *f, visitproc visit, void *arg)
 468 {
 469         Py_VISIT(f->func_code);
 470         Py_VISIT(f->func_globals);
 471         Py_VISIT(f->func_module);
 472         Py_VISIT(f->func_defaults);
 473         Py_VISIT(f->func_doc);
 474         Py_VISIT(f->func_name);
 475         Py_VISIT(f->func_dict);
 476         Py_VISIT(f->func_closure);
 477         return 0;
 478 }
 479
 480 static PyObject *
 481 function_call(PyObject *func, PyObject *arg, PyObject *kw)
 482 {
 483         PyObject *result;
 484         PyObject *argdefs;
 485         PyObject **d, **k;
 486         Py_ssize_t nk, nd;
 487
 488         argdefs = PyFunction_GET_DEFAULTS(func);
 489         if (argdefs != NULL && PyTuple_Check(argdefs)) {
 490                 d = &PyTuple_GET_ITEM((PyTupleObject *)argdefs, 0);
 491                 nd = PyTuple_Size(argdefs);
 492         }
 493         else {
 494                 d = NULL;
 495                 nd = 0;
 496         }
 497
 498         if (kw != NULL && PyDict_Check(kw)) {
 499                 Py_ssize_t pos, i;
 500                 nk = PyDict_Size(kw);
 501                 k = PyMem_NEW(PyObject *, 2*nk);
 502                 if (k == NULL) {
 503                         PyErr_NoMemory();
 504                         return NULL;
 505                 }
 506                 pos = i = 0;
 507                 while (PyDict_Next(kw, &pos, &k[i], &k[i+1]))
 508                         i += 2;
 509                 nk = i/2;
 510                 /* XXX This is broken if the caller deletes dict items! */
 511         }
 512         else {
 513                 k = NULL;
 514                 nk = 0;
 515         }
 516
 517         result = PyEval_EvalCodeEx(
 518                 (PyCodeObject *)PyFunction_GET_CODE(func),
 519                 PyFunction_GET_GLOBALS(func), (PyObject *)NULL,
 520                 &PyTuple_GET_ITEM(arg, 0), PyTuple_Size(arg),
 521                 k, nk, d, nd,
 522                 PyFunction_GET_CLOSURE(func));
 523
 524         if (k != NULL)
 525                 PyMem_DEL(k);
 526
 527         return result;
 528 }
 529
 530 /* Bind a function to an object */
 531 static PyObject *
 532 func_descr_get(PyObject *func, PyObject *obj, PyObject *type)
 533 {
 534         if (obj == Py_None)
 535                 obj = NULL;
 536         return PyMethod_New(func, obj, type);
 537 }
 538
 539 PyTypeObject PyFunction_Type = {
 540         PyObject_HEAD_INIT(&PyType_Type)
 541         0,
 542         "function",
 543         sizeof(PyFunctionObject),
 544         0,
 545         (destructor)func_dealloc,               /* tp_dealloc */
 546         0,                                      /* tp_print */
 547         0,                                      /* tp_getattr */
 548         0,                                      /* tp_setattr */
 549         0,                                      /* tp_compare */
 550         (reprfunc)func_repr,                    /* tp_repr */
 551         0,                                      /* tp_as_number */
 552         0,                                      /* tp_as_sequence */
 553         0,                                      /* tp_as_mapping */
 554         0,                                      /* tp_hash */
 555         function_call,                          /* tp_call */
 556         0,                                      /* tp_str */
 557         PyObject_GenericGetAttr,                /* tp_getattro */
 558         PyObject_GenericSetAttr,                /* tp_setattro */
 559         0,                                      /* tp_as_buffer */
 560         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
 561         func_doc,                               /* tp_doc */
 562         (traverseproc)func_traverse,            /* tp_traverse */
 563         0,                                      /* tp_clear */
 564         0,                                      /* tp_richcompare */
 565         offsetof(PyFunctionObject, func_weakreflist), /* tp_weaklistoffset */
 566         0,                                      /* tp_iter */
 567         0,                                      /* tp_iternext */
 568         0,                                      /* tp_methods */
 569         func_memberlist,                        /* tp_members */
 570         func_getsetlist,                        /* tp_getset */
 571         0,                                      /* tp_base */
 572         0,                                      /* tp_dict */
 573         func_descr_get,                         /* tp_descr_get */
 574         0,                                      /* tp_descr_set */
 575         offsetof(PyFunctionObject, func_dict),  /* tp_dictoffset */
 576         0,                                      /* tp_init */
 577         0,                                      /* tp_alloc */
 578         func_new,                               /* tp_new */
 579 };
 580
 581
 582 /* Class method object */
 583
 584 /* A class method receives the class as implicit first argument,
 585    just like an instance method receives the instance.
 586    To declare a class method, use this idiom:
 587
 588      class C:
 589          def f(cls, arg1, arg2, ...): ...
 590          f = classmethod(f)
 591
 592    It can be called either on the class (e.g. C.f()) or on an instance
 593    (e.g. C().f()); the instance is ignored except for its class.
 594    If a class method is called for a derived class, the derived class
 595    object is passed as the implied first argument.
 596
 597    Class methods are different than C++ or Java static methods.
 598    If you want those, see static methods below.
 599 */
 600
 601 typedef struct {
 602         PyObject_HEAD
 603         PyObject *cm_callable;
 604 } classmethod;
 605
 606 static void
 607 cm_dealloc(classmethod *cm)
 608 {
 609         _PyObject_GC_UNTRACK((PyObject *)cm);
 610         Py_XDECREF(cm->cm_callable);
 611         cm->ob_type->tp_free((PyObject *)cm);
 612 }
 613
 614 static int
 615 cm_traverse(classmethod *cm, visitproc visit, void *arg)
 616 {
 617         Py_VISIT(cm->cm_callable);
 618         return 0;
 619 }
 620
 621 static int
 622 cm_clear(classmethod *cm)
 623 {
 624         Py_CLEAR(cm->cm_callable);
 625         return 0;
 626 }
 627
 628
 629 static PyObject *
 630 cm_descr_get(PyObject *self, PyObject *obj, PyObject *type)
 631 {
 632         classmethod *cm = (classmethod *)self;
 633
 634         if (cm->cm_callable == NULL) {
 635                 PyErr_SetString(PyExc_RuntimeError,
 636                                 "uninitialized classmethod object");
 637                 return NULL;
 638         }
 639         if (type == NULL)
 640                 type = (PyObject *)(obj->ob_type);
 641         return PyMethod_New(cm->cm_callable,
 642                             type, (PyObject *)(type->ob_type));
 643 }
 644
 645 static int
 646 cm_init(PyObject *self, PyObject *args, PyObject *kwds)
 647 {
 648         classmethod *cm = (classmethod *)self;
 649         PyObject *callable;
 650
 651         if (!PyArg_UnpackTuple(args, "classmethod", 1, 1, &callable))
 652                 return -1;
 653         if (!_PyArg_NoKeywords("classmethod", kwds))
 654                 return -1;
 655         if (!PyCallable_Check(callable)) {
 656                 PyErr_Format(PyExc_TypeError, "'%s' object is not callable",
 657                      callable->ob_type->tp_name);
 658                 return -1;
 659         }
 660
 661         Py_INCREF(callable);
 662         cm->cm_callable = callable;
 663         return 0;
 664 }
 665
 666 PyDoc_STRVAR(classmethod_doc,
 667 "classmethod(function) -> method\n\
 668 \n\
 669 Convert a function to be a class method.\n\
 670 \n\
 671 A class method receives the class as implicit first argument,\n\
 672 just like an instance method receives the instance.\n\
 673 To declare a class method, use this idiom:\n\
 674 \n\
 675   class C:\n\
 676       def f(cls, arg1, arg2, ...): ...\n\
 677       f = classmethod(f)\n\
 678 \n\
 679 It can be called either on the class (e.g. C.f()) or on an instance\n\
 680 (e.g. C().f()).  The instance is ignored except for its class.\n\
 681 If a class method is called for a derived class, the derived class\n\
 682 object is passed as the implied first argument.\n\
 683 \n\
 684 Class methods are different than C++ or Java static methods.\n\
 685 If you want those, see the staticmethod builtin.");
 686
 687 PyTypeObject PyClassMethod_Type = {
 688         PyObject_HEAD_INIT(&PyType_Type)
 689         0,
 690         "classmethod",
 691         sizeof(classmethod),
 692         0,
 693         (destructor)cm_dealloc,                 /* tp_dealloc */
 694         0,                                      /* tp_print */
 695         0,                                      /* tp_getattr */
 696         0,                                      /* tp_setattr */
 697         0,                                      /* tp_compare */
 698         0,                                      /* tp_repr */
 699         0,                                      /* tp_as_number */
 700         0,                                      /* tp_as_sequence */
 701         0,                                      /* tp_as_mapping */
 702         0,                                      /* tp_hash */
 703         0,                                      /* tp_call */
 704         0,                                      /* tp_str */
 705         PyObject_GenericGetAttr,                /* tp_getattro */
 706         0,                                      /* tp_setattro */
 707         0,                                      /* tp_as_buffer */
 708         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
 709         classmethod_doc,                        /* tp_doc */
 710         (traverseproc)cm_traverse,              /* tp_traverse */
 711         (inquiry)cm_clear,                      /* tp_clear */
 712         0,                                      /* tp_richcompare */
 713         0,                                      /* tp_weaklistoffset */
 714         0,                                      /* tp_iter */
 715         0,                                      /* tp_iternext */
 716         0,                                      /* tp_methods */
 717         0,                                      /* tp_members */
 718         0,                                      /* tp_getset */
 719         0,                                      /* tp_base */
 720         0,                                      /* tp_dict */
 721         cm_descr_get,                           /* tp_descr_get */
 722         0,                                      /* tp_descr_set */
 723         0,                                      /* tp_dictoffset */
 724         cm_init,                                /* tp_init */
 725         PyType_GenericAlloc,                    /* tp_alloc */
 726         PyType_GenericNew,                      /* tp_new */
 727         PyObject_GC_Del,                        /* tp_free */
 728 };
 729
 730 PyObject *
 731 PyClassMethod_New(PyObject *callable)
 732 {
 733         classmethod *cm = (classmethod *)
 734                 PyType_GenericAlloc(&PyClassMethod_Type, 0);
 735         if (cm != NULL) {
 736                 Py_INCREF(callable);
 737                 cm->cm_callable = callable;
 738         }
 739         return (PyObject *)cm;
 740 }
 741
 742
 743 /* Static method object */
 744
 745 /* A static method does not receive an implicit first argument.
 746    To declare a static method, use this idiom:
 747
 748      class C:
 749          def f(arg1, arg2, ...): ...
 750          f = staticmethod(f)
 751
 752    It can be called either on the class (e.g. C.f()) or on an instance
 753    (e.g. C().f()); the instance is ignored except for its class.
 754
 755    Static methods in Python are similar to those found in Java or C++.
 756    For a more advanced concept, see class methods above.
 757 */
 758
 759 typedef struct {
 760         PyObject_HEAD
 761         PyObject *sm_callable;
 762 } staticmethod;
 763
 764 static void
 765 sm_dealloc(staticmethod *sm)
 766 {
 767         _PyObject_GC_UNTRACK((PyObject *)sm);
 768         Py_XDECREF(sm->sm_callable);
 769         sm->ob_type->tp_free((PyObject *)sm);
 770 }
 771
 772 static int
 773 sm_traverse(staticmethod *sm, visitproc visit, void *arg)
 774 {
 775         Py_VISIT(sm->sm_callable);
 776         return 0;
 777 }
 778
 779 static int
 780 sm_clear(staticmethod *sm)
 781 {
 782         Py_XDECREF(sm->sm_callable);
 783         sm->sm_callable = NULL;
 784
 785         return 0;
 786 }
 787
 788 static PyObject *
 789 sm_descr_get(PyObject *self, PyObject *obj, PyObject *type)
 790 {
 791         staticmethod *sm = (staticmethod *)self;
 792
 793         if (sm->sm_callable == NULL) {
 794                 PyErr_SetString(PyExc_RuntimeError,
 795                                 "uninitialized staticmethod object");
 796                 return NULL;
 797         }
 798         Py_INCREF(sm->sm_callable);
 799         return sm->sm_callable;
 800 }
 801
 802 static int
 803 sm_init(PyObject *self, PyObject *args, PyObject *kwds)
 804 {
 805         staticmethod *sm = (staticmethod *)self;
 806         PyObject *callable;
 807
 808         if (!PyArg_UnpackTuple(args, "staticmethod", 1, 1, &callable))
 809                 return -1;
 810         if (!_PyArg_NoKeywords("staticmethod", kwds))
 811                 return -1;
 812         Py_INCREF(callable);
 813         sm->sm_callable = callable;
 814         return 0;
 815 }
 816
 817 PyDoc_STRVAR(staticmethod_doc,
 818 "staticmethod(function) -> method\n\
 819 \n\
 820 Convert a function to be a static method.\n\
 821 \n\
 822 A static method does not receive an implicit first argument.\n\
 823 To declare a static method, use this idiom:\n\
 824 \n\
 825      class C:\n\
 826          def f(arg1, arg2, ...): ...\n\
 827          f = staticmethod(f)\n\
 828 \n\
 829 It can be called either on the class (e.g. C.f()) or on an instance\n\
 830 (e.g. C().f()).  The instance is ignored except for its class.\n\
 831 \n\
 832 Static methods in Python are similar to those found in Java or C++.\n\
 833 For a more advanced concept, see the classmethod builtin.");
 834
 835 PyTypeObject PyStaticMethod_Type = {
 836         PyObject_HEAD_INIT(&PyType_Type)
 837         0,
 838         "staticmethod",
 839         sizeof(staticmethod),
 840         0,
 841         (destructor)sm_dealloc,                 /* tp_dealloc */
 842         0,                                      /* tp_print */
 843         0,                                      /* tp_getattr */
 844         0,                                      /* tp_setattr */
 845         0,                                      /* tp_compare */
 846         0,                                      /* tp_repr */
 847         0,                                      /* tp_as_number */
 848         0,                                      /* tp_as_sequence */
 849         0,                                      /* tp_as_mapping */
 850         0,                                      /* tp_hash */
 851         0,                                      /* tp_call */
 852         0,                                      /* tp_str */
 853         PyObject_GenericGetAttr,                /* tp_getattro */
 854         0,                                      /* tp_setattro */
 855         0,                                      /* tp_as_buffer */
 856         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
 857         staticmethod_doc,                       /* tp_doc */
 858         (traverseproc)sm_traverse,              /* tp_traverse */
 859         (inquiry)sm_clear,                      /* tp_clear */
 860         0,                                      /* tp_richcompare */
 861         0,                                      /* tp_weaklistoffset */
 862         0,                                      /* tp_iter */
 863         0,                                      /* tp_iternext */
 864         0,                                      /* tp_methods */
 865         0,                                      /* tp_members */
 866         0,                                      /* tp_getset */
 867         0,                                      /* tp_base */
 868         0,                                      /* tp_dict */
 869         sm_descr_get,                           /* tp_descr_get */
 870         0,                                      /* tp_descr_set */
 871         0,                                      /* tp_dictoffset */
 872         sm_init,                                /* tp_init */
 873         PyType_GenericAlloc,                    /* tp_alloc */
 874         PyType_GenericNew,                      /* tp_new */
 875         PyObject_GC_Del,                        /* tp_free */
 876 };
 877
 878 PyObject *
 879 PyStaticMethod_New(PyObject *callable)
 880 {
 881         staticmethod *sm = (staticmethod *)
 882                 PyType_GenericAlloc(&PyStaticMethod_Type, 0);
 883         if (sm != NULL) {
 884                 Py_INCREF(callable);
 885                 sm->sm_callable = callable;
 886         }
 887         return (PyObject *)sm;
 888 }