#include <stdbool.h>

#include "Python.h"

#include "code.h"

#include "opcode.h"

#include "structmember.h" // PyMemberDef

#include "pycore_code.h" // _PyCodeConstructor

#include "pycore_interp.h" // PyInterpreterState.co_extra_freefuncs

#include "pycore_pystate.h" // _PyInterpreterState_GET()

#include "pycore_tuple.h" // _PyTuple_ITEMS()

#include "clinic/codeobject.c.h"

/******************

* generic helpers

******************/

/* all_name_chars(s): true iff s matches [a-zA-Z0-9_]* */

static int

all_name_chars(PyObject *o)

{

const unsigned char *s, *e;

if (!PyUnicode_IS_ASCII(o))

return 0;

s = PyUnicode_1BYTE_DATA(o);

e = s + PyUnicode_GET_LENGTH(o);

for (; s != e; s++) {

if (!Py_ISALNUM(*s) && *s != '_')

return 0;

}

return 1;

}

static int

intern_strings(PyObject *tuple)

{

Py_ssize_t i;

for (i = PyTuple_GET_SIZE(tuple); --i >= 0; ) {

PyObject *v = PyTuple_GET_ITEM(tuple, i);

if (v == NULL || !PyUnicode_CheckExact(v)) {

PyErr_SetString(PyExc_SystemError,

"non-string found in code slot");

return -1;

}

PyUnicode_InternInPlace(&_PyTuple_ITEMS(tuple)[i]);

}

return 0;

}

/* Intern selected string constants */

static int

intern_string_constants(PyObject *tuple, int *modified)

{

for (Py_ssize_t i = PyTuple_GET_SIZE(tuple); --i >= 0; ) {

PyObject *v = PyTuple_GET_ITEM(tuple, i);

if (PyUnicode_CheckExact(v)) {

if (PyUnicode_READY(v) == -1) {

return -1;

}

if (all_name_chars(v)) {

PyObject *w = v;

PyUnicode_InternInPlace(&v);

if (w != v) {

PyTuple_SET_ITEM(tuple, i, v);

if (modified) {

*modified = 1;

}

}

}

}

else if (PyTuple_CheckExact(v)) {

if (intern_string_constants(v, NULL) < 0) {

return -1;

}

}

else if (PyFrozenSet_CheckExact(v)) {

PyObject *w = v;

PyObject *tmp = PySequence_Tuple(v);

if (tmp == NULL) {

return -1;

}

int tmp_modified = 0;

if (intern_string_constants(tmp, &tmp_modified) < 0) {

Py_DECREF(tmp);

return -1;

}

if (tmp_modified) {

v = PyFrozenSet_New(tmp);

if (v == NULL) {

Py_DECREF(tmp);

return -1;

}

PyTuple_SET_ITEM(tuple, i, v);

Py_DECREF(w);

if (modified) {

*modified = 1;

}

}

Py_DECREF(tmp);

}

}

return 0;

}

/* Return a shallow copy of a tuple that is

guaranteed to contain exact strings, by converting string subclasses

to exact strings and complaining if a non-string is found. */

static PyObject*

validate_and_copy_tuple(PyObject *tup)

{

PyObject *newtuple;

PyObject *item;

Py_ssize_t i, len;

len = PyTuple_GET_SIZE(tup);

newtuple = PyTuple_New(len);

if (newtuple == NULL)

return NULL;

for (i = 0; i < len; i++) {

item = PyTuple_GET_ITEM(tup, i);

if (PyUnicode_CheckExact(item)) {

Py_INCREF(item);

}

else if (!PyUnicode_Check(item)) {

PyErr_Format(

PyExc_TypeError,

"name tuples must contain only "

"strings, not '%.500s'",

Py_TYPE(item)->tp_name);

Py_DECREF(newtuple);

return NULL;

}

else {

item = _PyUnicode_Copy(item);

if (item == NULL) {

Py_DECREF(newtuple);

return NULL;

}

}

PyTuple_SET_ITEM(newtuple, i, item);

}

return newtuple;

}

/******************

* _PyCode_New()

******************/

// This is also used in compile.c.

void

_Py_set_localsplus_info(int offset, PyObject *name, _PyLocals_Kind kind,

PyObject *names, PyObject *kinds)

{

Py_INCREF(name);

PyTuple_SET_ITEM(names, offset, name);

_PyLocals_SetKind(kinds, offset, kind);

}

