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