#include <stdbool.h>

#include "Python.h"

#include "code.h"

#include "opcode.h"

#include "structmember.h" // PyMemberDef

#include "pycore_code.h" // _PyOpcache

#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"

typedef struct {

Py_ssize_t ce_size;

void *ce_extras[1];

} _PyCodeObjectExtra;

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;

}

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;

}

PyCodeObject *

PyCode_NewWithPosOnlyArgs(int argcount, int posonlyargcount, int kwonlyargcount,

PyObject *linetable)

{

PyCodeObject *co;

Py_ssize_t *cell2arg = NULL;

Py_ssize_t i, n_cellvars, n_varnames, total_args;

/* Check argument types */

if (argcount < posonlyargcount || posonlyargcount < 0 ||

kwonlyargcount < 0 || nlocals < 0 ||

stacksize < 0 || flags < 0 ||

code == NULL || !PyBytes_Check(code) ||

consts == NULL || !PyTuple_Check(consts) ||

names == NULL || !PyTuple_Check(names) ||

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

freevars == NULL || !PyTuple_Check(freevars) ||

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

name == NULL || !PyUnicode_Check(name) ||

filename == NULL || !PyUnicode_Check(filename) ||

linetable == NULL || !PyBytes_Check(linetable)) {

PyErr_BadInternalCall();

return NULL;

}

/* Ensure that strings are ready Unicode string */

if (PyUnicode_READY(name) < 0) {

return NULL;

}

if (PyUnicode_READY(filename) < 0) {

return NULL;

}

if (intern_strings(names) < 0) {

return NULL;

}

if (intern_strings(varnames) < 0) {

return NULL;

}

if (intern_strings(freevars) < 0) {

return NULL;

}

if (intern_strings(cellvars) < 0) {

return NULL;

}

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

return NULL;

}

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

if (PyBytes_GET_SIZE(code) > INT_MAX) {

PyErr_SetString(PyExc_OverflowError, "co_code larger than INT_MAX");

return NULL;

}

/* Check for any inner or outer closure references */

n_cellvars = PyTuple_GET_SIZE(cellvars);

if (!n_cellvars && !PyTuple_GET_SIZE(freevars)) {

flags |= CO_NOFREE;

} else {

flags &= ~CO_NOFREE;

}

n_varnames = PyTuple_GET_SIZE(varnames);

if (argcount <= n_varnames && kwonlyargcount <= n_varnames) {

/* Never overflows. */

total_args = (Py_ssize_t)argcount + (Py_ssize_t)kwonlyargcount +

((flags & CO_VARARGS) != 0) + ((flags & CO_VARKEYWORDS) != 0);

}

else {

total_args = n_varnames + 1;

}

if (total_args > n_varnames) {

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

return NULL;

}

/* Create mapping between cells and arguments if needed. */

if (n_cellvars) {

bool used_cell2arg = false;

cell2arg = PyMem_NEW(Py_ssize_t, n_cellvars);

if (cell2arg == NULL) {

PyErr_NoMemory();

return NULL;

}

/* Find cells which are also arguments. */

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

Py_ssize_t j;

PyObject *cell = PyTuple_GET_ITEM(cellvars, i);

cell2arg[i] = CO_CELL_NOT_AN_ARG;

for (j = 0; j < total_args; j++) {

PyObject *arg = PyTuple_GET_ITEM(varnames, j);

int cmp = PyUnicode_Compare(cell, arg);

if (cmp == -1 && PyErr_Occurred()) {

PyMem_Free(cell2arg);

return NULL;

}

if (cmp == 0) {

cell2arg[i] = j;

used_cell2arg = true;

break;

}

}

}

if (!used_cell2arg) {

PyMem_Free(cell2arg);

cell2arg = NULL;

}

}

co = PyObject_New(PyCodeObject, &PyCode_Type);