static void

get_localsplus_counts(PyObject *names, PyObject *kinds,

int *pnlocals, int *pnplaincellvars, int *pncellvars,

int *pnfreevars)

{

int nlocals = 0;

int nplaincellvars = 0;

int ncellvars = 0;

int nfreevars = 0;

Py_ssize_t nlocalsplus = PyTuple_GET_SIZE(names);

for (int i = 0; i < nlocalsplus; i++) {

_PyLocals_Kind kind = _PyLocals_GetKind(kinds, i);

if (kind & CO_FAST_LOCAL) {

nlocals += 1;

if (kind & CO_FAST_CELL) {

ncellvars += 1;

}

}

else if (kind & CO_FAST_CELL) {

ncellvars += 1;

nplaincellvars += 1;

}

else if (kind & CO_FAST_FREE) {

nfreevars += 1;

}

}

if (pnlocals != NULL) {

*pnlocals = nlocals;

}

if (pnplaincellvars != NULL) {

*pnplaincellvars = nplaincellvars;

}

if (pncellvars != NULL) {

*pncellvars = ncellvars;

}

if (pnfreevars != NULL) {

*pnfreevars = nfreevars;

}

}

static PyObject *

get_localsplus_names(PyCodeObject *co, _PyLocals_Kind kind, int num)

{

PyObject *names = PyTuple_New(num);

if (names == NULL) {

return NULL;

}

int index = 0;

for (int offset = 0; offset < co->co_nlocalsplus; offset++) {

_PyLocals_Kind k = _PyLocals_GetKind(co->co_localspluskinds, offset);

if ((k & kind) == 0) {

continue;

}

assert(index < num);

PyObject *name = PyTuple_GET_ITEM(co->co_localsplusnames, offset);

Py_INCREF(name);

PyTuple_SET_ITEM(names, index, name);

index += 1;

}

assert(index == num);

return names;

}

int

_PyCode_Validate(struct _PyCodeConstructor *con)

{

/* Check argument types */

if (con->argcount < con->posonlyargcount || con->posonlyargcount < 0 ||

con->kwonlyargcount < 0 ||

con->stacksize < 0 || con->flags < 0 ||

con->code == NULL || !PyBytes_Check(con->code) ||

con->consts == NULL || !PyTuple_Check(con->consts) ||

con->names == NULL || !PyTuple_Check(con->names) ||

con->localsplusnames == NULL || !PyTuple_Check(con->localsplusnames) ||

con->localspluskinds == NULL || !PyBytes_Check(con->localspluskinds) ||

PyTuple_GET_SIZE(con->localsplusnames)

!= PyBytes_GET_SIZE(con->localspluskinds) ||

con->name == NULL || !PyUnicode_Check(con->name) ||

con->qualname == NULL || !PyUnicode_Check(con->qualname) ||

con->filename == NULL || !PyUnicode_Check(con->filename) ||

con->linetable == NULL || !PyBytes_Check(con->linetable) ||

con->endlinetable == NULL ||

(con->endlinetable != Py_None && !PyBytes_Check(con->endlinetable)) ||

con->columntable == NULL ||

(con->columntable != Py_None && !PyBytes_Check(con->columntable)) ||

con->exceptiontable == NULL || !PyBytes_Check(con->exceptiontable)

) {

PyErr_BadInternalCall();

return -1;

}

/* Make sure that code is indexable with an int, this is

a long running assumption in ceval.c and many parts of

the interpreter. */

if (PyBytes_GET_SIZE(con->code) > INT_MAX) {

PyErr_SetString(PyExc_OverflowError,

"code: co_code larger than INT_MAX");

return -1;

}

if (PyBytes_GET_SIZE(con->code) % sizeof(_Py_CODEUNIT) != 0 ||

!_Py_IS_ALIGNED(PyBytes_AS_STRING(con->code), sizeof(_Py_CODEUNIT))

) {

PyErr_SetString(PyExc_ValueError, "code: co_code is malformed");

return -1;

}

/* Ensure that the co_varnames has enough names to cover the arg counts.

* Note that totalargs = nlocals - nplainlocals. We check nplainlocals

* here to avoid the possibility of overflow (however remote). */

int nlocals;

get_localsplus_counts(con->localsplusnames, con->localspluskinds,

&nlocals, NULL, NULL, NULL);

int nplainlocals = nlocals -

con->argcount -

con->kwonlyargcount -

((con->flags & CO_VARARGS) != 0) -

((con->flags & CO_VARKEYWORDS) != 0);

if (nplainlocals < 0) {

PyErr_SetString(PyExc_ValueError, "code: co_varnames is too small");

return -1;

}

return 0;

}

