1 
2 /* Function object implementation */
3 
4 #include "Python.h"
5 #include "pycore_ceval.h"         // _PyEval_BuiltinsFromGlobals()
6 #include "pycore_object.h"        // _PyObject_GC_UNTRACK()
7 #include "pycore_pyerrors.h"      // _PyErr_Occurred()
8 #include "structmember.h"         // PyMemberDef
9 
10 static uint32_t next_func_version = 1;
11 
12 PyFunctionObject *
_PyFunction_FromConstructor(PyFrameConstructor * constr)13 _PyFunction_FromConstructor(PyFrameConstructor *constr)
14 {
15 
16     PyFunctionObject *op = PyObject_GC_New(PyFunctionObject, &PyFunction_Type);
17     if (op == NULL) {
18         return NULL;
19     }
20     Py_INCREF(constr->fc_globals);
21     op->func_globals = constr->fc_globals;
22     Py_INCREF(constr->fc_builtins);
23     op->func_builtins = constr->fc_builtins;
24     Py_INCREF(constr->fc_name);
25     op->func_name = constr->fc_name;
26     Py_INCREF(constr->fc_qualname);
27     op->func_qualname = constr->fc_qualname;
28     Py_INCREF(constr->fc_code);
29     op->func_code = constr->fc_code;
30     Py_XINCREF(constr->fc_defaults);
31     op->func_defaults = constr->fc_defaults;
32     Py_XINCREF(constr->fc_kwdefaults);
33     op->func_kwdefaults = constr->fc_kwdefaults;
34     Py_XINCREF(constr->fc_closure);
35     op->func_closure = constr->fc_closure;
36     Py_INCREF(Py_None);
37     op->func_doc = Py_None;
38     op->func_dict = NULL;
39     op->func_weakreflist = NULL;
40     op->func_module = NULL;
41     op->func_annotations = NULL;
42     op->vectorcall = _PyFunction_Vectorcall;
43     op->func_version = 0;
44     _PyObject_GC_TRACK(op);
45     return op;
46 }
47 
48 PyObject *
PyFunction_NewWithQualName(PyObject * code,PyObject * globals,PyObject * qualname)49 PyFunction_NewWithQualName(PyObject *code, PyObject *globals, PyObject *qualname)
50 {
51     assert(globals != NULL);
52     assert(PyDict_Check(globals));
53     Py_INCREF(globals);
54 
55     PyThreadState *tstate = _PyThreadState_GET();
56 
57     PyCodeObject *code_obj = (PyCodeObject *)code;
58     Py_INCREF(code_obj);
59 
60     PyObject *name = code_obj->co_name;
61     assert(name != NULL);
62     Py_INCREF(name);
63 
64     if (!qualname) {
65         qualname = code_obj->co_qualname;
66     }
67     assert(qualname != NULL);
68     Py_INCREF(qualname);
69 
70     PyObject *consts = code_obj->co_consts;
71     assert(PyTuple_Check(consts));
72     PyObject *doc;
73     if (PyTuple_Size(consts) >= 1) {
74         doc = PyTuple_GetItem(consts, 0);
75         if (!PyUnicode_Check(doc)) {
76             doc = Py_None;
77         }
78     }
79     else {
80         doc = Py_None;
81     }
82     Py_INCREF(doc);
83 
84     // __module__: Use globals['__name__'] if it exists, or NULL.
85     PyObject *module = PyDict_GetItemWithError(globals, &_Py_ID(__name__));
86     PyObject *builtins = NULL;
87     if (module == NULL && _PyErr_Occurred(tstate)) {
88         goto error;
89     }
90     Py_XINCREF(module);
91 
92     builtins = _PyEval_BuiltinsFromGlobals(tstate, globals); // borrowed ref
93     if (builtins == NULL) {
94         goto error;
95     }
96     Py_INCREF(builtins);
97 
98     PyFunctionObject *op = PyObject_GC_New(PyFunctionObject, &PyFunction_Type);
99     if (op == NULL) {
100         goto error;
101     }
102     /* Note: No failures from this point on, since func_dealloc() does not
103        expect a partially-created object. */
104 
105     op->func_globals = globals;
106     op->func_builtins = builtins;
107     op->func_name = name;
108     op->func_qualname = qualname;
109     op->func_code = (PyObject*)code_obj;
110     op->func_defaults = NULL;    // No default positional arguments
111     op->func_kwdefaults = NULL;  // No default keyword arguments
112     op->func_closure = NULL;
113     op->func_doc = doc;
114     op->func_dict = NULL;
115     op->func_weakreflist = NULL;
116     op->func_module = module;
117     op->func_annotations = NULL;
118     op->vectorcall = _PyFunction_Vectorcall;
119     op->func_version = 0;
120     _PyObject_GC_TRACK(op);
121     return (PyObject *)op;
122 
123 error:
124     Py_DECREF(globals);
125     Py_DECREF(code_obj);
126     Py_DECREF(name);
127     Py_DECREF(qualname);
128     Py_DECREF(doc);
129     Py_XDECREF(module);
130     Py_XDECREF(builtins);
131     return NULL;
132 }
133 
_PyFunction_GetVersionForCurrentState(PyFunctionObject * func)134 uint32_t _PyFunction_GetVersionForCurrentState(PyFunctionObject *func)
135 {
136     if (func->func_version != 0) {
137         return func->func_version;
138     }
139     if (next_func_version == 0) {
140         return 0;
141     }
142     uint32_t v = next_func_version++;
143     func->func_version = v;
144     return v;
145 }
146 
147 PyObject *
PyFunction_New(PyObject * code,PyObject * globals)148 PyFunction_New(PyObject *code, PyObject *globals)
149 {
150     return PyFunction_NewWithQualName(code, globals, NULL);
151 }
152 
153 PyObject *
PyFunction_GetCode(PyObject * op)154 PyFunction_GetCode(PyObject *op)
155 {
156     if (!PyFunction_Check(op)) {
157         PyErr_BadInternalCall();
158         return NULL;
159     }
160     return ((PyFunctionObject *) op) -> func_code;
161 }
162 
163 PyObject *
PyFunction_GetGlobals(PyObject * op)164 PyFunction_GetGlobals(PyObject *op)
165 {
166     if (!PyFunction_Check(op)) {
167         PyErr_BadInternalCall();
168         return NULL;
169     }
170     return ((PyFunctionObject *) op) -> func_globals;
171 }
172 
173 PyObject *
PyFunction_GetModule(PyObject * op)174 PyFunction_GetModule(PyObject *op)
175 {
176     if (!PyFunction_Check(op)) {
177         PyErr_BadInternalCall();
178         return NULL;
179     }
180     return ((PyFunctionObject *) op) -> func_module;
181 }
182 
183 PyObject *
PyFunction_GetDefaults(PyObject * op)184 PyFunction_GetDefaults(PyObject *op)
185 {
186     if (!PyFunction_Check(op)) {
187         PyErr_BadInternalCall();
188         return NULL;
189     }
190     return ((PyFunctionObject *) op) -> func_defaults;
191 }
192 
193 int
PyFunction_SetDefaults(PyObject * op,PyObject * defaults)194 PyFunction_SetDefaults(PyObject *op, PyObject *defaults)
195 {
196     if (!PyFunction_Check(op)) {
197         PyErr_BadInternalCall();
198         return -1;
199     }
200     if (defaults == Py_None)
201         defaults = NULL;
202     else if (defaults && PyTuple_Check(defaults)) {
203         Py_INCREF(defaults);
204     }
205     else {
206         PyErr_SetString(PyExc_SystemError, "non-tuple default args");
207         return -1;
208     }
209     ((PyFunctionObject *)op)->func_version = 0;
210     Py_XSETREF(((PyFunctionObject *)op)->func_defaults, defaults);
211     return 0;
212 }
213 
214 PyObject *
PyFunction_GetKwDefaults(PyObject * op)215 PyFunction_GetKwDefaults(PyObject *op)
216 {
217     if (!PyFunction_Check(op)) {
218         PyErr_BadInternalCall();
219         return NULL;
220     }
221     return ((PyFunctionObject *) op) -> func_kwdefaults;
222 }
223 
224 int
PyFunction_SetKwDefaults(PyObject * op,PyObject * defaults)225 PyFunction_SetKwDefaults(PyObject *op, PyObject *defaults)
226 {
227     if (!PyFunction_Check(op)) {
228         PyErr_BadInternalCall();
229         return -1;
230     }
231     if (defaults == Py_None)
232         defaults = NULL;
233     else if (defaults && PyDict_Check(defaults)) {
234         Py_INCREF(defaults);
235     }
236     else {
237         PyErr_SetString(PyExc_SystemError,
238                         "non-dict keyword only default args");
239         return -1;
240     }
241     ((PyFunctionObject *)op)->func_version = 0;
242     Py_XSETREF(((PyFunctionObject *)op)->func_kwdefaults, defaults);
243     return 0;
244 }
245 
246 PyObject *
PyFunction_GetClosure(PyObject * op)247 PyFunction_GetClosure(PyObject *op)
248 {
249     if (!PyFunction_Check(op)) {
250         PyErr_BadInternalCall();
251         return NULL;
252     }
253     return ((PyFunctionObject *) op) -> func_closure;
254 }
255 
256 int
PyFunction_SetClosure(PyObject * op,PyObject * closure)257 PyFunction_SetClosure(PyObject *op, PyObject *closure)
258 {
259     if (!PyFunction_Check(op)) {
260         PyErr_BadInternalCall();
261         return -1;
262     }
263     if (closure == Py_None)
264         closure = NULL;
265     else if (PyTuple_Check(closure)) {
266         Py_INCREF(closure);
267     }
268     else {
269         PyErr_Format(PyExc_SystemError,
270                      "expected tuple for closure, got '%.100s'",
271                      Py_TYPE(closure)->tp_name);
272         return -1;
273     }
274     ((PyFunctionObject *)op)->func_version = 0;
275     Py_XSETREF(((PyFunctionObject *)op)->func_closure, closure);
276     return 0;
277 }
278 
279 static PyObject *
func_get_annotation_dict(PyFunctionObject * op)280 func_get_annotation_dict(PyFunctionObject *op)
281 {
282     if (op->func_annotations == NULL) {
283         return NULL;
284     }
285     if (PyTuple_CheckExact(op->func_annotations)) {
286         PyObject *ann_tuple = op->func_annotations;
287         PyObject *ann_dict = PyDict_New();
288         if (ann_dict == NULL) {
289             return NULL;
290         }
291 
292         assert(PyTuple_GET_SIZE(ann_tuple) % 2 == 0);
293 
294         for (Py_ssize_t i = 0; i < PyTuple_GET_SIZE(ann_tuple); i += 2) {
295             int err = PyDict_SetItem(ann_dict,
296                                      PyTuple_GET_ITEM(ann_tuple, i),
297                                      PyTuple_GET_ITEM(ann_tuple, i + 1));
298 
299             if (err < 0) {
300                 return NULL;
301             }
302         }
303         Py_SETREF(op->func_annotations, ann_dict);
304     }
305     assert(PyDict_Check(op->func_annotations));
306     return op->func_annotations;
307 }
308 
309 PyObject *
PyFunction_GetAnnotations(PyObject * op)310 PyFunction_GetAnnotations(PyObject *op)
311 {
312     if (!PyFunction_Check(op)) {
313         PyErr_BadInternalCall();
314         return NULL;
315     }
316     return func_get_annotation_dict((PyFunctionObject *)op);
317 }
318 
319 int
PyFunction_SetAnnotations(PyObject * op,PyObject * annotations)320 PyFunction_SetAnnotations(PyObject *op, PyObject *annotations)
321 {
322     if (!PyFunction_Check(op)) {
323         PyErr_BadInternalCall();
324         return -1;
325     }
326     if (annotations == Py_None)
327         annotations = NULL;
328     else if (annotations && PyDict_Check(annotations)) {
329         Py_INCREF(annotations);
330     }
331     else {
332         PyErr_SetString(PyExc_SystemError,
333                         "non-dict annotations");
334         return -1;
335     }
336     ((PyFunctionObject *)op)->func_version = 0;
337     Py_XSETREF(((PyFunctionObject *)op)->func_annotations, annotations);
338     return 0;
339 }
340 
341 /* Methods */
342 
343 #define OFF(x) offsetof(PyFunctionObject, x)
344 
345 static PyMemberDef func_memberlist[] = {
346     {"__closure__",   T_OBJECT,     OFF(func_closure), READONLY},
347     {"__doc__",       T_OBJECT,     OFF(func_doc), 0},
348     {"__globals__",   T_OBJECT,     OFF(func_globals), READONLY},
349     {"__module__",    T_OBJECT,     OFF(func_module), 0},
350     {"__builtins__",  T_OBJECT,     OFF(func_builtins), READONLY},
351     {NULL}  /* Sentinel */
352 };
353 
354 static PyObject *
func_get_code(PyFunctionObject * op,void * Py_UNUSED (ignored))355 func_get_code(PyFunctionObject *op, void *Py_UNUSED(ignored))
356 {
357     if (PySys_Audit("object.__getattr__", "Os", op, "__code__") < 0) {
358         return NULL;
359     }
360 
361     Py_INCREF(op->func_code);
362     return op->func_code;
363 }
364 
365 static int
func_set_code(PyFunctionObject * op,PyObject * value,void * Py_UNUSED (ignored))366 func_set_code(PyFunctionObject *op, PyObject *value, void *Py_UNUSED(ignored))
367 {
368     Py_ssize_t nclosure;
369     int nfree;
370 
371     /* Not legal to del f.func_code or to set it to anything
372      * other than a code object. */
373     if (value == NULL || !PyCode_Check(value)) {
374         PyErr_SetString(PyExc_TypeError,
375                         "__code__ must be set to a code object");
376         return -1;
377     }
378 
379     if (PySys_Audit("object.__setattr__", "OsO",
380                     op, "__code__", value) < 0) {
381         return -1;
382     }
383 
384     nfree = ((PyCodeObject *)value)->co_nfreevars;
385     nclosure = (op->func_closure == NULL ? 0 :
386             PyTuple_GET_SIZE(op->func_closure));
387     if (nclosure != nfree) {
388         PyErr_Format(PyExc_ValueError,
389                      "%U() requires a code object with %zd free vars,"
390                      " not %zd",
391                      op->func_name,
392                      nclosure, nfree);
393         return -1;
394     }
395     op->func_version = 0;
396     Py_INCREF(value);
397     Py_XSETREF(op->func_code, value);
398     return 0;
399 }
400 
401 static PyObject *
func_get_name(PyFunctionObject * op,void * Py_UNUSED (ignored))402 func_get_name(PyFunctionObject *op, void *Py_UNUSED(ignored))
403 {
404     Py_INCREF(op->func_name);
405     return op->func_name;
406 }
407 
408 static int
func_set_name(PyFunctionObject * op,PyObject * value,void * Py_UNUSED (ignored))409 func_set_name(PyFunctionObject *op, PyObject *value, void *Py_UNUSED(ignored))
410 {
411     /* Not legal to del f.func_name or to set it to anything
412      * other than a string object. */
413     if (value == NULL || !PyUnicode_Check(value)) {
414         PyErr_SetString(PyExc_TypeError,
415                         "__name__ must be set to a string object");
416         return -1;
417     }
418     Py_INCREF(value);
419     Py_XSETREF(op->func_name, value);
420     return 0;
421 }
422 
423 static PyObject *
func_get_qualname(PyFunctionObject * op,void * Py_UNUSED (ignored))424 func_get_qualname(PyFunctionObject *op, void *Py_UNUSED(ignored))
425 {
426     Py_INCREF(op->func_qualname);
427     return op->func_qualname;
428 }
429 
430 static int
func_set_qualname(PyFunctionObject * op,PyObject * value,void * Py_UNUSED (ignored))431 func_set_qualname(PyFunctionObject *op, PyObject *value, void *Py_UNUSED(ignored))
432 {
433     /* Not legal to del f.__qualname__ or to set it to anything
434      * other than a string object. */
435     if (value == NULL || !PyUnicode_Check(value)) {
436         PyErr_SetString(PyExc_TypeError,
437                         "__qualname__ must be set to a string object");
438         return -1;
439     }
440     Py_INCREF(value);
441     Py_XSETREF(op->func_qualname, value);
442     return 0;
443 }
444 
445 static PyObject *
func_get_defaults(PyFunctionObject * op,void * Py_UNUSED (ignored))446 func_get_defaults(PyFunctionObject *op, void *Py_UNUSED(ignored))
447 {
448     if (PySys_Audit("object.__getattr__", "Os", op, "__defaults__") < 0) {
449         return NULL;
450     }
451     if (op->func_defaults == NULL) {
452         Py_RETURN_NONE;
453     }
454     Py_INCREF(op->func_defaults);
455     return op->func_defaults;
456 }
457 
458 static int
func_set_defaults(PyFunctionObject * op,PyObject * value,void * Py_UNUSED (ignored))459 func_set_defaults(PyFunctionObject *op, PyObject *value, void *Py_UNUSED(ignored))
460 {
461     /* Legal to del f.func_defaults.
462      * Can only set func_defaults to NULL or a tuple. */
463     if (value == Py_None)
464         value = NULL;
465     if (value != NULL && !PyTuple_Check(value)) {
466         PyErr_SetString(PyExc_TypeError,
467                         "__defaults__ must be set to a tuple object");
468         return -1;
469     }
470     if (value) {
471         if (PySys_Audit("object.__setattr__", "OsO",
472                         op, "__defaults__", value) < 0) {
473             return -1;
474         }
475     } else if (PySys_Audit("object.__delattr__", "Os",
476                            op, "__defaults__") < 0) {
477         return -1;
478     }
479 
480     op->func_version = 0;
481     Py_XINCREF(value);
482     Py_XSETREF(op->func_defaults, value);
483     return 0;
484 }
485 
486 static PyObject *
func_get_kwdefaults(PyFunctionObject * op,void * Py_UNUSED (ignored))487 func_get_kwdefaults(PyFunctionObject *op, void *Py_UNUSED(ignored))
488 {
489     if (PySys_Audit("object.__getattr__", "Os",
490                     op, "__kwdefaults__") < 0) {
491         return NULL;
492     }
493     if (op->func_kwdefaults == NULL) {
494         Py_RETURN_NONE;
495     }
496     Py_INCREF(op->func_kwdefaults);
497     return op->func_kwdefaults;
498 }
499 
500 static int
func_set_kwdefaults(PyFunctionObject * op,PyObject * value,void * Py_UNUSED (ignored))501 func_set_kwdefaults(PyFunctionObject *op, PyObject *value, void *Py_UNUSED(ignored))
502 {
503     if (value == Py_None)
504         value = NULL;
505     /* Legal to del f.func_kwdefaults.
506      * Can only set func_kwdefaults to NULL or a dict. */
507     if (value != NULL && !PyDict_Check(value)) {
508         PyErr_SetString(PyExc_TypeError,
509             "__kwdefaults__ must be set to a dict object");
510         return -1;
511     }
512     if (value) {
513         if (PySys_Audit("object.__setattr__", "OsO",
514                         op, "__kwdefaults__", value) < 0) {
515             return -1;
516         }
517     } else if (PySys_Audit("object.__delattr__", "Os",
518                            op, "__kwdefaults__") < 0) {
519         return -1;
520     }
521 
522     op->func_version = 0;
523     Py_XINCREF(value);
524     Py_XSETREF(op->func_kwdefaults, value);
525     return 0;
526 }
527 
528 static PyObject *
func_get_annotations(PyFunctionObject * op,void * Py_UNUSED (ignored))529 func_get_annotations(PyFunctionObject *op, void *Py_UNUSED(ignored))
530 {
531     if (op->func_annotations == NULL) {
532         op->func_annotations = PyDict_New();
533         if (op->func_annotations == NULL)
534             return NULL;
535     }
536     PyObject *d = func_get_annotation_dict(op);
537     if (d) {
538         Py_INCREF(d);
539     }
540     return d;
541 }
542 
543 static int
func_set_annotations(PyFunctionObject * op,PyObject * value,void * Py_UNUSED (ignored))544 func_set_annotations(PyFunctionObject *op, PyObject *value, void *Py_UNUSED(ignored))
545 {
546     if (value == Py_None)
547         value = NULL;
548     /* Legal to del f.func_annotations.
549      * Can only set func_annotations to NULL (through C api)
550      * or a dict. */
551     if (value != NULL && !PyDict_Check(value)) {
552         PyErr_SetString(PyExc_TypeError,
553             "__annotations__ must be set to a dict object");
554         return -1;
555     }
556     op->func_version = 0;
557     Py_XINCREF(value);
558     Py_XSETREF(op->func_annotations, value);
559     return 0;
560 }
561 
562 static PyGetSetDef func_getsetlist[] = {
563     {"__code__", (getter)func_get_code, (setter)func_set_code},
564     {"__defaults__", (getter)func_get_defaults,
565      (setter)func_set_defaults},
566     {"__kwdefaults__", (getter)func_get_kwdefaults,
567      (setter)func_set_kwdefaults},
568     {"__annotations__", (getter)func_get_annotations,
569      (setter)func_set_annotations},
570     {"__dict__", PyObject_GenericGetDict, PyObject_GenericSetDict},
571     {"__name__", (getter)func_get_name, (setter)func_set_name},
572     {"__qualname__", (getter)func_get_qualname, (setter)func_set_qualname},
573     {NULL} /* Sentinel */
574 };
575 
576 /*[clinic input]
577 class function "PyFunctionObject *" "&PyFunction_Type"
578 [clinic start generated code]*/
579 /*[clinic end generated code: output=da39a3ee5e6b4b0d input=70af9c90aa2e71b0]*/
580 
581 #include "clinic/funcobject.c.h"
582 
583 /* function.__new__() maintains the following invariants for closures.
584    The closure must correspond to the free variables of the code object.
585 
586    if len(code.co_freevars) == 0:
587        closure = NULL
588    else:
589        len(closure) == len(code.co_freevars)
590    for every elt in closure, type(elt) == cell
591 */
592 
593 /*[clinic input]
594 @classmethod
595 function.__new__ as func_new
596     code: object(type="PyCodeObject *", subclass_of="&PyCode_Type")
597         a code object
598     globals: object(subclass_of="&PyDict_Type")
599         the globals dictionary
600     name: object = None
601         a string that overrides the name from the code object
602     argdefs as defaults: object = None
603         a tuple that specifies the default argument values
604     closure: object = None
605         a tuple that supplies the bindings for free variables
606 
607 Create a function object.
608 [clinic start generated code]*/
609 
610 static PyObject *
func_new_impl(PyTypeObject * type,PyCodeObject * code,PyObject * globals,PyObject * name,PyObject * defaults,PyObject * closure)611 func_new_impl(PyTypeObject *type, PyCodeObject *code, PyObject *globals,
612               PyObject *name, PyObject *defaults, PyObject *closure)
613 /*[clinic end generated code: output=99c6d9da3a24e3be input=93611752fc2daf11]*/
614 {
615     PyFunctionObject *newfunc;
616     Py_ssize_t nclosure;
617 
618     if (name != Py_None && !PyUnicode_Check(name)) {
619         PyErr_SetString(PyExc_TypeError,
620                         "arg 3 (name) must be None or string");
621         return NULL;
622     }
623     if (defaults != Py_None && !PyTuple_Check(defaults)) {
624         PyErr_SetString(PyExc_TypeError,
625                         "arg 4 (defaults) must be None or tuple");
626         return NULL;
627     }
628     if (!PyTuple_Check(closure)) {
629         if (code->co_nfreevars && closure == Py_None) {
630             PyErr_SetString(PyExc_TypeError,
631                             "arg 5 (closure) must be tuple");
632             return NULL;
633         }
634         else if (closure != Py_None) {
635             PyErr_SetString(PyExc_TypeError,
636                 "arg 5 (closure) must be None or tuple");
637             return NULL;
638         }
639     }
640 
641     /* check that the closure is well-formed */
642     nclosure = closure == Py_None ? 0 : PyTuple_GET_SIZE(closure);
643     if (code->co_nfreevars != nclosure)
644         return PyErr_Format(PyExc_ValueError,
645                             "%U requires closure of length %zd, not %zd",
646                             code->co_name, code->co_nfreevars, nclosure);
647     if (nclosure) {
648         Py_ssize_t i;
649         for (i = 0; i < nclosure; i++) {
650             PyObject *o = PyTuple_GET_ITEM(closure, i);
651             if (!PyCell_Check(o)) {
652                 return PyErr_Format(PyExc_TypeError,
653                     "arg 5 (closure) expected cell, found %s",
654                                     Py_TYPE(o)->tp_name);
655             }
656         }
657     }
658     if (PySys_Audit("function.__new__", "O", code) < 0) {
659         return NULL;
660     }
661 
662     newfunc = (PyFunctionObject *)PyFunction_New((PyObject *)code,
663                                                  globals);
664     if (newfunc == NULL) {
665         return NULL;
666     }
667     if (name != Py_None) {
668         Py_INCREF(name);
669         Py_SETREF(newfunc->func_name, name);
670     }
671     if (defaults != Py_None) {
672         Py_INCREF(defaults);
673         newfunc->func_defaults  = defaults;
674     }
675     if (closure != Py_None) {
676         Py_INCREF(closure);
677         newfunc->func_closure = closure;
678     }
679 
680     return (PyObject *)newfunc;
681 }
682 
683 static int
func_clear(PyFunctionObject * op)684 func_clear(PyFunctionObject *op)
685 {
686     op->func_version = 0;
687     Py_CLEAR(op->func_globals);
688     Py_CLEAR(op->func_builtins);
689     Py_CLEAR(op->func_module);
690     Py_CLEAR(op->func_defaults);
691     Py_CLEAR(op->func_kwdefaults);
692     Py_CLEAR(op->func_doc);
693     Py_CLEAR(op->func_dict);
694     Py_CLEAR(op->func_closure);
695     Py_CLEAR(op->func_annotations);
696     // Don't Py_CLEAR(op->func_code), since code is always required
697     // to be non-NULL. Similarly, name and qualname shouldn't be NULL.
698     // However, name and qualname could be str subclasses, so they
699     // could have reference cycles. The solution is to replace them
700     // with a genuinely immutable string.
701     Py_SETREF(op->func_name, Py_NewRef(&_Py_STR(empty)));
702     Py_SETREF(op->func_qualname, Py_NewRef(&_Py_STR(empty)));
703     return 0;
704 }
705 
706 static void
func_dealloc(PyFunctionObject * op)707 func_dealloc(PyFunctionObject *op)
708 {
709     _PyObject_GC_UNTRACK(op);
710     if (op->func_weakreflist != NULL) {
711         PyObject_ClearWeakRefs((PyObject *) op);
712     }
713     (void)func_clear(op);
714     // These aren't cleared by func_clear().
715     Py_DECREF(op->func_code);
716     Py_DECREF(op->func_name);
717     Py_DECREF(op->func_qualname);
718     PyObject_GC_Del(op);
719 }
720 
721 static PyObject*
func_repr(PyFunctionObject * op)722 func_repr(PyFunctionObject *op)
723 {
724     return PyUnicode_FromFormat("<function %U at %p>",
725                                 op->func_qualname, op);
726 }
727 
728 static int
func_traverse(PyFunctionObject * f,visitproc visit,void * arg)729 func_traverse(PyFunctionObject *f, visitproc visit, void *arg)
730 {
731     Py_VISIT(f->func_code);
732     Py_VISIT(f->func_globals);
733     Py_VISIT(f->func_builtins);
734     Py_VISIT(f->func_module);
735     Py_VISIT(f->func_defaults);
736     Py_VISIT(f->func_kwdefaults);
737     Py_VISIT(f->func_doc);
738     Py_VISIT(f->func_name);
739     Py_VISIT(f->func_dict);
740     Py_VISIT(f->func_closure);
741     Py_VISIT(f->func_annotations);
742     Py_VISIT(f->func_qualname);
743     return 0;
744 }
745 
746 /* Bind a function to an object */
747 static PyObject *
func_descr_get(PyObject * func,PyObject * obj,PyObject * type)748 func_descr_get(PyObject *func, PyObject *obj, PyObject *type)
749 {
750     if (obj == Py_None || obj == NULL) {
751         Py_INCREF(func);
752         return func;
753     }
754     return PyMethod_New(func, obj);
755 }
756 
757 PyTypeObject PyFunction_Type = {
758     PyVarObject_HEAD_INIT(&PyType_Type, 0)
759     "function",
760     sizeof(PyFunctionObject),
761     0,
762     (destructor)func_dealloc,                   /* tp_dealloc */
763     offsetof(PyFunctionObject, vectorcall),     /* tp_vectorcall_offset */
764     0,                                          /* tp_getattr */
765     0,                                          /* tp_setattr */
766     0,                                          /* tp_as_async */
767     (reprfunc)func_repr,                        /* tp_repr */
768     0,                                          /* tp_as_number */
769     0,                                          /* tp_as_sequence */
770     0,                                          /* tp_as_mapping */
771     0,                                          /* tp_hash */
772     PyVectorcall_Call,                          /* tp_call */
773     0,                                          /* tp_str */
774     0,                                          /* tp_getattro */
775     0,                                          /* tp_setattro */
776     0,                                          /* tp_as_buffer */
777     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
778     Py_TPFLAGS_HAVE_VECTORCALL |
779     Py_TPFLAGS_METHOD_DESCRIPTOR,               /* tp_flags */
780     func_new__doc__,                            /* tp_doc */
781     (traverseproc)func_traverse,                /* tp_traverse */
782     (inquiry)func_clear,                        /* tp_clear */
783     0,                                          /* tp_richcompare */
784     offsetof(PyFunctionObject, func_weakreflist), /* tp_weaklistoffset */
785     0,                                          /* tp_iter */
786     0,                                          /* tp_iternext */
787     0,                                          /* tp_methods */
788     func_memberlist,                            /* tp_members */
789     func_getsetlist,                            /* tp_getset */
790     0,                                          /* tp_base */
791     0,                                          /* tp_dict */
792     func_descr_get,                             /* tp_descr_get */
793     0,                                          /* tp_descr_set */
794     offsetof(PyFunctionObject, func_dict),      /* tp_dictoffset */
795     0,                                          /* tp_init */
796     0,                                          /* tp_alloc */
797     func_new,                                   /* tp_new */
798 };
799 
800 
801 static int
functools_copy_attr(PyObject * wrapper,PyObject * wrapped,PyObject * name)802 functools_copy_attr(PyObject *wrapper, PyObject *wrapped, PyObject *name)
803 {
804     PyObject *value = PyObject_GetAttr(wrapped, name);
805     if (value == NULL) {
806         if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
807             PyErr_Clear();
808             return 0;
809         }
810         return -1;
811     }
812 
813     int res = PyObject_SetAttr(wrapper, name, value);
814     Py_DECREF(value);
815     return res;
816 }
817 
818 // Similar to functools.wraps(wrapper, wrapped)
819 static int
functools_wraps(PyObject * wrapper,PyObject * wrapped)820 functools_wraps(PyObject *wrapper, PyObject *wrapped)
821 {
822 #define COPY_ATTR(ATTR) \
823     do { \
824         if (functools_copy_attr(wrapper, wrapped, &_Py_ID(ATTR)) < 0) { \
825             return -1; \
826         } \
827     } while (0) \
828 
829     COPY_ATTR(__module__);
830     COPY_ATTR(__name__);
831     COPY_ATTR(__qualname__);
832     COPY_ATTR(__doc__);
833     COPY_ATTR(__annotations__);
834     return 0;
835 
836 #undef COPY_ATTR
837 }
838 
839 
840 /* Class method object */
841 
842 /* A class method receives the class as implicit first argument,
843    just like an instance method receives the instance.
844    To declare a class method, use this idiom:
845 
846      class C:
847          @classmethod
848          def f(cls, arg1, arg2, argN):
849              ...
850 
851    It can be called either on the class (e.g. C.f()) or on an instance
852    (e.g. C().f()); the instance is ignored except for its class.
853    If a class method is called for a derived class, the derived class
854    object is passed as the implied first argument.
855 
856    Class methods are different than C++ or Java static methods.
857    If you want those, see static methods below.
858 */
859 
860 typedef struct {
861     PyObject_HEAD
862     PyObject *cm_callable;
863     PyObject *cm_dict;
864 } classmethod;
865 
866 static void
cm_dealloc(classmethod * cm)867 cm_dealloc(classmethod *cm)
868 {
869     _PyObject_GC_UNTRACK((PyObject *)cm);
870     Py_XDECREF(cm->cm_callable);
871     Py_XDECREF(cm->cm_dict);
872     Py_TYPE(cm)->tp_free((PyObject *)cm);
873 }
874 
875 static int
cm_traverse(classmethod * cm,visitproc visit,void * arg)876 cm_traverse(classmethod *cm, visitproc visit, void *arg)
877 {
878     Py_VISIT(cm->cm_callable);
879     Py_VISIT(cm->cm_dict);
880     return 0;
881 }
882 
883 static int
cm_clear(classmethod * cm)884 cm_clear(classmethod *cm)
885 {
886     Py_CLEAR(cm->cm_callable);
887     Py_CLEAR(cm->cm_dict);
888     return 0;
889 }
890 
891 
892 static PyObject *
cm_descr_get(PyObject * self,PyObject * obj,PyObject * type)893 cm_descr_get(PyObject *self, PyObject *obj, PyObject *type)
894 {
895     classmethod *cm = (classmethod *)self;
896 
897     if (cm->cm_callable == NULL) {
898         PyErr_SetString(PyExc_RuntimeError,
899                         "uninitialized classmethod object");
900         return NULL;
901     }
902     if (type == NULL)
903         type = (PyObject *)(Py_TYPE(obj));
904     if (Py_TYPE(cm->cm_callable)->tp_descr_get != NULL) {
905         return Py_TYPE(cm->cm_callable)->tp_descr_get(cm->cm_callable, type,
906                                                       type);
907     }
908     return PyMethod_New(cm->cm_callable, type);
909 }
910 
911 static int
cm_init(PyObject * self,PyObject * args,PyObject * kwds)912 cm_init(PyObject *self, PyObject *args, PyObject *kwds)
913 {
914     classmethod *cm = (classmethod *)self;
915     PyObject *callable;
916 
917     if (!_PyArg_NoKeywords("classmethod", kwds))
918         return -1;
919     if (!PyArg_UnpackTuple(args, "classmethod", 1, 1, &callable))
920         return -1;
921     Py_INCREF(callable);
922     Py_XSETREF(cm->cm_callable, callable);
923 
924     if (functools_wraps((PyObject *)cm, cm->cm_callable) < 0) {
925         return -1;
926     }
927     return 0;
928 }
929 
930 static PyMemberDef cm_memberlist[] = {
931     {"__func__", T_OBJECT, offsetof(classmethod, cm_callable), READONLY},
932     {"__wrapped__", T_OBJECT, offsetof(classmethod, cm_callable), READONLY},
933     {NULL}  /* Sentinel */
934 };
935 
936 static PyObject *
cm_get___isabstractmethod__(classmethod * cm,void * closure)937 cm_get___isabstractmethod__(classmethod *cm, void *closure)
938 {
939     int res = _PyObject_IsAbstract(cm->cm_callable);
940     if (res == -1) {
941         return NULL;
942     }
943     else if (res) {
944         Py_RETURN_TRUE;
945     }
946     Py_RETURN_FALSE;
947 }
948 
949 static PyGetSetDef cm_getsetlist[] = {
950     {"__isabstractmethod__",
951      (getter)cm_get___isabstractmethod__, NULL, NULL, NULL},
952     {"__dict__", PyObject_GenericGetDict, PyObject_GenericSetDict, NULL, NULL},
953     {NULL} /* Sentinel */
954 };
955 
956 static PyObject*
cm_repr(classmethod * cm)957 cm_repr(classmethod *cm)
958 {
959     return PyUnicode_FromFormat("<classmethod(%R)>", cm->cm_callable);
960 }
961 
962 PyDoc_STRVAR(classmethod_doc,
963 "classmethod(function) -> method\n\
964 \n\
965 Convert a function to be a class method.\n\
966 \n\
967 A class method receives the class as implicit first argument,\n\
968 just like an instance method receives the instance.\n\
969 To declare a class method, use this idiom:\n\
970 \n\
971   class C:\n\
972       @classmethod\n\
973       def f(cls, arg1, arg2, argN):\n\
974           ...\n\
975 \n\
976 It can be called either on the class (e.g. C.f()) or on an instance\n\
977 (e.g. C().f()).  The instance is ignored except for its class.\n\
978 If a class method is called for a derived class, the derived class\n\
979 object is passed as the implied first argument.\n\
980 \n\
981 Class methods are different than C++ or Java static methods.\n\
982 If you want those, see the staticmethod builtin.");
983 
984 PyTypeObject PyClassMethod_Type = {
985     PyVarObject_HEAD_INIT(&PyType_Type, 0)
986     "classmethod",
987     sizeof(classmethod),
988     0,
989     (destructor)cm_dealloc,                     /* tp_dealloc */
990     0,                                          /* tp_vectorcall_offset */
991     0,                                          /* tp_getattr */
992     0,                                          /* tp_setattr */
993     0,                                          /* tp_as_async */
994     (reprfunc)cm_repr,                          /* tp_repr */
995     0,                                          /* tp_as_number */
996     0,                                          /* tp_as_sequence */
997     0,                                          /* tp_as_mapping */
998     0,                                          /* tp_hash */
999     0,                                          /* tp_call */
1000     0,                                          /* tp_str */
1001     0,                                          /* tp_getattro */
1002     0,                                          /* tp_setattro */
1003     0,                                          /* tp_as_buffer */
1004     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
1005     classmethod_doc,                            /* tp_doc */
1006     (traverseproc)cm_traverse,                  /* tp_traverse */
1007     (inquiry)cm_clear,                          /* tp_clear */
1008     0,                                          /* tp_richcompare */
1009     0,                                          /* tp_weaklistoffset */
1010     0,                                          /* tp_iter */
1011     0,                                          /* tp_iternext */
1012     0,                                          /* tp_methods */
1013     cm_memberlist,              /* tp_members */
1014     cm_getsetlist,                              /* tp_getset */
1015     0,                                          /* tp_base */
1016     0,                                          /* tp_dict */
1017     cm_descr_get,                               /* tp_descr_get */
1018     0,                                          /* tp_descr_set */
1019     offsetof(classmethod, cm_dict),             /* tp_dictoffset */
1020     cm_init,                                    /* tp_init */
1021     PyType_GenericAlloc,                        /* tp_alloc */
1022     PyType_GenericNew,                          /* tp_new */
1023     PyObject_GC_Del,                            /* tp_free */
1024 };
1025 
1026 PyObject *
PyClassMethod_New(PyObject * callable)1027 PyClassMethod_New(PyObject *callable)
1028 {
1029     classmethod *cm = (classmethod *)
1030         PyType_GenericAlloc(&PyClassMethod_Type, 0);
1031     if (cm != NULL) {
1032         Py_INCREF(callable);
1033         cm->cm_callable = callable;
1034     }
1035     return (PyObject *)cm;
1036 }
1037 
1038 
1039 /* Static method object */
1040 
1041 /* A static method does not receive an implicit first argument.
1042    To declare a static method, use this idiom:
1043 
1044      class C:
1045          @staticmethod
1046          def f(arg1, arg2, argN):
1047              ...
1048 
1049    It can be called either on the class (e.g. C.f()) or on an instance
1050    (e.g. C().f()). Both the class and the instance are ignored, and
1051    neither is passed implicitly as the first argument to the method.
1052 
1053    Static methods in Python are similar to those found in Java or C++.
1054    For a more advanced concept, see class methods above.
1055 */
1056 
1057 typedef struct {
1058     PyObject_HEAD
1059     PyObject *sm_callable;
1060     PyObject *sm_dict;
1061 } staticmethod;
1062 
1063 static void
sm_dealloc(staticmethod * sm)1064 sm_dealloc(staticmethod *sm)
1065 {
1066     _PyObject_GC_UNTRACK((PyObject *)sm);
1067     Py_XDECREF(sm->sm_callable);
1068     Py_XDECREF(sm->sm_dict);
1069     Py_TYPE(sm)->tp_free((PyObject *)sm);
1070 }
1071 
1072 static int
sm_traverse(staticmethod * sm,visitproc visit,void * arg)1073 sm_traverse(staticmethod *sm, visitproc visit, void *arg)
1074 {
1075     Py_VISIT(sm->sm_callable);
1076     Py_VISIT(sm->sm_dict);
1077     return 0;
1078 }
1079 
1080 static int
sm_clear(staticmethod * sm)1081 sm_clear(staticmethod *sm)
1082 {
1083     Py_CLEAR(sm->sm_callable);
1084     Py_CLEAR(sm->sm_dict);
1085     return 0;
1086 }
1087 
1088 static PyObject *
sm_descr_get(PyObject * self,PyObject * obj,PyObject * type)1089 sm_descr_get(PyObject *self, PyObject *obj, PyObject *type)
1090 {
1091     staticmethod *sm = (staticmethod *)self;
1092 
1093     if (sm->sm_callable == NULL) {
1094         PyErr_SetString(PyExc_RuntimeError,
1095                         "uninitialized staticmethod object");
1096         return NULL;
1097     }
1098     Py_INCREF(sm->sm_callable);
1099     return sm->sm_callable;
1100 }
1101 
1102 static int
sm_init(PyObject * self,PyObject * args,PyObject * kwds)1103 sm_init(PyObject *self, PyObject *args, PyObject *kwds)
1104 {
1105     staticmethod *sm = (staticmethod *)self;
1106     PyObject *callable;
1107 
1108     if (!_PyArg_NoKeywords("staticmethod", kwds))
1109         return -1;
1110     if (!PyArg_UnpackTuple(args, "staticmethod", 1, 1, &callable))
1111         return -1;
1112     Py_INCREF(callable);
1113     Py_XSETREF(sm->sm_callable, callable);
1114 
1115     if (functools_wraps((PyObject *)sm, sm->sm_callable) < 0) {
1116         return -1;
1117     }
1118     return 0;
1119 }
1120 
1121 static PyObject*
sm_call(PyObject * callable,PyObject * args,PyObject * kwargs)1122 sm_call(PyObject *callable, PyObject *args, PyObject *kwargs)
1123 {
1124     staticmethod *sm = (staticmethod *)callable;
1125     return PyObject_Call(sm->sm_callable, args, kwargs);
1126 }
1127 
1128 static PyMemberDef sm_memberlist[] = {
1129     {"__func__", T_OBJECT, offsetof(staticmethod, sm_callable), READONLY},
1130     {"__wrapped__", T_OBJECT, offsetof(staticmethod, sm_callable), READONLY},
1131     {NULL}  /* Sentinel */
1132 };
1133 
1134 static PyObject *
sm_get___isabstractmethod__(staticmethod * sm,void * closure)1135 sm_get___isabstractmethod__(staticmethod *sm, void *closure)
1136 {
1137     int res = _PyObject_IsAbstract(sm->sm_callable);
1138     if (res == -1) {
1139         return NULL;
1140     }
1141     else if (res) {
1142         Py_RETURN_TRUE;
1143     }
1144     Py_RETURN_FALSE;
1145 }
1146 
1147 static PyGetSetDef sm_getsetlist[] = {
1148     {"__isabstractmethod__",
1149      (getter)sm_get___isabstractmethod__, NULL, NULL, NULL},
1150     {"__dict__", PyObject_GenericGetDict, PyObject_GenericSetDict, NULL, NULL},
1151     {NULL} /* Sentinel */
1152 };
1153 
1154 static PyObject*
sm_repr(staticmethod * sm)1155 sm_repr(staticmethod *sm)
1156 {
1157     return PyUnicode_FromFormat("<staticmethod(%R)>", sm->sm_callable);
1158 }
1159 
1160 PyDoc_STRVAR(staticmethod_doc,
1161 "staticmethod(function) -> method\n\
1162 \n\
1163 Convert a function to be a static method.\n\
1164 \n\
1165 A static method does not receive an implicit first argument.\n\
1166 To declare a static method, use this idiom:\n\
1167 \n\
1168      class C:\n\
1169          @staticmethod\n\
1170          def f(arg1, arg2, argN):\n\
1171              ...\n\
1172 \n\
1173 It can be called either on the class (e.g. C.f()) or on an instance\n\
1174 (e.g. C().f()). Both the class and the instance are ignored, and\n\
1175 neither is passed implicitly as the first argument to the method.\n\
1176 \n\
1177 Static methods in Python are similar to those found in Java or C++.\n\
1178 For a more advanced concept, see the classmethod builtin.");
1179 
1180 PyTypeObject PyStaticMethod_Type = {
1181     PyVarObject_HEAD_INIT(&PyType_Type, 0)
1182     "staticmethod",
1183     sizeof(staticmethod),
1184     0,
1185     (destructor)sm_dealloc,                     /* tp_dealloc */
1186     0,                                          /* tp_vectorcall_offset */
1187     0,                                          /* tp_getattr */
1188     0,                                          /* tp_setattr */
1189     0,                                          /* tp_as_async */
1190     (reprfunc)sm_repr,                          /* tp_repr */
1191     0,                                          /* tp_as_number */
1192     0,                                          /* tp_as_sequence */
1193     0,                                          /* tp_as_mapping */
1194     0,                                          /* tp_hash */
1195     sm_call,                                    /* tp_call */
1196     0,                                          /* tp_str */
1197     0,                                          /* tp_getattro */
1198     0,                                          /* tp_setattro */
1199     0,                                          /* tp_as_buffer */
1200     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
1201     staticmethod_doc,                           /* tp_doc */
1202     (traverseproc)sm_traverse,                  /* tp_traverse */
1203     (inquiry)sm_clear,                          /* tp_clear */
1204     0,                                          /* tp_richcompare */
1205     0,                                          /* tp_weaklistoffset */
1206     0,                                          /* tp_iter */
1207     0,                                          /* tp_iternext */
1208     0,                                          /* tp_methods */
1209     sm_memberlist,              /* tp_members */
1210     sm_getsetlist,                              /* tp_getset */
1211     0,                                          /* tp_base */
1212     0,                                          /* tp_dict */
1213     sm_descr_get,                               /* tp_descr_get */
1214     0,                                          /* tp_descr_set */
1215     offsetof(staticmethod, sm_dict),            /* tp_dictoffset */
1216     sm_init,                                    /* tp_init */
1217     PyType_GenericAlloc,                        /* tp_alloc */
1218     PyType_GenericNew,                          /* tp_new */
1219     PyObject_GC_Del,                            /* tp_free */
1220 };
1221 
1222 PyObject *
PyStaticMethod_New(PyObject * callable)1223 PyStaticMethod_New(PyObject *callable)
1224 {
1225     staticmethod *sm = (staticmethod *)
1226         PyType_GenericAlloc(&PyStaticMethod_Type, 0);
1227     if (sm != NULL) {
1228         Py_INCREF(callable);
1229         sm->sm_callable = callable;
1230     }
1231     return (PyObject *)sm;
1232 }
1233