if (co == NULL) {

if (cell2arg)

PyMem_Free(cell2arg);

return NULL;

}

co->co_argcount = argcount;

co->co_posonlyargcount = posonlyargcount;

co->co_kwonlyargcount = kwonlyargcount;

co->co_nlocals = nlocals;

co->co_stacksize = stacksize;

co->co_flags = flags;

Py_INCREF(code);

co->co_code = code;

Py_INCREF(consts);

co->co_consts = consts;

Py_INCREF(names);

co->co_names = names;

Py_INCREF(varnames);

co->co_varnames = varnames;

Py_INCREF(freevars);

co->co_freevars = freevars;

Py_INCREF(cellvars);

co->co_cellvars = cellvars;

co->co_cell2arg = cell2arg;

Py_INCREF(filename);

co->co_filename = filename;

Py_INCREF(name);

co->co_name = name;

co->co_firstlineno = firstlineno;

Py_INCREF(linetable);

co->co_linetable = linetable;

co->co_zombieframe = NULL;

co->co_weakreflist = NULL;

co->co_extra = NULL;

co->co_opcache_map = NULL;

co->co_opcache = NULL;

co->co_opcache_flag = 0;

co->co_opcache_size = 0;

return co;

}

PyCodeObject *

PyCode_New(int argcount, int kwonlyargcount,

PyObject *linetable)

{

return PyCode_NewWithPosOnlyArgs(argcount, 0, kwonlyargcount, nlocals,

stacksize, flags, code, consts, names,

varnames, freevars, cellvars, filename,

name, firstlineno, linetable);

}

_PyCode_InitOpcache(PyCodeObject *co)

{

Py_ssize_t co_size = PyBytes_Size(co->co_code) / sizeof(_Py_CODEUNIT);

co->co_opcache_map = (unsigned char *)PyMem_Calloc(co_size, 1);

if (co->co_opcache_map == NULL) {

return -1;

}

_Py_CODEUNIT *opcodes = (_Py_CODEUNIT*)PyBytes_AS_STRING(co->co_code);

Py_ssize_t opts = 0;

for (Py_ssize_t i = 0; i < co_size;) {

unsigned char opcode = _Py_OPCODE(opcodes[i]);

i++; // 'i' is now aligned to (next_instr - first_instr)

// TODO: LOAD_METHOD

if (opcode == LOAD_GLOBAL || opcode == LOAD_ATTR) {

opts++;

co->co_opcache_map[i] = (unsigned char)opts;

if (opts > 254) {

break;

}

}

}

if (opts) {

co->co_opcache = (_PyOpcache *)PyMem_Calloc(opts, sizeof(_PyOpcache));

if (co->co_opcache == NULL) {

PyMem_Free(co->co_opcache_map);

return -1;

}

}

else {

PyMem_Free(co->co_opcache_map);

co->co_opcache_map = NULL;

co->co_opcache = NULL;

}

co->co_opcache_size = (unsigned char)opts;

return 0;

}

PyCodeObject *

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