static void

init_code(PyCodeObject *co, struct _PyCodeConstructor *con)

{

int nlocalsplus = (int)PyTuple_GET_SIZE(con->localsplusnames);

int nlocals, nplaincellvars, ncellvars, nfreevars;

get_localsplus_counts(con->localsplusnames, con->localspluskinds,

&nlocals, &nplaincellvars, &ncellvars, &nfreevars);

Py_INCREF(con->filename);

co->co_filename = con->filename;

Py_INCREF(con->name);

co->co_name = con->name;

Py_INCREF(con->qualname);

co->co_qualname = con->qualname;

co->co_flags = con->flags;

Py_INCREF(con->code);

co->co_code = con->code;

co->co_firstinstr = (_Py_CODEUNIT *)PyBytes_AS_STRING(con->code);

co->co_firstlineno = con->firstlineno;

Py_INCREF(con->linetable);

co->co_linetable = con->linetable;

Py_INCREF(con->endlinetable);

co->co_endlinetable = con->endlinetable;

Py_INCREF(con->columntable);

co->co_columntable = con->columntable;

Py_INCREF(con->consts);

co->co_consts = con->consts;

Py_INCREF(con->names);

co->co_names = con->names;

Py_INCREF(con->localsplusnames);

co->co_localsplusnames = con->localsplusnames;

Py_INCREF(con->localspluskinds);

co->co_localspluskinds = con->localspluskinds;

co->co_argcount = con->argcount;

co->co_posonlyargcount = con->posonlyargcount;

co->co_kwonlyargcount = con->kwonlyargcount;

co->co_stacksize = con->stacksize;

Py_INCREF(con->exceptiontable);

co->co_exceptiontable = con->exceptiontable;

/* derived values */

co->co_nlocalsplus = nlocalsplus;

co->co_nlocals = nlocals;

co->co_nplaincellvars = nplaincellvars;

co->co_ncellvars = ncellvars;

co->co_nfreevars = nfreevars;

co->co_varnames = NULL;

co->co_cellvars = NULL;

co->co_freevars = NULL;

/* not set */

co->co_weakreflist = NULL;

co->co_extra = NULL;

co->co_warmup = QUICKENING_INITIAL_WARMUP_VALUE;

co->co_quickened = NULL;

}

/* The caller is responsible for ensuring that the given data is valid. */

PyCodeObject *

_PyCode_New(struct _PyCodeConstructor *con)

{

/* Ensure that strings are ready Unicode string */

if (PyUnicode_READY(con->name) < 0) {

return NULL;

}

if (PyUnicode_READY(con->qualname) < 0) {

return NULL;

}

if (PyUnicode_READY(con->filename) < 0) {

return NULL;

}

if (intern_strings(con->names) < 0) {

return NULL;

}

if (intern_string_constants(con->consts, NULL) < 0) {

return NULL;

}

if (intern_strings(con->localsplusnames) < 0) {

return NULL;

}

// Discard the endlinetable and columntable if we are opted out of debug

// ranges.

if (!_Py_GetConfig()->code_debug_ranges) {

con->endlinetable = Py_None;

con->columntable = Py_None;

}

PyCodeObject *co = PyObject_New(PyCodeObject, &PyCode_Type);

if (co == NULL) {

PyErr_NoMemory();

return NULL;

}

init_code(co, con);

return co;

}

/******************

* the legacy "constructors"

******************/

PyCodeObject *

PyCode_NewWithPosOnlyArgs(int argcount, int posonlyargcount, int kwonlyargcount,

int nlocals, int stacksize, int flags,

PyObject *code, PyObject *consts, PyObject *names,

PyObject *varnames, PyObject *freevars, PyObject *cellvars,

PyObject *filename, PyObject *name,

PyObject *qualname, int firstlineno,

PyObject *linetable, PyObject *endlinetable,

PyObject *columntable, PyObject *exceptiontable)

