1 | #include <stdbool.h> |
2 | |
3 | #include "Python.h" |
4 | #include "code.h" |
5 | #include "opcode.h" |
6 | #include "structmember.h" // PyMemberDef |
7 | #include "pycore_code.h" // _PyOpcache |
8 | #include "pycore_interp.h" // PyInterpreterState.co_extra_freefuncs |
9 | #include "pycore_pystate.h" // _PyInterpreterState_GET() |
10 | #include "pycore_tuple.h" // _PyTuple_ITEMS() |
11 | #include "clinic/codeobject.c.h" |
12 | |
13 | /* Holder for co_extra information */ |
14 | typedef struct { |
15 | Py_ssize_t ce_size; |
16 | void *[1]; |
17 | } ; |
18 | |
19 | /*[clinic input] |
20 | class code "PyCodeObject *" "&PyCode_Type" |
21 | [clinic start generated code]*/ |
22 | /*[clinic end generated code: output=da39a3ee5e6b4b0d input=78aa5d576683bb4b]*/ |
23 | |
24 | /* all_name_chars(s): true iff s matches [a-zA-Z0-9_]* */ |
25 | static int |
26 | all_name_chars(PyObject *o) |
27 | { |
28 | const unsigned char *s, *e; |
29 | |
30 | if (!PyUnicode_IS_ASCII(o)) |
31 | return 0; |
32 | |
33 | s = PyUnicode_1BYTE_DATA(o); |
34 | e = s + PyUnicode_GET_LENGTH(o); |
35 | for (; s != e; s++) { |
36 | if (!Py_ISALNUM(*s) && *s != '_') |
37 | return 0; |
38 | } |
39 | return 1; |
40 | } |
41 | |
42 | static int |
43 | intern_strings(PyObject *tuple) |
44 | { |
45 | Py_ssize_t i; |
46 | |
47 | for (i = PyTuple_GET_SIZE(tuple); --i >= 0; ) { |
48 | PyObject *v = PyTuple_GET_ITEM(tuple, i); |
49 | if (v == NULL || !PyUnicode_CheckExact(v)) { |
50 | PyErr_SetString(PyExc_SystemError, |
51 | "non-string found in code slot" ); |
52 | return -1; |
53 | } |
54 | PyUnicode_InternInPlace(&_PyTuple_ITEMS(tuple)[i]); |
55 | } |
56 | return 0; |
57 | } |
58 | |
59 | /* Intern selected string constants */ |
60 | static int |
61 | intern_string_constants(PyObject *tuple, int *modified) |
62 | { |
63 | for (Py_ssize_t i = PyTuple_GET_SIZE(tuple); --i >= 0; ) { |
64 | PyObject *v = PyTuple_GET_ITEM(tuple, i); |
65 | if (PyUnicode_CheckExact(v)) { |
66 | if (PyUnicode_READY(v) == -1) { |
67 | return -1; |
68 | } |
69 | |
70 | if (all_name_chars(v)) { |
71 | PyObject *w = v; |
72 | PyUnicode_InternInPlace(&v); |
73 | if (w != v) { |
74 | PyTuple_SET_ITEM(tuple, i, v); |
75 | if (modified) { |
76 | *modified = 1; |
77 | } |
78 | } |
79 | } |
80 | } |
81 | else if (PyTuple_CheckExact(v)) { |
82 | if (intern_string_constants(v, NULL) < 0) { |
83 | return -1; |
84 | } |
85 | } |
86 | else if (PyFrozenSet_CheckExact(v)) { |
87 | PyObject *w = v; |
88 | PyObject *tmp = PySequence_Tuple(v); |
89 | if (tmp == NULL) { |
90 | return -1; |
91 | } |
92 | int tmp_modified = 0; |
93 | if (intern_string_constants(tmp, &tmp_modified) < 0) { |
94 | Py_DECREF(tmp); |
95 | return -1; |
96 | } |
97 | if (tmp_modified) { |
98 | v = PyFrozenSet_New(tmp); |
99 | if (v == NULL) { |
100 | Py_DECREF(tmp); |
101 | return -1; |
102 | } |
103 | |
104 | PyTuple_SET_ITEM(tuple, i, v); |
105 | Py_DECREF(w); |
106 | if (modified) { |
107 | *modified = 1; |
108 | } |
109 | } |
110 | Py_DECREF(tmp); |
111 | } |
112 | } |
113 | return 0; |
114 | } |
115 | |
116 | PyCodeObject * |
117 | PyCode_NewWithPosOnlyArgs(int argcount, int posonlyargcount, int kwonlyargcount, |
118 | int nlocals, int stacksize, int flags, |
119 | PyObject *code, PyObject *consts, PyObject *names, |
120 | PyObject *varnames, PyObject *freevars, PyObject *cellvars, |
121 | PyObject *filename, PyObject *name, int firstlineno, |
122 | PyObject *linetable) |
123 | { |
124 | PyCodeObject *co; |
125 | Py_ssize_t *cell2arg = NULL; |
126 | Py_ssize_t i, n_cellvars, n_varnames, total_args; |
127 | |
128 | /* Check argument types */ |
129 | if (argcount < posonlyargcount || posonlyargcount < 0 || |
130 | kwonlyargcount < 0 || nlocals < 0 || |
131 | stacksize < 0 || flags < 0 || |
132 | code == NULL || !PyBytes_Check(code) || |
133 | consts == NULL || !PyTuple_Check(consts) || |
134 | names == NULL || !PyTuple_Check(names) || |
135 | varnames == NULL || !PyTuple_Check(varnames) || |
136 | freevars == NULL || !PyTuple_Check(freevars) || |
137 | cellvars == NULL || !PyTuple_Check(cellvars) || |
138 | name == NULL || !PyUnicode_Check(name) || |
139 | filename == NULL || !PyUnicode_Check(filename) || |
140 | linetable == NULL || !PyBytes_Check(linetable)) { |
141 | PyErr_BadInternalCall(); |
142 | return NULL; |
143 | } |
144 | |
145 | /* Ensure that strings are ready Unicode string */ |
146 | if (PyUnicode_READY(name) < 0) { |
147 | return NULL; |
148 | } |
149 | if (PyUnicode_READY(filename) < 0) { |
150 | return NULL; |
151 | } |
152 | |
153 | if (intern_strings(names) < 0) { |
154 | return NULL; |
155 | } |
156 | if (intern_strings(varnames) < 0) { |
157 | return NULL; |
158 | } |
159 | if (intern_strings(freevars) < 0) { |
160 | return NULL; |
161 | } |
162 | if (intern_strings(cellvars) < 0) { |
163 | return NULL; |
164 | } |
165 | if (intern_string_constants(consts, NULL) < 0) { |
166 | return NULL; |
167 | } |
168 | |
169 | /* Make sure that code is indexable with an int, this is |
170 | a long running assumption in ceval.c and many parts of |
171 | the interpreter. */ |
172 | if (PyBytes_GET_SIZE(code) > INT_MAX) { |
173 | PyErr_SetString(PyExc_OverflowError, "co_code larger than INT_MAX" ); |
174 | return NULL; |
175 | } |
176 | |
177 | /* Check for any inner or outer closure references */ |
178 | n_cellvars = PyTuple_GET_SIZE(cellvars); |
179 | if (!n_cellvars && !PyTuple_GET_SIZE(freevars)) { |
180 | flags |= CO_NOFREE; |
181 | } else { |
182 | flags &= ~CO_NOFREE; |
183 | } |
184 | |
185 | n_varnames = PyTuple_GET_SIZE(varnames); |
186 | if (argcount <= n_varnames && kwonlyargcount <= n_varnames) { |
187 | /* Never overflows. */ |
188 | total_args = (Py_ssize_t)argcount + (Py_ssize_t)kwonlyargcount + |
189 | ((flags & CO_VARARGS) != 0) + ((flags & CO_VARKEYWORDS) != 0); |
190 | } |
191 | else { |
192 | total_args = n_varnames + 1; |
193 | } |
194 | if (total_args > n_varnames) { |
195 | PyErr_SetString(PyExc_ValueError, "code: varnames is too small" ); |
196 | return NULL; |
197 | } |
198 | |
199 | /* Create mapping between cells and arguments if needed. */ |
200 | if (n_cellvars) { |
201 | bool used_cell2arg = false; |
202 | cell2arg = PyMem_NEW(Py_ssize_t, n_cellvars); |
203 | if (cell2arg == NULL) { |
204 | PyErr_NoMemory(); |
205 | return NULL; |
206 | } |
207 | /* Find cells which are also arguments. */ |
208 | for (i = 0; i < n_cellvars; i++) { |
209 | Py_ssize_t j; |
210 | PyObject *cell = PyTuple_GET_ITEM(cellvars, i); |
211 | cell2arg[i] = CO_CELL_NOT_AN_ARG; |
212 | for (j = 0; j < total_args; j++) { |
213 | PyObject *arg = PyTuple_GET_ITEM(varnames, j); |
214 | int cmp = PyUnicode_Compare(cell, arg); |
215 | if (cmp == -1 && PyErr_Occurred()) { |
216 | PyMem_Free(cell2arg); |
217 | return NULL; |
218 | } |
219 | if (cmp == 0) { |
220 | cell2arg[i] = j; |
221 | used_cell2arg = true; |
222 | break; |
223 | } |
224 | } |
225 | } |
226 | if (!used_cell2arg) { |
227 | PyMem_Free(cell2arg); |
228 | cell2arg = NULL; |
229 | } |
230 | } |
231 | co = PyObject_New(PyCodeObject, &PyCode_Type); |
232 | if (co == NULL) { |
233 | if (cell2arg) |
234 | PyMem_Free(cell2arg); |
235 | return NULL; |
236 | } |
237 | co->co_argcount = argcount; |
238 | co->co_posonlyargcount = posonlyargcount; |
239 | co->co_kwonlyargcount = kwonlyargcount; |
240 | co->co_nlocals = nlocals; |
241 | co->co_stacksize = stacksize; |
242 | co->co_flags = flags; |
243 | Py_INCREF(code); |
244 | co->co_code = code; |
245 | Py_INCREF(consts); |
246 | co->co_consts = consts; |
247 | Py_INCREF(names); |
248 | co->co_names = names; |
249 | Py_INCREF(varnames); |
250 | co->co_varnames = varnames; |
251 | Py_INCREF(freevars); |
252 | co->co_freevars = freevars; |
253 | Py_INCREF(cellvars); |
254 | co->co_cellvars = cellvars; |
255 | co->co_cell2arg = cell2arg; |
256 | Py_INCREF(filename); |
257 | co->co_filename = filename; |
258 | Py_INCREF(name); |
259 | co->co_name = name; |
260 | co->co_firstlineno = firstlineno; |
261 | Py_INCREF(linetable); |
262 | co->co_linetable = linetable; |
263 | co->co_zombieframe = NULL; |
264 | co->co_weakreflist = NULL; |
265 | co->co_extra = NULL; |
266 | |
267 | co->co_opcache_map = NULL; |
268 | co->co_opcache = NULL; |
269 | co->co_opcache_flag = 0; |
270 | co->co_opcache_size = 0; |
271 | return co; |
272 | } |
273 | |
274 | PyCodeObject * |
275 | PyCode_New(int argcount, int kwonlyargcount, |
276 | int nlocals, int stacksize, int flags, |
277 | PyObject *code, PyObject *consts, PyObject *names, |
278 | PyObject *varnames, PyObject *freevars, PyObject *cellvars, |
279 | PyObject *filename, PyObject *name, int firstlineno, |
280 | PyObject *linetable) |
281 | { |
282 | return PyCode_NewWithPosOnlyArgs(argcount, 0, kwonlyargcount, nlocals, |
283 | stacksize, flags, code, consts, names, |
284 | varnames, freevars, cellvars, filename, |
285 | name, firstlineno, linetable); |
286 | } |
287 | |
288 | int |
289 | _PyCode_InitOpcache(PyCodeObject *co) |
290 | { |
291 | Py_ssize_t co_size = PyBytes_Size(co->co_code) / sizeof(_Py_CODEUNIT); |
292 | co->co_opcache_map = (unsigned char *)PyMem_Calloc(co_size, 1); |
293 | if (co->co_opcache_map == NULL) { |
294 | return -1; |
295 | } |
296 | |
297 | const _Py_CODEUNIT *opcodes = (_Py_CODEUNIT*)PyBytes_AS_STRING(co->co_code); |
298 | Py_ssize_t opts = 0; |
299 | |
300 | for (Py_ssize_t i = 0; i < co_size;) { |
301 | unsigned char opcode = _Py_OPCODE(opcodes[i]); |
302 | i++; // 'i' is now aligned to (next_instr - first_instr) |
303 | |
304 | // TODO: LOAD_METHOD |
305 | if (opcode == LOAD_GLOBAL || opcode == LOAD_ATTR) { |
306 | opts++; |
307 | co->co_opcache_map[i] = (unsigned char)opts; |
308 | if (opts > 254) { |
309 | break; |
310 | } |
311 | } |
312 | } |
313 | |
314 | if (opts) { |
315 | co->co_opcache = (_PyOpcache *)PyMem_Calloc(opts, sizeof(_PyOpcache)); |
316 | if (co->co_opcache == NULL) { |
317 | PyMem_Free(co->co_opcache_map); |
318 | return -1; |
319 | } |
320 | } |
321 | else { |
322 | PyMem_Free(co->co_opcache_map); |
323 | co->co_opcache_map = NULL; |
324 | co->co_opcache = NULL; |
325 | } |
326 | |
327 | co->co_opcache_size = (unsigned char)opts; |
328 | return 0; |
329 | } |
330 | |
331 | PyCodeObject * |
332 | PyCode_NewEmpty(const char *filename, const char *funcname, int firstlineno) |
333 | { |
334 | static PyObject *emptystring = NULL; |
335 | static PyObject *nulltuple = NULL; |
336 | PyObject *filename_ob = NULL; |
337 | PyObject *funcname_ob = NULL; |
338 | PyCodeObject *result = NULL; |
339 | if (emptystring == NULL) { |
340 | emptystring = PyBytes_FromString("" ); |
341 | if (emptystring == NULL) |
342 | goto failed; |
343 | } |
344 | if (nulltuple == NULL) { |
345 | nulltuple = PyTuple_New(0); |
346 | if (nulltuple == NULL) |
347 | goto failed; |
348 | } |
349 | funcname_ob = PyUnicode_FromString(funcname); |
350 | if (funcname_ob == NULL) |
351 | goto failed; |
352 | filename_ob = PyUnicode_DecodeFSDefault(filename); |
353 | if (filename_ob == NULL) |
354 | goto failed; |
355 | |
356 | result = PyCode_NewWithPosOnlyArgs( |
357 | 0, /* argcount */ |
358 | 0, /* posonlyargcount */ |
359 | 0, /* kwonlyargcount */ |
360 | 0, /* nlocals */ |
361 | 0, /* stacksize */ |
362 | 0, /* flags */ |
363 | emptystring, /* code */ |
364 | nulltuple, /* consts */ |
365 | nulltuple, /* names */ |
366 | nulltuple, /* varnames */ |
367 | nulltuple, /* freevars */ |
368 | nulltuple, /* cellvars */ |
369 | filename_ob, /* filename */ |
370 | funcname_ob, /* name */ |
371 | firstlineno, /* firstlineno */ |
372 | emptystring /* linetable */ |
373 | ); |
374 | |
375 | failed: |
376 | Py_XDECREF(funcname_ob); |
377 | Py_XDECREF(filename_ob); |
378 | return result; |
379 | } |
380 | |
381 | #define OFF(x) offsetof(PyCodeObject, x) |
382 | |
383 | static PyMemberDef code_memberlist[] = { |
384 | {"co_argcount" , T_INT, OFF(co_argcount), READONLY}, |
385 | {"co_posonlyargcount" , T_INT, OFF(co_posonlyargcount), READONLY}, |
386 | {"co_kwonlyargcount" , T_INT, OFF(co_kwonlyargcount), READONLY}, |
387 | {"co_nlocals" , T_INT, OFF(co_nlocals), READONLY}, |
388 | {"co_stacksize" ,T_INT, OFF(co_stacksize), READONLY}, |
389 | {"co_flags" , T_INT, OFF(co_flags), READONLY}, |
390 | {"co_code" , T_OBJECT, OFF(co_code), READONLY}, |
391 | {"co_consts" , T_OBJECT, OFF(co_consts), READONLY}, |
392 | {"co_names" , T_OBJECT, OFF(co_names), READONLY}, |
393 | {"co_varnames" , T_OBJECT, OFF(co_varnames), READONLY}, |
394 | {"co_freevars" , T_OBJECT, OFF(co_freevars), READONLY}, |
395 | {"co_cellvars" , T_OBJECT, OFF(co_cellvars), READONLY}, |
396 | {"co_filename" , T_OBJECT, OFF(co_filename), READONLY}, |
397 | {"co_name" , T_OBJECT, OFF(co_name), READONLY}, |
398 | {"co_firstlineno" , T_INT, OFF(co_firstlineno), READONLY}, |
399 | {"co_linetable" , T_OBJECT, OFF(co_linetable), READONLY}, |
400 | {NULL} /* Sentinel */ |
401 | }; |
402 | |
403 | static int |
404 | emit_pair(PyObject **bytes, int *offset, int a, int b) |
405 | { |
406 | Py_ssize_t len = PyBytes_GET_SIZE(*bytes); |
407 | if (*offset + 2 >= len) { |
408 | if (_PyBytes_Resize(bytes, len * 2) < 0) |
409 | return 0; |
410 | } |
411 | unsigned char *lnotab = (unsigned char *) PyBytes_AS_STRING(*bytes); |
412 | lnotab += *offset; |
413 | *lnotab++ = a; |
414 | *lnotab++ = b; |
415 | *offset += 2; |
416 | return 1; |
417 | } |
418 | |
419 | static int |
420 | emit_delta(PyObject **bytes, int bdelta, int ldelta, int *offset) |
421 | { |
422 | while (bdelta > 255) { |
423 | if (!emit_pair(bytes, offset, 255, 0)) { |
424 | return 0; |
425 | } |
426 | bdelta -= 255; |
427 | } |
428 | while (ldelta > 127) { |
429 | if (!emit_pair(bytes, offset, bdelta, 127)) { |
430 | return 0; |
431 | } |
432 | bdelta = 0; |
433 | ldelta -= 127; |
434 | } |
435 | while (ldelta < -128) { |
436 | if (!emit_pair(bytes, offset, bdelta, -128)) { |
437 | return 0; |
438 | } |
439 | bdelta = 0; |
440 | ldelta += 128; |
441 | } |
442 | return emit_pair(bytes, offset, bdelta, ldelta); |
443 | } |
444 | |
445 | static PyObject * |
446 | code_getlnotab(PyCodeObject *code, void *closure) |
447 | { |
448 | PyCodeAddressRange bounds; |
449 | PyObject *bytes; |
450 | int table_offset = 0; |
451 | int code_offset = 0; |
452 | int line = code->co_firstlineno; |
453 | bytes = PyBytes_FromStringAndSize(NULL, 64); |
454 | if (bytes == NULL) { |
455 | return NULL; |
456 | } |
457 | _PyCode_InitAddressRange(code, &bounds); |
458 | while (PyLineTable_NextAddressRange(&bounds)) { |
459 | if (bounds.opaque.computed_line != line) { |
460 | int bdelta = bounds.ar_start - code_offset; |
461 | int ldelta = bounds.opaque.computed_line - line; |
462 | if (!emit_delta(&bytes, bdelta, ldelta, &table_offset)) { |
463 | Py_DECREF(bytes); |
464 | return NULL; |
465 | } |
466 | code_offset = bounds.ar_start; |
467 | line = bounds.opaque.computed_line; |
468 | } |
469 | } |
470 | _PyBytes_Resize(&bytes, table_offset); |
471 | return bytes; |
472 | } |
473 | |
474 | |
475 | static PyGetSetDef code_getsetlist[] = { |
476 | {"co_lnotab" , (getter)code_getlnotab, NULL, NULL}, |
477 | {0} |
478 | }; |
479 | |
480 | |
481 | /* Helper for code_new: return a shallow copy of a tuple that is |
482 | guaranteed to contain exact strings, by converting string subclasses |
483 | to exact strings and complaining if a non-string is found. */ |
484 | static PyObject* |
485 | validate_and_copy_tuple(PyObject *tup) |
486 | { |
487 | PyObject *newtuple; |
488 | PyObject *item; |
489 | Py_ssize_t i, len; |
490 | |
491 | len = PyTuple_GET_SIZE(tup); |
492 | newtuple = PyTuple_New(len); |
493 | if (newtuple == NULL) |
494 | return NULL; |
495 | |
496 | for (i = 0; i < len; i++) { |
497 | item = PyTuple_GET_ITEM(tup, i); |
498 | if (PyUnicode_CheckExact(item)) { |
499 | Py_INCREF(item); |
500 | } |
501 | else if (!PyUnicode_Check(item)) { |
502 | PyErr_Format( |
503 | PyExc_TypeError, |
504 | "name tuples must contain only " |
505 | "strings, not '%.500s'" , |
506 | Py_TYPE(item)->tp_name); |
507 | Py_DECREF(newtuple); |
508 | return NULL; |
509 | } |
510 | else { |
511 | item = _PyUnicode_Copy(item); |
512 | if (item == NULL) { |
513 | Py_DECREF(newtuple); |
514 | return NULL; |
515 | } |
516 | } |
517 | PyTuple_SET_ITEM(newtuple, i, item); |
518 | } |
519 | |
520 | return newtuple; |
521 | } |
522 | |
523 | /*[clinic input] |
524 | @classmethod |
525 | code.__new__ as code_new |
526 | |
527 | argcount: int |
528 | posonlyargcount: int |
529 | kwonlyargcount: int |
530 | nlocals: int |
531 | stacksize: int |
532 | flags: int |
533 | codestring as code: object(subclass_of="&PyBytes_Type") |
534 | constants as consts: object(subclass_of="&PyTuple_Type") |
535 | names: object(subclass_of="&PyTuple_Type") |
536 | varnames: object(subclass_of="&PyTuple_Type") |
537 | filename: unicode |
538 | name: unicode |
539 | firstlineno: int |
540 | linetable: object(subclass_of="&PyBytes_Type") |
541 | freevars: object(subclass_of="&PyTuple_Type", c_default="NULL") = () |
542 | cellvars: object(subclass_of="&PyTuple_Type", c_default="NULL") = () |
543 | / |
544 | |
545 | Create a code object. Not for the faint of heart. |
546 | [clinic start generated code]*/ |
547 | |
548 | static PyObject * |
549 | code_new_impl(PyTypeObject *type, int argcount, int posonlyargcount, |
550 | int kwonlyargcount, int nlocals, int stacksize, int flags, |
551 | PyObject *code, PyObject *consts, PyObject *names, |
552 | PyObject *varnames, PyObject *filename, PyObject *name, |
553 | int firstlineno, PyObject *linetable, PyObject *freevars, |
554 | PyObject *cellvars) |
555 | /*[clinic end generated code: output=42c1839b082ba293 input=0ec80da632b99f57]*/ |
556 | { |
557 | PyObject *co = NULL; |
558 | PyObject *ournames = NULL; |
559 | PyObject *ourvarnames = NULL; |
560 | PyObject *ourfreevars = NULL; |
561 | PyObject *ourcellvars = NULL; |
562 | |
563 | if (PySys_Audit("code.__new__" , "OOOiiiiii" , |
564 | code, filename, name, argcount, posonlyargcount, |
565 | kwonlyargcount, nlocals, stacksize, flags) < 0) { |
566 | goto cleanup; |
567 | } |
568 | |
569 | if (argcount < 0) { |
570 | PyErr_SetString( |
571 | PyExc_ValueError, |
572 | "code: argcount must not be negative" ); |
573 | goto cleanup; |
574 | } |
575 | |
576 | if (posonlyargcount < 0) { |
577 | PyErr_SetString( |
578 | PyExc_ValueError, |
579 | "code: posonlyargcount must not be negative" ); |
580 | goto cleanup; |
581 | } |
582 | |
583 | if (kwonlyargcount < 0) { |
584 | PyErr_SetString( |
585 | PyExc_ValueError, |
586 | "code: kwonlyargcount must not be negative" ); |
587 | goto cleanup; |
588 | } |
589 | if (nlocals < 0) { |
590 | PyErr_SetString( |
591 | PyExc_ValueError, |
592 | "code: nlocals must not be negative" ); |
593 | goto cleanup; |
594 | } |
595 | |
596 | ournames = validate_and_copy_tuple(names); |
597 | if (ournames == NULL) |
598 | goto cleanup; |
599 | ourvarnames = validate_and_copy_tuple(varnames); |
600 | if (ourvarnames == NULL) |
601 | goto cleanup; |
602 | if (freevars) |
603 | ourfreevars = validate_and_copy_tuple(freevars); |
604 | else |
605 | ourfreevars = PyTuple_New(0); |
606 | if (ourfreevars == NULL) |
607 | goto cleanup; |
608 | if (cellvars) |
609 | ourcellvars = validate_and_copy_tuple(cellvars); |
610 | else |
611 | ourcellvars = PyTuple_New(0); |
612 | if (ourcellvars == NULL) |
613 | goto cleanup; |
614 | |
615 | co = (PyObject *)PyCode_NewWithPosOnlyArgs(argcount, posonlyargcount, |
616 | kwonlyargcount, |
617 | nlocals, stacksize, flags, |
618 | code, consts, ournames, |
619 | ourvarnames, ourfreevars, |
620 | ourcellvars, filename, |
621 | name, firstlineno, linetable); |
622 | cleanup: |
623 | Py_XDECREF(ournames); |
624 | Py_XDECREF(ourvarnames); |
625 | Py_XDECREF(ourfreevars); |
626 | Py_XDECREF(ourcellvars); |
627 | return co; |
628 | } |
629 | |
630 | static void |
631 | code_dealloc(PyCodeObject *co) |
632 | { |
633 | if (co->co_opcache != NULL) { |
634 | PyMem_Free(co->co_opcache); |
635 | } |
636 | if (co->co_opcache_map != NULL) { |
637 | PyMem_Free(co->co_opcache_map); |
638 | } |
639 | co->co_opcache_flag = 0; |
640 | co->co_opcache_size = 0; |
641 | |
642 | if (co->co_extra != NULL) { |
643 | PyInterpreterState *interp = _PyInterpreterState_GET(); |
644 | _PyCodeObjectExtra * = co->co_extra; |
645 | |
646 | for (Py_ssize_t i = 0; i < co_extra->ce_size; i++) { |
647 | freefunc = interp->co_extra_freefuncs[i]; |
648 | |
649 | if (free_extra != NULL) { |
650 | free_extra(co_extra->ce_extras[i]); |
651 | } |
652 | } |
653 | |
654 | PyMem_Free(co_extra); |
655 | } |
656 | |
657 | Py_XDECREF(co->co_code); |
658 | Py_XDECREF(co->co_consts); |
659 | Py_XDECREF(co->co_names); |
660 | Py_XDECREF(co->co_varnames); |
661 | Py_XDECREF(co->co_freevars); |
662 | Py_XDECREF(co->co_cellvars); |
663 | Py_XDECREF(co->co_filename); |
664 | Py_XDECREF(co->co_name); |
665 | Py_XDECREF(co->co_linetable); |
666 | if (co->co_cell2arg != NULL) |
667 | PyMem_Free(co->co_cell2arg); |
668 | if (co->co_zombieframe != NULL) |
669 | PyObject_GC_Del(co->co_zombieframe); |
670 | if (co->co_weakreflist != NULL) |
671 | PyObject_ClearWeakRefs((PyObject*)co); |
672 | PyObject_Free(co); |
673 | } |
674 | |
675 | static PyObject * |
676 | code_sizeof(PyCodeObject *co, PyObject *Py_UNUSED(args)) |
677 | { |
678 | Py_ssize_t res = _PyObject_SIZE(Py_TYPE(co)); |
679 | _PyCodeObjectExtra * = (_PyCodeObjectExtra*) co->co_extra; |
680 | |
681 | if (co->co_cell2arg != NULL && co->co_cellvars != NULL) { |
682 | res += PyTuple_GET_SIZE(co->co_cellvars) * sizeof(Py_ssize_t); |
683 | } |
684 | if (co_extra != NULL) { |
685 | res += sizeof(_PyCodeObjectExtra) + |
686 | (co_extra->ce_size-1) * sizeof(co_extra->ce_extras[0]); |
687 | } |
688 | if (co->co_opcache != NULL) { |
689 | assert(co->co_opcache_map != NULL); |
690 | // co_opcache_map |
691 | res += PyBytes_GET_SIZE(co->co_code) / sizeof(_Py_CODEUNIT); |
692 | // co_opcache |
693 | res += co->co_opcache_size * sizeof(_PyOpcache); |
694 | } |
695 | return PyLong_FromSsize_t(res); |
696 | } |
697 | |
698 | /*[clinic input] |
699 | code.replace |
700 | |
701 | * |
702 | co_argcount: int(c_default="self->co_argcount") = -1 |
703 | co_posonlyargcount: int(c_default="self->co_posonlyargcount") = -1 |
704 | co_kwonlyargcount: int(c_default="self->co_kwonlyargcount") = -1 |
705 | co_nlocals: int(c_default="self->co_nlocals") = -1 |
706 | co_stacksize: int(c_default="self->co_stacksize") = -1 |
707 | co_flags: int(c_default="self->co_flags") = -1 |
708 | co_firstlineno: int(c_default="self->co_firstlineno") = -1 |
709 | co_code: PyBytesObject(c_default="(PyBytesObject *)self->co_code") = None |
710 | co_consts: object(subclass_of="&PyTuple_Type", c_default="self->co_consts") = None |
711 | co_names: object(subclass_of="&PyTuple_Type", c_default="self->co_names") = None |
712 | co_varnames: object(subclass_of="&PyTuple_Type", c_default="self->co_varnames") = None |
713 | co_freevars: object(subclass_of="&PyTuple_Type", c_default="self->co_freevars") = None |
714 | co_cellvars: object(subclass_of="&PyTuple_Type", c_default="self->co_cellvars") = None |
715 | co_filename: unicode(c_default="self->co_filename") = None |
716 | co_name: unicode(c_default="self->co_name") = None |
717 | co_linetable: PyBytesObject(c_default="(PyBytesObject *)self->co_linetable") = None |
718 | |
719 | Return a copy of the code object with new values for the specified fields. |
720 | [clinic start generated code]*/ |
721 | |
722 | static PyObject * |
723 | code_replace_impl(PyCodeObject *self, int co_argcount, |
724 | int co_posonlyargcount, int co_kwonlyargcount, |
725 | int co_nlocals, int co_stacksize, int co_flags, |
726 | int co_firstlineno, PyBytesObject *co_code, |
727 | PyObject *co_consts, PyObject *co_names, |
728 | PyObject *co_varnames, PyObject *co_freevars, |
729 | PyObject *co_cellvars, PyObject *co_filename, |
730 | PyObject *co_name, PyBytesObject *co_linetable) |
731 | /*[clinic end generated code: output=50d77e668d3b449b input=a5f997b173d7f636]*/ |
732 | { |
733 | #define CHECK_INT_ARG(ARG) \ |
734 | if (ARG < 0) { \ |
735 | PyErr_SetString(PyExc_ValueError, \ |
736 | #ARG " must be a positive integer"); \ |
737 | return NULL; \ |
738 | } |
739 | |
740 | CHECK_INT_ARG(co_argcount); |
741 | CHECK_INT_ARG(co_posonlyargcount); |
742 | CHECK_INT_ARG(co_kwonlyargcount); |
743 | CHECK_INT_ARG(co_nlocals); |
744 | CHECK_INT_ARG(co_stacksize); |
745 | CHECK_INT_ARG(co_flags); |
746 | CHECK_INT_ARG(co_firstlineno); |
747 | |
748 | #undef CHECK_INT_ARG |
749 | |
750 | if (PySys_Audit("code.__new__" , "OOOiiiiii" , |
751 | co_code, co_filename, co_name, co_argcount, |
752 | co_posonlyargcount, co_kwonlyargcount, co_nlocals, |
753 | co_stacksize, co_flags) < 0) { |
754 | return NULL; |
755 | } |
756 | |
757 | return (PyObject *)PyCode_NewWithPosOnlyArgs( |
758 | co_argcount, co_posonlyargcount, co_kwonlyargcount, co_nlocals, |
759 | co_stacksize, co_flags, (PyObject*)co_code, co_consts, co_names, |
760 | co_varnames, co_freevars, co_cellvars, co_filename, co_name, |
761 | co_firstlineno, (PyObject*)co_linetable); |
762 | } |
763 | |
764 | static PyObject * |
765 | code_repr(PyCodeObject *co) |
766 | { |
767 | int lineno; |
768 | if (co->co_firstlineno != 0) |
769 | lineno = co->co_firstlineno; |
770 | else |
771 | lineno = -1; |
772 | if (co->co_filename && PyUnicode_Check(co->co_filename)) { |
773 | return PyUnicode_FromFormat( |
774 | "<code object %U at %p, file \"%U\", line %d>" , |
775 | co->co_name, co, co->co_filename, lineno); |
776 | } else { |
777 | return PyUnicode_FromFormat( |
778 | "<code object %U at %p, file ???, line %d>" , |
779 | co->co_name, co, lineno); |
780 | } |
781 | } |
782 | |
783 | PyObject* |
784 | _PyCode_ConstantKey(PyObject *op) |
785 | { |
786 | PyObject *key; |
787 | |
788 | /* Py_None and Py_Ellipsis are singletons. */ |
789 | if (op == Py_None || op == Py_Ellipsis |
790 | || PyLong_CheckExact(op) |
791 | || PyUnicode_CheckExact(op) |
792 | /* code_richcompare() uses _PyCode_ConstantKey() internally */ |
793 | || PyCode_Check(op)) |
794 | { |
795 | /* Objects of these types are always different from object of other |
796 | * type and from tuples. */ |
797 | Py_INCREF(op); |
798 | key = op; |
799 | } |
800 | else if (PyBool_Check(op) || PyBytes_CheckExact(op)) { |
801 | /* Make booleans different from integers 0 and 1. |
802 | * Avoid BytesWarning from comparing bytes with strings. */ |
803 | key = PyTuple_Pack(2, Py_TYPE(op), op); |
804 | } |
805 | else if (PyFloat_CheckExact(op)) { |
806 | double d = PyFloat_AS_DOUBLE(op); |
807 | /* all we need is to make the tuple different in either the 0.0 |
808 | * or -0.0 case from all others, just to avoid the "coercion". |
809 | */ |
810 | if (d == 0.0 && copysign(1.0, d) < 0.0) |
811 | key = PyTuple_Pack(3, Py_TYPE(op), op, Py_None); |
812 | else |
813 | key = PyTuple_Pack(2, Py_TYPE(op), op); |
814 | } |
815 | else if (PyComplex_CheckExact(op)) { |
816 | Py_complex z; |
817 | int real_negzero, imag_negzero; |
818 | /* For the complex case we must make complex(x, 0.) |
819 | different from complex(x, -0.) and complex(0., y) |
820 | different from complex(-0., y), for any x and y. |
821 | All four complex zeros must be distinguished.*/ |
822 | z = PyComplex_AsCComplex(op); |
823 | real_negzero = z.real == 0.0 && copysign(1.0, z.real) < 0.0; |
824 | imag_negzero = z.imag == 0.0 && copysign(1.0, z.imag) < 0.0; |
825 | /* use True, False and None singleton as tags for the real and imag |
826 | * sign, to make tuples different */ |
827 | if (real_negzero && imag_negzero) { |
828 | key = PyTuple_Pack(3, Py_TYPE(op), op, Py_True); |
829 | } |
830 | else if (imag_negzero) { |
831 | key = PyTuple_Pack(3, Py_TYPE(op), op, Py_False); |
832 | } |
833 | else if (real_negzero) { |
834 | key = PyTuple_Pack(3, Py_TYPE(op), op, Py_None); |
835 | } |
836 | else { |
837 | key = PyTuple_Pack(2, Py_TYPE(op), op); |
838 | } |
839 | } |
840 | else if (PyTuple_CheckExact(op)) { |
841 | Py_ssize_t i, len; |
842 | PyObject *tuple; |
843 | |
844 | len = PyTuple_GET_SIZE(op); |
845 | tuple = PyTuple_New(len); |
846 | if (tuple == NULL) |
847 | return NULL; |
848 | |
849 | for (i=0; i < len; i++) { |
850 | PyObject *item, *item_key; |
851 | |
852 | item = PyTuple_GET_ITEM(op, i); |
853 | item_key = _PyCode_ConstantKey(item); |
854 | if (item_key == NULL) { |
855 | Py_DECREF(tuple); |
856 | return NULL; |
857 | } |
858 | |
859 | PyTuple_SET_ITEM(tuple, i, item_key); |
860 | } |
861 | |
862 | key = PyTuple_Pack(2, tuple, op); |
863 | Py_DECREF(tuple); |
864 | } |
865 | else if (PyFrozenSet_CheckExact(op)) { |
866 | Py_ssize_t pos = 0; |
867 | PyObject *item; |
868 | Py_hash_t hash; |
869 | Py_ssize_t i, len; |
870 | PyObject *tuple, *set; |
871 | |
872 | len = PySet_GET_SIZE(op); |
873 | tuple = PyTuple_New(len); |
874 | if (tuple == NULL) |
875 | return NULL; |
876 | |
877 | i = 0; |
878 | while (_PySet_NextEntry(op, &pos, &item, &hash)) { |
879 | PyObject *item_key; |
880 | |
881 | item_key = _PyCode_ConstantKey(item); |
882 | if (item_key == NULL) { |
883 | Py_DECREF(tuple); |
884 | return NULL; |
885 | } |
886 | |
887 | assert(i < len); |
888 | PyTuple_SET_ITEM(tuple, i, item_key); |
889 | i++; |
890 | } |
891 | set = PyFrozenSet_New(tuple); |
892 | Py_DECREF(tuple); |
893 | if (set == NULL) |
894 | return NULL; |
895 | |
896 | key = PyTuple_Pack(2, set, op); |
897 | Py_DECREF(set); |
898 | return key; |
899 | } |
900 | else { |
901 | /* for other types, use the object identifier as a unique identifier |
902 | * to ensure that they are seen as unequal. */ |
903 | PyObject *obj_id = PyLong_FromVoidPtr(op); |
904 | if (obj_id == NULL) |
905 | return NULL; |
906 | |
907 | key = PyTuple_Pack(2, obj_id, op); |
908 | Py_DECREF(obj_id); |
909 | } |
910 | return key; |
911 | } |
912 | |
913 | static PyObject * |
914 | code_richcompare(PyObject *self, PyObject *other, int op) |
915 | { |
916 | PyCodeObject *co, *cp; |
917 | int eq; |
918 | PyObject *consts1, *consts2; |
919 | PyObject *res; |
920 | |
921 | if ((op != Py_EQ && op != Py_NE) || |
922 | !PyCode_Check(self) || |
923 | !PyCode_Check(other)) { |
924 | Py_RETURN_NOTIMPLEMENTED; |
925 | } |
926 | |
927 | co = (PyCodeObject *)self; |
928 | cp = (PyCodeObject *)other; |
929 | |
930 | eq = PyObject_RichCompareBool(co->co_name, cp->co_name, Py_EQ); |
931 | if (!eq) goto unequal; |
932 | eq = co->co_argcount == cp->co_argcount; |
933 | if (!eq) goto unequal; |
934 | eq = co->co_posonlyargcount == cp->co_posonlyargcount; |
935 | if (!eq) goto unequal; |
936 | eq = co->co_kwonlyargcount == cp->co_kwonlyargcount; |
937 | if (!eq) goto unequal; |
938 | eq = co->co_nlocals == cp->co_nlocals; |
939 | if (!eq) goto unequal; |
940 | eq = co->co_flags == cp->co_flags; |
941 | if (!eq) goto unequal; |
942 | eq = co->co_firstlineno == cp->co_firstlineno; |
943 | if (!eq) goto unequal; |
944 | eq = PyObject_RichCompareBool(co->co_code, cp->co_code, Py_EQ); |
945 | if (eq <= 0) goto unequal; |
946 | |
947 | /* compare constants */ |
948 | consts1 = _PyCode_ConstantKey(co->co_consts); |
949 | if (!consts1) |
950 | return NULL; |
951 | consts2 = _PyCode_ConstantKey(cp->co_consts); |
952 | if (!consts2) { |
953 | Py_DECREF(consts1); |
954 | return NULL; |
955 | } |
956 | eq = PyObject_RichCompareBool(consts1, consts2, Py_EQ); |
957 | Py_DECREF(consts1); |
958 | Py_DECREF(consts2); |
959 | if (eq <= 0) goto unequal; |
960 | |
961 | eq = PyObject_RichCompareBool(co->co_names, cp->co_names, Py_EQ); |
962 | if (eq <= 0) goto unequal; |
963 | eq = PyObject_RichCompareBool(co->co_varnames, cp->co_varnames, Py_EQ); |
964 | if (eq <= 0) goto unequal; |
965 | eq = PyObject_RichCompareBool(co->co_freevars, cp->co_freevars, Py_EQ); |
966 | if (eq <= 0) goto unequal; |
967 | eq = PyObject_RichCompareBool(co->co_cellvars, cp->co_cellvars, Py_EQ); |
968 | if (eq <= 0) goto unequal; |
969 | |
970 | if (op == Py_EQ) |
971 | res = Py_True; |
972 | else |
973 | res = Py_False; |
974 | goto done; |
975 | |
976 | unequal: |
977 | if (eq < 0) |
978 | return NULL; |
979 | if (op == Py_NE) |
980 | res = Py_True; |
981 | else |
982 | res = Py_False; |
983 | |
984 | done: |
985 | Py_INCREF(res); |
986 | return res; |
987 | } |
988 | |
989 | static Py_hash_t |
990 | code_hash(PyCodeObject *co) |
991 | { |
992 | Py_hash_t h, h0, h1, h2, h3, h4, h5, h6; |
993 | h0 = PyObject_Hash(co->co_name); |
994 | if (h0 == -1) return -1; |
995 | h1 = PyObject_Hash(co->co_code); |
996 | if (h1 == -1) return -1; |
997 | h2 = PyObject_Hash(co->co_consts); |
998 | if (h2 == -1) return -1; |
999 | h3 = PyObject_Hash(co->co_names); |
1000 | if (h3 == -1) return -1; |
1001 | h4 = PyObject_Hash(co->co_varnames); |
1002 | if (h4 == -1) return -1; |
1003 | h5 = PyObject_Hash(co->co_freevars); |
1004 | if (h5 == -1) return -1; |
1005 | h6 = PyObject_Hash(co->co_cellvars); |
1006 | if (h6 == -1) return -1; |
1007 | h = h0 ^ h1 ^ h2 ^ h3 ^ h4 ^ h5 ^ h6 ^ |
1008 | co->co_argcount ^ co->co_posonlyargcount ^ co->co_kwonlyargcount ^ |
1009 | co->co_nlocals ^ co->co_flags; |
1010 | if (h == -1) h = -2; |
1011 | return h; |
1012 | } |
1013 | |
1014 | typedef struct { |
1015 | PyObject_HEAD |
1016 | PyCodeObject *li_code; |
1017 | PyCodeAddressRange li_line; |
1018 | char *li_end; |
1019 | } lineiterator; |
1020 | |
1021 | |
1022 | static void |
1023 | lineiter_dealloc(lineiterator *li) |
1024 | { |
1025 | Py_DECREF(li->li_code); |
1026 | Py_TYPE(li)->tp_free(li); |
1027 | } |
1028 | |
1029 | static PyObject * |
1030 | lineiter_next(lineiterator *li) |
1031 | { |
1032 | PyCodeAddressRange *bounds = &li->li_line; |
1033 | if (!PyLineTable_NextAddressRange(bounds)) { |
1034 | return NULL; |
1035 | } |
1036 | PyObject *start = NULL; |
1037 | PyObject *end = NULL; |
1038 | PyObject *line = NULL; |
1039 | PyObject *result = PyTuple_New(3); |
1040 | start = PyLong_FromLong(bounds->ar_start); |
1041 | end = PyLong_FromLong(bounds->ar_end); |
1042 | if (bounds->ar_line < 0) { |
1043 | Py_INCREF(Py_None); |
1044 | line = Py_None; |
1045 | } |
1046 | else { |
1047 | line = PyLong_FromLong(bounds->ar_line); |
1048 | } |
1049 | if (result == NULL || start == NULL || end == NULL || line == NULL) { |
1050 | goto error; |
1051 | } |
1052 | PyTuple_SET_ITEM(result, 0, start); |
1053 | PyTuple_SET_ITEM(result, 1, end); |
1054 | PyTuple_SET_ITEM(result, 2, line); |
1055 | return result; |
1056 | error: |
1057 | Py_XDECREF(start); |
1058 | Py_XDECREF(end); |
1059 | Py_XDECREF(line); |
1060 | Py_XDECREF(result); |
1061 | return result; |
1062 | } |
1063 | |
1064 | static PyTypeObject LineIterator = { |
1065 | PyVarObject_HEAD_INIT(&PyType_Type, 0) |
1066 | "line_iterator" , /* tp_name */ |
1067 | sizeof(lineiterator), /* tp_basicsize */ |
1068 | 0, /* tp_itemsize */ |
1069 | /* methods */ |
1070 | (destructor)lineiter_dealloc, /* tp_dealloc */ |
1071 | 0, /* tp_vectorcall_offset */ |
1072 | 0, /* tp_getattr */ |
1073 | 0, /* tp_setattr */ |
1074 | 0, /* tp_as_async */ |
1075 | 0, /* tp_repr */ |
1076 | 0, /* tp_as_number */ |
1077 | 0, /* tp_as_sequence */ |
1078 | 0, /* tp_as_mapping */ |
1079 | 0, /* tp_hash */ |
1080 | 0, /* tp_call */ |
1081 | 0, /* tp_str */ |
1082 | 0, /* tp_getattro */ |
1083 | 0, /* tp_setattro */ |
1084 | 0, /* tp_as_buffer */ |
1085 | Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ |
1086 | 0, /* tp_doc */ |
1087 | 0, /* tp_traverse */ |
1088 | 0, /* tp_clear */ |
1089 | 0, /* tp_richcompare */ |
1090 | 0, /* tp_weaklistoffset */ |
1091 | PyObject_SelfIter, /* tp_iter */ |
1092 | (iternextfunc)lineiter_next, /* tp_iternext */ |
1093 | 0, /* tp_methods */ |
1094 | 0, /* tp_members */ |
1095 | 0, /* tp_getset */ |
1096 | 0, /* tp_base */ |
1097 | 0, /* tp_dict */ |
1098 | 0, /* tp_descr_get */ |
1099 | 0, /* tp_descr_set */ |
1100 | 0, /* tp_dictoffset */ |
1101 | 0, /* tp_init */ |
1102 | 0, /* tp_alloc */ |
1103 | 0, /* tp_new */ |
1104 | PyObject_Del, /* tp_free */ |
1105 | }; |
1106 | |
1107 | static PyObject * |
1108 | code_linesiterator(PyCodeObject *code, PyObject *Py_UNUSED(args)) |
1109 | { |
1110 | lineiterator *li = (lineiterator *)PyType_GenericAlloc(&LineIterator, 0); |
1111 | if (li == NULL) { |
1112 | return NULL; |
1113 | } |
1114 | Py_INCREF(code); |
1115 | li->li_code = code; |
1116 | _PyCode_InitAddressRange(code, &li->li_line); |
1117 | return (PyObject *)li; |
1118 | } |
1119 | |
1120 | static void |
1121 | retreat(PyCodeAddressRange *bounds) |
1122 | { |
1123 | int ldelta = ((signed char *)bounds->opaque.lo_next)[-1]; |
1124 | if (ldelta == -128) { |
1125 | ldelta = 0; |
1126 | } |
1127 | bounds->opaque.computed_line -= ldelta; |
1128 | bounds->opaque.lo_next -= 2; |
1129 | bounds->ar_end = bounds->ar_start; |
1130 | bounds->ar_start -= ((unsigned char *)bounds->opaque.lo_next)[-2]; |
1131 | ldelta = ((signed char *)bounds->opaque.lo_next)[-1]; |
1132 | if (ldelta == -128) { |
1133 | bounds->ar_line = -1; |
1134 | } |
1135 | else { |
1136 | bounds->ar_line = bounds->opaque.computed_line; |
1137 | } |
1138 | } |
1139 | |
1140 | static void |
1141 | advance(PyCodeAddressRange *bounds) |
1142 | { |
1143 | bounds->ar_start = bounds->ar_end; |
1144 | int delta = ((unsigned char *)bounds->opaque.lo_next)[0]; |
1145 | bounds->ar_end += delta; |
1146 | int ldelta = ((signed char *)bounds->opaque.lo_next)[1]; |
1147 | bounds->opaque.lo_next += 2; |
1148 | if (ldelta == -128) { |
1149 | bounds->ar_line = -1; |
1150 | } |
1151 | else { |
1152 | bounds->opaque.computed_line += ldelta; |
1153 | bounds->ar_line = bounds->opaque.computed_line; |
1154 | } |
1155 | } |
1156 | |
1157 | static inline int |
1158 | at_end(PyCodeAddressRange *bounds) { |
1159 | return bounds->opaque.lo_next >= bounds->opaque.limit; |
1160 | } |
1161 | |
1162 | int |
1163 | PyLineTable_PreviousAddressRange(PyCodeAddressRange *range) |
1164 | { |
1165 | if (range->ar_start <= 0) { |
1166 | return 0; |
1167 | } |
1168 | retreat(range); |
1169 | while (range->ar_start == range->ar_end) { |
1170 | assert(range->ar_start > 0); |
1171 | retreat(range); |
1172 | } |
1173 | return 1; |
1174 | } |
1175 | |
1176 | int |
1177 | PyLineTable_NextAddressRange(PyCodeAddressRange *range) |
1178 | { |
1179 | if (at_end(range)) { |
1180 | return 0; |
1181 | } |
1182 | advance(range); |
1183 | while (range->ar_start == range->ar_end) { |
1184 | assert(!at_end(range)); |
1185 | advance(range); |
1186 | } |
1187 | return 1; |
1188 | } |
1189 | |
1190 | |
1191 | /* XXX code objects need to participate in GC? */ |
1192 | |
1193 | static struct PyMethodDef code_methods[] = { |
1194 | {"__sizeof__" , (PyCFunction)code_sizeof, METH_NOARGS}, |
1195 | {"co_lines" , (PyCFunction)code_linesiterator, METH_NOARGS}, |
1196 | CODE_REPLACE_METHODDEF |
1197 | {NULL, NULL} /* sentinel */ |
1198 | }; |
1199 | |
1200 | PyTypeObject PyCode_Type = { |
1201 | PyVarObject_HEAD_INIT(&PyType_Type, 0) |
1202 | "code" , |
1203 | sizeof(PyCodeObject), |
1204 | 0, |
1205 | (destructor)code_dealloc, /* tp_dealloc */ |
1206 | 0, /* tp_vectorcall_offset */ |
1207 | 0, /* tp_getattr */ |
1208 | 0, /* tp_setattr */ |
1209 | 0, /* tp_as_async */ |
1210 | (reprfunc)code_repr, /* tp_repr */ |
1211 | 0, /* tp_as_number */ |
1212 | 0, /* tp_as_sequence */ |
1213 | 0, /* tp_as_mapping */ |
1214 | (hashfunc)code_hash, /* tp_hash */ |
1215 | 0, /* tp_call */ |
1216 | 0, /* tp_str */ |
1217 | PyObject_GenericGetAttr, /* tp_getattro */ |
1218 | 0, /* tp_setattro */ |
1219 | 0, /* tp_as_buffer */ |
1220 | Py_TPFLAGS_DEFAULT, /* tp_flags */ |
1221 | code_new__doc__, /* tp_doc */ |
1222 | 0, /* tp_traverse */ |
1223 | 0, /* tp_clear */ |
1224 | code_richcompare, /* tp_richcompare */ |
1225 | offsetof(PyCodeObject, co_weakreflist), /* tp_weaklistoffset */ |
1226 | 0, /* tp_iter */ |
1227 | 0, /* tp_iternext */ |
1228 | code_methods, /* tp_methods */ |
1229 | code_memberlist, /* tp_members */ |
1230 | code_getsetlist, /* tp_getset */ |
1231 | 0, /* tp_base */ |
1232 | 0, /* tp_dict */ |
1233 | 0, /* tp_descr_get */ |
1234 | 0, /* tp_descr_set */ |
1235 | 0, /* tp_dictoffset */ |
1236 | 0, /* tp_init */ |
1237 | 0, /* tp_alloc */ |
1238 | code_new, /* tp_new */ |
1239 | }; |
1240 | |
1241 | /* Use co_linetable to compute the line number from a bytecode index, addrq. See |
1242 | lnotab_notes.txt for the details of the lnotab representation. |
1243 | */ |
1244 | |
1245 | int |
1246 | PyCode_Addr2Line(PyCodeObject *co, int addrq) |
1247 | { |
1248 | if (addrq < 0) { |
1249 | return co->co_firstlineno; |
1250 | } |
1251 | assert(addrq >= 0 && addrq < PyBytes_GET_SIZE(co->co_code)); |
1252 | PyCodeAddressRange bounds; |
1253 | _PyCode_InitAddressRange(co, &bounds); |
1254 | return _PyCode_CheckLineNumber(addrq, &bounds); |
1255 | } |
1256 | |
1257 | void |
1258 | PyLineTable_InitAddressRange(const char *linetable, Py_ssize_t length, int firstlineno, PyCodeAddressRange *range) |
1259 | { |
1260 | range->opaque.lo_next = linetable; |
1261 | range->opaque.limit = range->opaque.lo_next + length; |
1262 | range->ar_start = -1; |
1263 | range->ar_end = 0; |
1264 | range->opaque.computed_line = firstlineno; |
1265 | range->ar_line = -1; |
1266 | } |
1267 | |
1268 | int |
1269 | _PyCode_InitAddressRange(PyCodeObject* co, PyCodeAddressRange *bounds) |
1270 | { |
1271 | const char *linetable = PyBytes_AS_STRING(co->co_linetable); |
1272 | Py_ssize_t length = PyBytes_GET_SIZE(co->co_linetable); |
1273 | PyLineTable_InitAddressRange(linetable, length, co->co_firstlineno, bounds); |
1274 | return bounds->ar_line; |
1275 | } |
1276 | |
1277 | /* Update *bounds to describe the first and one-past-the-last instructions in |
1278 | the same line as lasti. Return the number of that line, or -1 if lasti is out of bounds. */ |
1279 | int |
1280 | _PyCode_CheckLineNumber(int lasti, PyCodeAddressRange *bounds) |
1281 | { |
1282 | while (bounds->ar_end <= lasti) { |
1283 | if (!PyLineTable_NextAddressRange(bounds)) { |
1284 | return -1; |
1285 | } |
1286 | } |
1287 | while (bounds->ar_start > lasti) { |
1288 | if (!PyLineTable_PreviousAddressRange(bounds)) { |
1289 | return -1; |
1290 | } |
1291 | } |
1292 | return bounds->ar_line; |
1293 | } |
1294 | |
1295 | |
1296 | int |
1297 | (PyObject *code, Py_ssize_t index, void **) |
1298 | { |
1299 | if (!PyCode_Check(code)) { |
1300 | PyErr_BadInternalCall(); |
1301 | return -1; |
1302 | } |
1303 | |
1304 | PyCodeObject *o = (PyCodeObject*) code; |
1305 | _PyCodeObjectExtra * = (_PyCodeObjectExtra*) o->co_extra; |
1306 | |
1307 | if (co_extra == NULL || co_extra->ce_size <= index) { |
1308 | *extra = NULL; |
1309 | return 0; |
1310 | } |
1311 | |
1312 | *extra = co_extra->ce_extras[index]; |
1313 | return 0; |
1314 | } |
1315 | |
1316 | |
1317 | int |
1318 | (PyObject *code, Py_ssize_t index, void *) |
1319 | { |
1320 | PyInterpreterState *interp = _PyInterpreterState_GET(); |
1321 | |
1322 | if (!PyCode_Check(code) || index < 0 || |
1323 | index >= interp->co_extra_user_count) { |
1324 | PyErr_BadInternalCall(); |
1325 | return -1; |
1326 | } |
1327 | |
1328 | PyCodeObject *o = (PyCodeObject*) code; |
1329 | _PyCodeObjectExtra * = (_PyCodeObjectExtra *) o->co_extra; |
1330 | |
1331 | if (co_extra == NULL || co_extra->ce_size <= index) { |
1332 | Py_ssize_t i = (co_extra == NULL ? 0 : co_extra->ce_size); |
1333 | co_extra = PyMem_Realloc( |
1334 | co_extra, |
1335 | sizeof(_PyCodeObjectExtra) + |
1336 | (interp->co_extra_user_count-1) * sizeof(void*)); |
1337 | if (co_extra == NULL) { |
1338 | return -1; |
1339 | } |
1340 | for (; i < interp->co_extra_user_count; i++) { |
1341 | co_extra->ce_extras[i] = NULL; |
1342 | } |
1343 | co_extra->ce_size = interp->co_extra_user_count; |
1344 | o->co_extra = co_extra; |
1345 | } |
1346 | |
1347 | if (co_extra->ce_extras[index] != NULL) { |
1348 | freefunc free = interp->co_extra_freefuncs[index]; |
1349 | if (free != NULL) { |
1350 | free(co_extra->ce_extras[index]); |
1351 | } |
1352 | } |
1353 | |
1354 | co_extra->ce_extras[index] = extra; |
1355 | return 0; |
1356 | } |
1357 | |