{

static PyObject *emptystring = NULL;

static PyObject *nulltuple = NULL;

PyObject *filename_ob = NULL;

PyObject *funcname_ob = NULL;

PyCodeObject *result = NULL;

if (emptystring == NULL) {

emptystring = PyBytes_FromString("");

if (emptystring == NULL)

goto failed;

}

if (nulltuple == 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;

result = PyCode_NewWithPosOnlyArgs(

0, /* argcount */

0, /* posonlyargcount */

0, /* kwonlyargcount */

0, /* nlocals */

0, /* stacksize */

0, /* flags */

emptystring, /* code */

nulltuple, /* consts */

nulltuple, /* names */

nulltuple, /* varnames */

nulltuple, /* freevars */

nulltuple, /* cellvars */

filename_ob, /* filename */

funcname_ob, /* name */

firstlineno, /* firstlineno */

emptystring /* linetable */

);

failed:

Py_XDECREF(funcname_ob);

Py_XDECREF(filename_ob);

return result;

}

#define OFF(x) offsetof(PyCodeObject, x)

static PyMemberDef code_memberlist[] = {

{"co_argcount", T_INT, OFF(co_argcount), READONLY},

{"co_posonlyargcount", T_INT, OFF(co_posonlyargcount), READONLY},

{"co_kwonlyargcount", T_INT, OFF(co_kwonlyargcount), READONLY},

{"co_nlocals", T_INT, OFF(co_nlocals), READONLY},

{"co_stacksize",T_INT, OFF(co_stacksize), READONLY},

{"co_flags", T_INT, OFF(co_flags), READONLY},

{"co_code", T_OBJECT, OFF(co_code), READONLY},

{"co_consts", T_OBJECT, OFF(co_consts), READONLY},

{"co_names", T_OBJECT, OFF(co_names), READONLY},

{"co_varnames", T_OBJECT, OFF(co_varnames), READONLY},

{"co_freevars", T_OBJECT, OFF(co_freevars), READONLY},

{"co_cellvars", T_OBJECT, OFF(co_cellvars), READONLY},

{"co_filename", T_OBJECT, OFF(co_filename), READONLY},

{"co_name", T_OBJECT, OFF(co_name), READONLY},

{"co_firstlineno", T_INT, OFF(co_firstlineno), READONLY},

{"co_linetable", T_OBJECT, OFF(co_linetable), READONLY},

{NULL} /* Sentinel */

};

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 *

code_getlnotab(PyCodeObject *code, void *closure)

{

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.ar_computed_line != line) {

int bdelta = bounds.ar_start - code_offset;

int ldelta = bounds.ar_computed_line - line;

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

Py_DECREF(bytes);

return NULL;

}

code_offset = bounds.ar_start;

line = bounds.ar_computed_line;

}

}

_PyBytes_Resize(&bytes, table_offset);

return bytes;

}

static PyGetSetDef code_getsetlist[] = {

{"co_lnotab", (getter)code_getlnotab, NULL, NULL},

{0}

};

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;

}

static PyObject *

code_new_impl(PyTypeObject *type, int argcount, int posonlyargcount,

PyObject *cellvars)

{

PyObject *co = NULL;

PyObject *ournames = NULL;

PyObject *ourvarnames = NULL;

PyObject *ourfreevars = NULL;

PyObject *ourcellvars = NULL;

if (PySys_Audit("code.__new__", "OOOiiiiii",

code, filename, name, argcount, posonlyargcount,

kwonlyargcount, nlocals, stacksize, flags) < 0) {

goto cleanup;

}

if (argcount < 0) {

PyErr_SetString(

PyExc_ValueError,

"code: argcount must not be negative");

goto cleanup;

}

if (posonlyargcount < 0) {

PyErr_SetString(

PyExc_ValueError,

"code: posonlyargcount must not be negative");

goto cleanup;

}

if (kwonlyargcount < 0) {

PyErr_SetString(

PyExc_ValueError,

"code: kwonlyargcount must not be negative");

goto cleanup;

}

if (nlocals < 0) {

PyErr_SetString(

PyExc_ValueError,

"code: nlocals must not be negative");

goto cleanup;

}

ournames = validate_and_copy_tuple(names);

if (ournames == NULL)

goto cleanup;

ourvarnames = validate_and_copy_tuple(varnames);

if (ourvarnames == NULL)

goto cleanup;

if (freevars)

ourfreevars = validate_and_copy_tuple(freevars);

else

ourfreevars = PyTuple_New(0);

if (ourfreevars == NULL)

goto cleanup;

if (cellvars)

ourcellvars = validate_and_copy_tuple(cellvars);

else

ourcellvars = PyTuple_New(0);

if (ourcellvars == NULL)

goto cleanup;

co = (PyObject *)PyCode_NewWithPosOnlyArgs(argcount, posonlyargcount,

kwonlyargcount,

nlocals, stacksize, flags,

code, consts, ournames,

ourvarnames, ourfreevars,

ourcellvars, filename,

name, firstlineno, linetable);

cleanup:

Py_XDECREF(ournames);

Py_XDECREF(ourvarnames);

Py_XDECREF(ourfreevars);

Py_XDECREF(ourcellvars);

return co;

}