{

PyCodeObject *co = NULL;

PyObject *localsplusnames = NULL;

PyObject *localspluskinds = NULL;

if (varnames == NULL || !PyTuple_Check(varnames) ||

cellvars == NULL || !PyTuple_Check(cellvars) ||

freevars == NULL || !PyTuple_Check(freevars)

) {

PyErr_BadInternalCall();

return NULL;

}

// Set the "fast locals plus" info.

int nvarnames = (int)PyTuple_GET_SIZE(varnames);

int ncellvars = (int)PyTuple_GET_SIZE(cellvars);

int nfreevars = (int)PyTuple_GET_SIZE(freevars);

int nlocalsplus = nvarnames + ncellvars + nfreevars;

localsplusnames = PyTuple_New(nlocalsplus);

if (localsplusnames == NULL) {

goto error;

}

localspluskinds = PyBytes_FromStringAndSize(NULL, nlocalsplus);

if (localspluskinds == NULL) {

goto error;

}

int offset = 0;

for (int i = 0; i < nvarnames; i++, offset++) {

PyObject *name = PyTuple_GET_ITEM(varnames, i);

_Py_set_localsplus_info(offset, name, CO_FAST_LOCAL,

localsplusnames, localspluskinds);

}

for (int i = 0; i < ncellvars; i++, offset++) {

PyObject *name = PyTuple_GET_ITEM(cellvars, i);

int argoffset = -1;

for (int j = 0; j < nvarnames; j++) {

int cmp = PyUnicode_Compare(PyTuple_GET_ITEM(varnames, j),

name);

assert(!PyErr_Occurred());

if (cmp == 0) {

argoffset = j;

break;

}

}

if (argoffset >= 0) {

// Merge the localsplus indices.

nlocalsplus -= 1;

offset -= 1;

_PyLocals_Kind kind = _PyLocals_GetKind(localspluskinds, argoffset);

_PyLocals_SetKind(localspluskinds, argoffset, kind | CO_FAST_CELL);

continue;

}

_Py_set_localsplus_info(offset, name, CO_FAST_CELL,

localsplusnames, localspluskinds);

}

for (int i = 0; i < nfreevars; i++, offset++) {

PyObject *name = PyTuple_GET_ITEM(freevars, i);

_Py_set_localsplus_info(offset, name, CO_FAST_FREE,

localsplusnames, localspluskinds);

}

// If any cells were args then nlocalsplus will have shrunk.

if (nlocalsplus != PyTuple_GET_SIZE(localsplusnames)) {

if (_PyTuple_Resize(&localsplusnames, nlocalsplus) < 0

|| _PyBytes_Resize(&localspluskinds, nlocalsplus) < 0) {

goto error;

}

}

struct _PyCodeConstructor con = {

.filename = filename,

.name = name,

.qualname = qualname,

.flags = flags,

.code = code,

.firstlineno = firstlineno,

.linetable = linetable,

.endlinetable = endlinetable,

.columntable = columntable,

.consts = consts,

.names = names,

.localsplusnames = localsplusnames,

.localspluskinds = localspluskinds,

.argcount = argcount,

.posonlyargcount = posonlyargcount,

.kwonlyargcount = kwonlyargcount,

.stacksize = stacksize,

.exceptiontable = exceptiontable,

};

if (_PyCode_Validate(&con) < 0) {

goto error;

}

assert(PyBytes_GET_SIZE(code) % sizeof(_Py_CODEUNIT) == 0);

assert(_Py_IS_ALIGNED(PyBytes_AS_STRING(code), sizeof(_Py_CODEUNIT)));

if (nlocals != PyTuple_GET_SIZE(varnames)) {

PyErr_SetString(PyExc_ValueError,

"code: co_nlocals != len(co_varnames)");

goto error;

}

co = _PyCode_New(&con);

if (co == NULL) {

goto error;

}

Py_INCREF(varnames);

co->co_varnames = varnames;

Py_INCREF(cellvars);

co->co_cellvars = cellvars;

Py_INCREF(freevars);

co->co_freevars = freevars;

error:

Py_XDECREF(localsplusnames);

Py_XDECREF(localspluskinds);

return co;

}

PyCodeObject *

PyCode_New(int argcount, int kwonlyargcount,

int nlocals, int stacksize, int flags,

PyObject *code, PyObject *consts, PyObject *names,

PyObject *varnames, PyObject *freevars, PyObject *cellvars,

PyObject *filename, PyObject *name, PyObject *qualname,

int firstlineno, PyObject *linetable, PyObject *endlinetable,

PyObject *columntable, PyObject *exceptiontable)

{

return PyCode_NewWithPosOnlyArgs(argcount, 0, kwonlyargcount, nlocals,

stacksize, flags, code, consts, names,

varnames, freevars, cellvars, filename,

name, qualname, firstlineno, linetable,

endlinetable, columntable, exceptiontable);

}

PyCodeObject *

PyCode_NewEmpty(const char *filename, const char *funcname, int firstlineno)

{

PyObject *nulltuple = NULL;

PyObject *filename_ob = NULL;

PyObject *funcname_ob = NULL;

PyCodeObject *result = NULL;

nulltuple = PyTuple_New(0);

if (nulltuple == NULL) {

goto failed;

}

funcname_ob = PyUnicode_FromString(funcname);

if (funcname_ob == NULL) {

goto failed;

}

filename_ob = PyUnicode_DecodeFSDefault(filename);

if (filename_ob == NULL) {

goto failed;

}

#define emptystring (PyObject *)&_Py_SINGLETON(bytes_empty)

struct _PyCodeConstructor con = {

.filename = filename_ob,

.name = funcname_ob,

.qualname = funcname_ob,

.code = emptystring,

.firstlineno = firstlineno,

.linetable = emptystring,

.endlinetable = emptystring,

.columntable = emptystring,

.consts = nulltuple,

.names = nulltuple,

.localsplusnames = nulltuple,

.localspluskinds = emptystring,

.exceptiontable = emptystring,

};

result = _PyCode_New(&con);

failed:

Py_XDECREF(nulltuple);

Py_XDECREF(funcname_ob);

Py_XDECREF(filename_ob);

return result;

}

/******************

* source location tracking (co_lines/co_positions)

******************/

/* Use co_linetable to compute the line number from a bytecode index, addrq. See

lnotab_notes.txt for the details of the lnotab representation.

*/

int

PyCode_Addr2Line(PyCodeObject *co, int addrq)

{

if (addrq < 0) {

return co->co_firstlineno;

}

assert(addrq >= 0 && addrq < PyBytes_GET_SIZE(co->co_code));

PyCodeAddressRange bounds;

_PyCode_InitAddressRange(co, &bounds);

return _PyCode_CheckLineNumber(addrq, &bounds);

}

int

PyCode_Addr2Location(PyCodeObject *co, int addrq,

int *start_line, int *start_column,

int *end_line, int *end_column)

{

*start_line = PyCode_Addr2Line(co, addrq);

*start_column = _PyCode_Addr2Offset(co, addrq);

*end_line = _PyCode_Addr2EndLine(co, addrq);

*end_column = _PyCode_Addr2EndOffset(co, addrq);

return 1;

}

int

_PyCode_Addr2EndLine(PyCodeObject* co, int addrq)

{

if (addrq < 0) {

return co->co_firstlineno;

}

else if (co->co_endlinetable == Py_None) {

return -1;

}

assert(addrq >= 0 && addrq < PyBytes_GET_SIZE(co->co_code));

PyCodeAddressRange bounds;

_PyCode_InitEndAddressRange(co, &bounds);

return _PyCode_CheckLineNumber(addrq, &bounds);

}

int

_PyCode_Addr2Offset(PyCodeObject* co, int addrq)

{

if (co->co_columntable == Py_None || addrq < 0) {

return -1;

}

addrq /= sizeof(_Py_CODEUNIT);

if (addrq*2 >= PyBytes_GET_SIZE(co->co_columntable)) {

return -1;

}

unsigned char* bytes = (unsigned char*)PyBytes_AS_STRING(co->co_columntable);

return bytes[addrq*2] - 1;

}

int

_PyCode_Addr2EndOffset(PyCodeObject* co, int addrq)

{

if (co->co_columntable == Py_None || addrq < 0) {

return -1;

}

addrq /= sizeof(_Py_CODEUNIT);

if (addrq*2+1 >= PyBytes_GET_SIZE(co->co_columntable)) {

return -1;

}

unsigned char* bytes = (unsigned char*)PyBytes_AS_STRING(co->co_columntable);

return bytes[addrq*2+1] - 1;

}

void

_PyLineTable_InitAddressRange(const char *linetable, Py_ssize_t length, int firstlineno, PyCodeAddressRange *range)

{

range->opaque.lo_next = linetable;

range->opaque.limit = range->opaque.lo_next + length;

range->ar_start = -1;

range->ar_end = 0;

range->opaque.computed_line = firstlineno;

range->ar_line = -1;

}