static void

code_dealloc(PyCodeObject *co)

{

if (co->co_opcache != NULL) {

PyMem_Free(co->co_opcache);

}

if (co->co_opcache_map != NULL) {

PyMem_Free(co->co_opcache_map);

}

co->co_opcache_flag = 0;

co->co_opcache_size = 0;

if (co->co_extra != NULL) {

PyInterpreterState *interp = _PyInterpreterState_GET();

_PyCodeObjectExtra *co_extra = co->co_extra;

for (Py_ssize_t i = 0; i < co_extra->ce_size; i++) {

freefunc free_extra = interp->co_extra_freefuncs[i];

if (free_extra != NULL) {

free_extra(co_extra->ce_extras[i]);

}

}

PyMem_Free(co_extra);

}

Py_XDECREF(co->co_code);

Py_XDECREF(co->co_consts);

Py_XDECREF(co->co_names);

Py_XDECREF(co->co_varnames);

Py_XDECREF(co->co_freevars);

Py_XDECREF(co->co_cellvars);

Py_XDECREF(co->co_filename);

Py_XDECREF(co->co_name);

Py_XDECREF(co->co_linetable);

if (co->co_cell2arg != NULL)

PyMem_Free(co->co_cell2arg);

if (co->co_zombieframe != NULL)

PyObject_GC_Del(co->co_zombieframe);

if (co->co_weakreflist != NULL)

PyObject_ClearWeakRefs((PyObject*)co);

PyObject_Free(co);

}

static PyObject *

code_sizeof(PyCodeObject *co, PyObject *Py_UNUSED(args))

{

Py_ssize_t res = _PyObject_SIZE(Py_TYPE(co));

_PyCodeObjectExtra *co_extra = (_PyCodeObjectExtra*) co->co_extra;

if (co->co_cell2arg != NULL && co->co_cellvars != NULL) {

res += PyTuple_GET_SIZE(co->co_cellvars) * sizeof(Py_ssize_t);

}

if (co_extra != NULL) {

res += sizeof(_PyCodeObjectExtra) +

(co_extra->ce_size-1) * sizeof(co_extra->ce_extras[0]);

}

if (co->co_opcache != NULL) {

assert(co->co_opcache_map != NULL);

// co_opcache_map

res += PyBytes_GET_SIZE(co->co_code) / sizeof(_Py_CODEUNIT);

// co_opcache

res += co->co_opcache_size * sizeof(_PyOpcache);

}

return PyLong_FromSsize_t(res);

}

static PyObject *

code_replace_impl(PyCodeObject *self, int co_argcount,

PyObject *co_name, PyBytesObject *co_linetable)