int

_PyCode_InitAddressRange(PyCodeObject* co, PyCodeAddressRange *bounds)

{

const char *linetable = PyBytes_AS_STRING(co->co_linetable);

Py_ssize_t length = PyBytes_GET_SIZE(co->co_linetable);

_PyLineTable_InitAddressRange(linetable, length, co->co_firstlineno, bounds);

return bounds->ar_line;

}

int

_PyCode_InitEndAddressRange(PyCodeObject* co, PyCodeAddressRange* bounds)

{

char* linetable = PyBytes_AS_STRING(co->co_endlinetable);

Py_ssize_t length = PyBytes_GET_SIZE(co->co_endlinetable);

_PyLineTable_InitAddressRange(linetable, length, co->co_firstlineno, bounds);

return bounds->ar_line;

}

/* Update *bounds to describe the first and one-past-the-last instructions in

the same line as lasti. Return the number of that line, or -1 if lasti is out of bounds. */

int

_PyCode_CheckLineNumber(int lasti, PyCodeAddressRange *bounds)

{

while (bounds->ar_end <= lasti) {

if (!_PyLineTable_NextAddressRange(bounds)) {

return -1;

}

}

while (bounds->ar_start > lasti) {

if (!_PyLineTable_PreviousAddressRange(bounds)) {

return -1;

}

}

return bounds->ar_line;

}

static void

retreat(PyCodeAddressRange *bounds)

{

int ldelta = ((signed char *)bounds->opaque.lo_next)[-1];

if (ldelta == -128) {

ldelta = 0;

}

bounds->opaque.computed_line -= ldelta;

bounds->opaque.lo_next -= 2;

bounds->ar_end = bounds->ar_start;

bounds->ar_start -= ((unsigned char *)bounds->opaque.lo_next)[-2];

ldelta = ((signed char *)bounds->opaque.lo_next)[-1];

if (ldelta == -128) {

bounds->ar_line = -1;

}

else {

bounds->ar_line = bounds->opaque.computed_line;

}

}

static void

advance(PyCodeAddressRange *bounds)

{

bounds->ar_start = bounds->ar_end;

int delta = ((unsigned char *)bounds->opaque.lo_next)[0];

bounds->ar_end += delta;

int ldelta = ((signed char *)bounds->opaque.lo_next)[1];

bounds->opaque.lo_next += 2;

if (ldelta == -128) {

bounds->ar_line = -1;

}

else {

bounds->opaque.computed_line += ldelta;

bounds->ar_line = bounds->opaque.computed_line;

}

}

static inline int

at_end(PyCodeAddressRange *bounds) {

return bounds->opaque.lo_next >= bounds->opaque.limit;

}

int

_PyLineTable_PreviousAddressRange(PyCodeAddressRange *range)

{

if (range->ar_start <= 0) {

return 0;

}

retreat(range);

while (range->ar_start == range->ar_end) {

assert(range->ar_start > 0);

retreat(range);

}

return 1;

}

int

_PyLineTable_NextAddressRange(PyCodeAddressRange *range)

{

if (at_end(range)) {

return 0;

}

advance(range);

while (range->ar_start == range->ar_end) {

assert(!at_end(range));

advance(range);

}

return 1;

}

static int

emit_pair(PyObject **bytes, int *offset, int a, int b)

{

Py_ssize_t len = PyBytes_GET_SIZE(*bytes);

if (*offset + 2 >= len) {

if (_PyBytes_Resize(bytes, len * 2) < 0)

return 0;

}

unsigned char *lnotab = (unsigned char *) PyBytes_AS_STRING(*bytes);

lnotab += *offset;

*lnotab++ = a;

*lnotab++ = b;

*offset += 2;

return 1;

}

static int

emit_delta(PyObject **bytes, int bdelta, int ldelta, int *offset)

{

while (bdelta > 255) {

if (!emit_pair(bytes, offset, 255, 0)) {

return 0;

}

bdelta -= 255;

}

while (ldelta > 127) {

if (!emit_pair(bytes, offset, bdelta, 127)) {

return 0;

}

bdelta = 0;

ldelta -= 127;

}

while (ldelta < -128) {

if (!emit_pair(bytes, offset, bdelta, -128)) {

return 0;

}

bdelta = 0;

ldelta += 128;

}

return emit_pair(bytes, offset, bdelta, ldelta);

}

static PyObject *

decode_linetable(PyCodeObject *code)

{

PyCodeAddressRange bounds;

PyObject *bytes;

int table_offset = 0;

int code_offset = 0;

int line = code->co_firstlineno;

bytes = PyBytes_FromStringAndSize(NULL, 64);

if (bytes == NULL) {

return NULL;

}

_PyCode_InitAddressRange(code, &bounds);

while (_PyLineTable_NextAddressRange(&bounds)) {

if (bounds.opaque.computed_line != line) {

int bdelta = bounds.ar_start - code_offset;

int ldelta = bounds.opaque.computed_line - line;

if (!emit_delta(&bytes, bdelta, ldelta, &table_offset)) {

Py_DECREF(bytes);

return NULL;

}

code_offset = bounds.ar_start;

line = bounds.opaque.computed_line;

}

}

_PyBytes_Resize(&bytes, table_offset);

return bytes;

}

typedef struct {

PyObject_HEAD

PyCodeObject *li_code;

PyCodeAddressRange li_line;

char *li_end;

} lineiterator;

static void

lineiter_dealloc(lineiterator *li)

{

Py_DECREF(li->li_code);

Py_TYPE(li)->tp_free(li);

}

static PyObject *

lineiter_next(lineiterator *li)

{

PyCodeAddressRange *bounds = &li->li_line;

if (!_PyLineTable_NextAddressRange(bounds)) {

return NULL;

}

PyObject *start = NULL;

PyObject *end = NULL;

PyObject *line = NULL;

PyObject *result = PyTuple_New(3);

start = PyLong_FromLong(bounds->ar_start);

end = PyLong_FromLong(bounds->ar_end);

if (bounds->ar_line < 0) {

Py_INCREF(Py_None);

line = Py_None;

}

else {

line = PyLong_FromLong(bounds->ar_line);

}

if (result == NULL || start == NULL || end == NULL || line == NULL) {

goto error;

}

PyTuple_SET_ITEM(result, 0, start);

PyTuple_SET_ITEM(result, 1, end);

PyTuple_SET_ITEM(result, 2, line);

return result;

error:

Py_XDECREF(start);

Py_XDECREF(end);

Py_XDECREF(line);

Py_XDECREF(result);

return result;

}

static PyTypeObject LineIterator = {

PyVarObject_HEAD_INIT(&PyType_Type, 0)

"line_iterator", /* tp_name */

sizeof(lineiterator), /* tp_basicsize */

0, /* tp_itemsize */

/* methods */

(destructor)lineiter_dealloc, /* tp_dealloc */

0, /* tp_vectorcall_offset */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_as_async */

0, /* tp_repr */

0, /* tp_as_number */

0, /* tp_as_sequence */

0, /* tp_as_mapping */

0, /* tp_hash */

0, /* tp_call */

0, /* tp_str */

0, /* tp_getattro */

0, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */

0, /* tp_doc */

0, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

PyObject_SelfIter, /* tp_iter */

(iternextfunc)lineiter_next, /* tp_iternext */

0, /* tp_methods */

0, /* tp_members */

0, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

0, /* tp_descr_get */

0, /* tp_descr_set */

0, /* tp_dictoffset */

0, /* tp_init */

0, /* tp_alloc */

0, /* tp_new */

PyObject_Del, /* tp_free */

};

static lineiterator *

new_linesiterator(PyCodeObject *code)

{

lineiterator *li = (lineiterator *)PyType_GenericAlloc(&LineIterator, 0);

if (li == NULL) {

return NULL;

}

Py_INCREF(code);

li->li_code = code;

_PyCode_InitAddressRange(code, &li->li_line);

return li;

}

/* co_positions iterator object. */

typedef struct {

PyObject_HEAD

PyCodeObject* pi_code;

int pi_offset;

} positionsiterator;

static void

positionsiter_dealloc(positionsiterator* pi)

{

Py_DECREF(pi->pi_code);

Py_TYPE(pi)->tp_free(pi);

}

static PyObject*

_source_offset_converter(int* value) {

if (*value == -1) {

Py_RETURN_NONE;

}

return PyLong_FromLong(*value);

}

static PyObject*

positionsiter_next(positionsiterator* pi)

{

if (pi->pi_offset >= PyBytes_GET_SIZE(pi->pi_code->co_code)) {

return NULL;

}