{

#define CHECK_INT_ARG(ARG) \

if (ARG < 0) { \

PyErr_SetString(PyExc_ValueError, \

#ARG " must be a positive integer"); \

return NULL; \

}

CHECK_INT_ARG(co_argcount);

CHECK_INT_ARG(co_posonlyargcount);

CHECK_INT_ARG(co_kwonlyargcount);

CHECK_INT_ARG(co_nlocals);

CHECK_INT_ARG(co_stacksize);

CHECK_INT_ARG(co_flags);

CHECK_INT_ARG(co_firstlineno);

#undef CHECK_INT_ARG

if (PySys_Audit("code.__new__", "OOOiiiiii",

co_code, co_filename, co_name, co_argcount,

co_posonlyargcount, co_kwonlyargcount, co_nlocals,

co_stacksize, co_flags) < 0) {

return NULL;

}

return (PyObject *)PyCode_NewWithPosOnlyArgs(

co_argcount, co_posonlyargcount, co_kwonlyargcount, co_nlocals,

co_stacksize, co_flags, (PyObject*)co_code, co_consts, co_names,

co_varnames, co_freevars, co_cellvars, co_filename, co_name,

co_firstlineno, (PyObject*)co_linetable);

}

static PyObject *

code_repr(PyCodeObject *co)

{

int lineno;

if (co->co_firstlineno != 0)

lineno = co->co_firstlineno;

else

lineno = -1;

if (co->co_filename && PyUnicode_Check(co->co_filename)) {

return PyUnicode_FromFormat(

"<code object %U at %p, file \"%U\", line %d>",

co->co_name, co, co->co_filename, lineno);

} else {

return PyUnicode_FromFormat(

"<code object %U at %p, file ???, line %d>",

co->co_name, co, lineno);

}

}

_PyCode_ConstantKey(PyObject *op)

{

PyObject *key;

/* Py_None and Py_Ellipsis are singletons. */

if (op == Py_None || op == Py_Ellipsis

|| PyLong_CheckExact(op)

|| PyUnicode_CheckExact(op)

/* code_richcompare() uses _PyCode_ConstantKey() internally */

|| PyCode_Check(op))

{

/* Objects of these types are always different from object of other

Py_INCREF(op);

key = op;

}

else if (PyBool_Check(op) || PyBytes_CheckExact(op)) {

/* Make booleans different from integers 0 and 1.

key = PyTuple_Pack(2, Py_TYPE(op), op);

}

else if (PyFloat_CheckExact(op)) {

double d = PyFloat_AS_DOUBLE(op);

/* all we need is to make the tuple different in either the 0.0

if (d == 0.0 && copysign(1.0, d) < 0.0)

key = PyTuple_Pack(3, Py_TYPE(op), op, Py_None);

else

key = PyTuple_Pack(2, Py_TYPE(op), op);

}

else if (PyComplex_CheckExact(op)) {

Py_complex z;

int real_negzero, imag_negzero;

/* For the complex case we must make complex(x, 0.)

z = PyComplex_AsCComplex(op);

real_negzero = z.real == 0.0 && copysign(1.0, z.real) < 0.0;

imag_negzero = z.imag == 0.0 && copysign(1.0, z.imag) < 0.0;

/* use True, False and None singleton as tags for the real and imag

if (real_negzero && imag_negzero) {

key = PyTuple_Pack(3, Py_TYPE(op), op, Py_True);

}

else if (imag_negzero) {

key = PyTuple_Pack(3, Py_TYPE(op), op, Py_False);

}

else if (real_negzero) {

key = PyTuple_Pack(3, Py_TYPE(op), op, Py_None);

}

else {

key = PyTuple_Pack(2, Py_TYPE(op), op);

}

}

else if (PyTuple_CheckExact(op)) {

Py_ssize_t i, len;

PyObject *tuple;

len = PyTuple_GET_SIZE(op);

tuple = PyTuple_New(len);

if (tuple == NULL)

return NULL;

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

PyObject *item, *item_key;

item = PyTuple_GET_ITEM(op, i);

item_key = _PyCode_ConstantKey(item);

if (item_key == NULL) {

Py_DECREF(tuple);

return NULL;

}

PyTuple_SET_ITEM(tuple, i, item_key);

}

key = PyTuple_Pack(2, tuple, op);

Py_DECREF(tuple);

}

else if (PyFrozenSet_CheckExact(op)) {

Py_ssize_t pos = 0;

PyObject *item;

Py_hash_t hash;

Py_ssize_t i, len;

PyObject *tuple, *set;

len = PySet_GET_SIZE(op);

tuple = PyTuple_New(len);

if (tuple == NULL)

return NULL;

i = 0;

while (_PySet_NextEntry(op, &pos, &item, &hash)) {

PyObject *item_key;

item_key = _PyCode_ConstantKey(item);

if (item_key == NULL) {

Py_DECREF(tuple);

return NULL;

}

assert(i < len);

PyTuple_SET_ITEM(tuple, i, item_key);

i++;

}

set = PyFrozenSet_New(tuple);

Py_DECREF(tuple);

if (set == NULL)

return NULL;

key = PyTuple_Pack(2, set, op);

Py_DECREF(set);

return key;

}

else {

/* for other types, use the object identifier as a unique identifier

PyObject *obj_id = PyLong_FromVoidPtr(op);

if (obj_id == NULL)

return NULL;

key = PyTuple_Pack(2, obj_id, op);

Py_DECREF(obj_id);

}

return key;

}

static PyObject *

code_richcompare(PyObject *self, PyObject *other, int op)

{

PyCodeObject *co, *cp;

int eq;

PyObject *consts1, *consts2;

PyObject *res;

if ((op != Py_EQ && op != Py_NE) ||

!PyCode_Check(self) ||

!PyCode_Check(other)) {

Py_RETURN_NOTIMPLEMENTED;

}

co = (PyCodeObject *)self;

cp = (PyCodeObject *)other;

eq = PyObject_RichCompareBool(co->co_name, cp->co_name, Py_EQ);

if (!eq) goto unequal;

eq = co->co_argcount == cp->co_argcount;

if (!eq) goto unequal;

eq = co->co_posonlyargcount == cp->co_posonlyargcount;

if (!eq) goto unequal;

eq = co->co_kwonlyargcount == cp->co_kwonlyargcount;

if (!eq) goto unequal;

eq = co->co_nlocals == cp->co_nlocals;

if (!eq) goto unequal;

eq = co->co_flags == cp->co_flags;

if (!eq) goto unequal;

eq = co->co_firstlineno == cp->co_firstlineno;

if (!eq) goto unequal;

eq = PyObject_RichCompareBool(co->co_code, cp->co_code, Py_EQ);

if (eq <= 0) goto unequal;

/* compare constants */

consts1 = _PyCode_ConstantKey(co->co_consts);

if (!consts1)

return NULL;

consts2 = _PyCode_ConstantKey(cp->co_consts);

if (!consts2) {

Py_DECREF(consts1);

return NULL;

}

eq = PyObject_RichCompareBool(consts1, consts2, Py_EQ);

Py_DECREF(consts1);

Py_DECREF(consts2);

if (eq <= 0) goto unequal;

eq = PyObject_RichCompareBool(co->co_names, cp->co_names, Py_EQ);

if (eq <= 0) goto unequal;

eq = PyObject_RichCompareBool(co->co_varnames, cp->co_varnames, Py_EQ);

if (eq <= 0) goto unequal;

eq = PyObject_RichCompareBool(co->co_freevars, cp->co_freevars, Py_EQ);

if (eq <= 0) goto unequal;

eq = PyObject_RichCompareBool(co->co_cellvars, cp->co_cellvars, Py_EQ);

if (eq <= 0) goto unequal;

if (op == Py_EQ)

res = Py_True;

else

res = Py_False;

goto done;

unequal:

if (eq < 0)

return NULL;

if (op == Py_NE)

res = Py_True;

else

res = Py_False;

done:

Py_INCREF(res);

return res;

}

static Py_hash_t

code_hash(PyCodeObject *co)

{

Py_hash_t h, h0, h1, h2, h3, h4, h5, h6;

h0 = PyObject_Hash(co->co_name);

if (h0 == -1) return -1;

h1 = PyObject_Hash(co->co_code);

if (h1 == -1) return -1;

h2 = PyObject_Hash(co->co_consts);

if (h2 == -1) return -1;

h3 = PyObject_Hash(co->co_names);

if (h3 == -1) return -1;