#include "Python.h"

#include "pycore_ast.h" // PyAST_Check()

#include "pycore_code.h"

#include "pycore_compile.h"

#include "pycore_flowgraph.h" // _PyCfg_FromInstructionSequence()

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

#include "pycore_runtime.h" // _Py_ID()

#include "pycore_setobject.h" // _PySet_NextEntry()

#include "pycore_stats.h"

#include "pycore_tuple.h" // _PyTuple_FromPair

#include "pycore_unicodeobject.h" // _PyUnicode_EqualToASCIIString()

#include "cpython/code.h"

#include <stdbool.h>

#undef SUCCESS

#undef ERROR

#define SUCCESS 0

#define ERROR -1

#define RETURN_IF_ERROR(X) \

do { \

if ((X) == -1) { \

return ERROR; \

} \

} while (0)

typedef _Py_SourceLocation location;

typedef _PyJumpTargetLabel jump_target_label;

typedef _PyInstructionSequence instr_sequence;

typedef struct _PyCfgBuilder cfg_builder;

typedef _PyCompile_FBlockInfo fblockinfo;

typedef enum _PyCompile_FBlockType fblocktype;

struct compiler_unit {

};

typedef struct _PyCompiler {

} compiler;

static int

compiler_setup(compiler *c, mod_ty mod, PyObject *filename,

PyCompilerFlags *flags, int optimize, PyArena *arena,

PyObject *module)

{

PyCompilerFlags local_flags = _PyCompilerFlags_INIT;

c->c_const_cache = PyDict_New();

if (!c->c_const_cache) {

return ERROR;

}

c->c_stack = PyList_New(0);

if (!c->c_stack) {

return ERROR;

}

c->c_filename = Py_NewRef(filename);

if (!_PyFuture_FromAST(mod, filename, &c->c_future)) {

return ERROR;

}

c->c_module = Py_XNewRef(module);

if (!flags) {

flags = &local_flags;

}

int merged = c->c_future.ff_features | flags->cf_flags;

c->c_future.ff_features = merged;

flags->cf_flags = merged;

c->c_flags = *flags;

c->c_optimize = (optimize == -1) ? _Py_GetConfig()->optimization_level : optimize;

c->c_save_nested_seqs = false;

if (!_PyAST_Preprocess(mod, arena, filename, c->c_optimize, merged,

0, 1, module))

{

return ERROR;

}

c->c_st = _PySymtable_Build(mod, filename, &c->c_future);

if (c->c_st == NULL) {

if (!PyErr_Occurred()) {

PyErr_SetString(PyExc_SystemError, "no symtable");

}

return ERROR;

}

return SUCCESS;

}

static void

compiler_free(compiler *c)

{

if (c->c_st) {

_PySymtable_Free(c->c_st);

}

Py_XDECREF(c->c_filename);

Py_XDECREF(c->c_module);

Py_XDECREF(c->c_const_cache);

Py_XDECREF(c->c_stack);

PyMem_Free(c);

}

static compiler*

new_compiler(mod_ty mod, PyObject *filename, PyCompilerFlags *pflags,

int optimize, PyArena *arena, PyObject *module)

{

compiler *c = PyMem_Calloc(1, sizeof(compiler));

if (c == NULL) {

return NULL;

}

if (compiler_setup(c, mod, filename, pflags, optimize, arena, module) < 0) {

compiler_free(c);

return NULL;

}

return c;

}

static void

compiler_unit_free(struct compiler_unit *u)

{

Py_CLEAR(u->u_instr_sequence);

Py_CLEAR(u->u_stashed_instr_sequence);

Py_CLEAR(u->u_ste);

Py_CLEAR(u->u_metadata.u_name);

Py_CLEAR(u->u_metadata.u_qualname);

Py_CLEAR(u->u_metadata.u_consts);

Py_CLEAR(u->u_metadata.u_names);

Py_CLEAR(u->u_metadata.u_varnames);

Py_CLEAR(u->u_metadata.u_freevars);

Py_CLEAR(u->u_metadata.u_cellvars);

Py_CLEAR(u->u_metadata.u_fasthidden);

Py_CLEAR(u->u_private);

Py_CLEAR(u->u_static_attributes);

Py_CLEAR(u->u_deferred_annotations);

Py_CLEAR(u->u_conditional_annotation_indices);

PyMem_Free(u);

}

#define CAPSULE_NAME "compile.c compiler unit"

_PyCompile_MaybeAddStaticAttributeToClass(compiler *c, expr_ty e)

{

assert(e->kind == Attribute_kind);

expr_ty attr_value = e->v.Attribute.value;

if (attr_value->kind != Name_kind ||

e->v.Attribute.ctx != Store ||

!_PyUnicode_EqualToASCIIString(attr_value->v.Name.id, "self"))

{

return SUCCESS;

}

Py_ssize_t stack_size = PyList_GET_SIZE(c->c_stack);

for (Py_ssize_t i = stack_size - 1; i >= 0; i--) {

PyObject *capsule = PyList_GET_ITEM(c->c_stack, i);

struct compiler_unit *u = (struct compiler_unit *)PyCapsule_GetPointer(

capsule, CAPSULE_NAME);

assert(u);

if (u->u_scope_type == COMPILE_SCOPE_CLASS) {

assert(u->u_static_attributes);

RETURN_IF_ERROR(PySet_Add(u->u_static_attributes, e->v.Attribute.attr));

break;

}

}

return SUCCESS;

}

static int

compiler_set_qualname(compiler *c)

{

Py_ssize_t stack_size;

struct compiler_unit *u = c->u;

PyObject *name, *base;

base = NULL;

stack_size = PyList_GET_SIZE(c->c_stack);

assert(stack_size >= 1);

if (stack_size > 1) {

int scope, force_global = 0;

struct compiler_unit *parent;

PyObject *mangled, *capsule;

capsule = PyList_GET_ITEM(c->c_stack, stack_size - 1);

parent = (struct compiler_unit *)PyCapsule_GetPointer(capsule, CAPSULE_NAME);

assert(parent);

if (parent->u_scope_type == COMPILE_SCOPE_ANNOTATIONS) {

/* The parent is an annotation scope, so we need to

if (stack_size == 2) {

// If we're immediately within the module, we can skip

// the rest and just set the qualname to be the same as name.

u->u_metadata.u_qualname = Py_NewRef(u->u_metadata.u_name);

return SUCCESS;

}

capsule = PyList_GET_ITEM(c->c_stack, stack_size - 2);

parent = (struct compiler_unit *)PyCapsule_GetPointer(capsule, CAPSULE_NAME);

assert(parent);

}

if (u->u_scope_type == COMPILE_SCOPE_FUNCTION

|| u->u_scope_type == COMPILE_SCOPE_ASYNC_FUNCTION

|| u->u_scope_type == COMPILE_SCOPE_CLASS) {

assert(u->u_metadata.u_name);

mangled = _Py_Mangle(parent->u_private, u->u_metadata.u_name);

if (!mangled) {

return ERROR;

}

scope = _PyST_GetScope(parent->u_ste, mangled);

Py_DECREF(mangled);

RETURN_IF_ERROR(scope);

assert(scope != GLOBAL_IMPLICIT);

if (scope == GLOBAL_EXPLICIT)

force_global = 1;

}

if (!force_global) {

if (parent->u_scope_type == COMPILE_SCOPE_FUNCTION

|| parent->u_scope_type == COMPILE_SCOPE_ASYNC_FUNCTION

|| parent->u_scope_type == COMPILE_SCOPE_LAMBDA)

{

_Py_DECLARE_STR(dot_locals, ".<locals>");

base = PyUnicode_Concat(parent->u_metadata.u_qualname,

&_Py_STR(dot_locals));

if (base == NULL) {

return ERROR;

}

}

else {

base = Py_NewRef(parent->u_metadata.u_qualname);

}

}

if (u->u_ste->ste_function_name != NULL) {

PyObject *tmp = base;

base = PyUnicode_FromFormat("%U.%U",

base,

u->u_ste->ste_function_name);

Py_DECREF(tmp);

if (base == NULL) {

return ERROR;

}

}

}

else if (u->u_ste->ste_function_name != NULL) {

base = Py_NewRef(u->u_ste->ste_function_name);

}

if (base != NULL) {

name = PyUnicode_Concat(base, _Py_LATIN1_CHR('.'));

Py_DECREF(base);

if (name == NULL) {

return ERROR;

}

PyUnicode_Append(&name, u->u_metadata.u_name);

if (name == NULL) {

return ERROR;

}

}

else {

name = Py_NewRef(u->u_metadata.u_name);

}

u->u_metadata.u_qualname = name;

return SUCCESS;

}

static PyObject*

const_cache_insert(PyObject *const_cache, PyObject *o, bool recursive)

{

assert(PyDict_CheckExact(const_cache));

// None and Ellipsis are immortal objects, and key is the singleton.

// No need to merge object and key.

if (o == Py_None || o == Py_Ellipsis) {

return o;

}

PyObject *key = _PyCode_ConstantKey(o);

if (key == NULL) {

return NULL;

}

PyObject *t;

int res = PyDict_SetDefaultRef(const_cache, key, key, &t);

if (res != 0) {

// o was not inserted into const_cache. t is either the existing value

// or NULL (on error).

Py_DECREF(key);

return t;

}

Py_DECREF(t);

if (!recursive) {

return key;

}

// We registered o in const_cache.

// When o is a tuple or frozenset, we want to merge its

// items too.

if (PyTuple_CheckExact(o)) {

Py_ssize_t len = PyTuple_GET_SIZE(o);

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

PyObject *item = PyTuple_GET_ITEM(o, i);

PyObject *u = const_cache_insert(const_cache, item, recursive);

if (u == NULL) {

Py_DECREF(key);

return NULL;

}

// See _PyCode_ConstantKey()

PyObject *v; // borrowed

if (PyTuple_CheckExact(u)) {

v = PyTuple_GET_ITEM(u, 1);

}

else {

v = u;

}

if (v != item) {

PyTuple_SET_ITEM(o, i, Py_NewRef(v));

Py_DECREF(item);

}

Py_DECREF(u);

}

}

else if (PyFrozenSet_CheckExact(o)) {

// *key* is tuple. And its first item is frozenset of

// constant keys.

// See _PyCode_ConstantKey() for detail.

assert(PyTuple_CheckExact(key));

assert(PyTuple_GET_SIZE(key) == 2);

Py_ssize_t len = PySet_GET_SIZE(o);

if (len == 0) { // empty frozenset should not be re-created.

return key;

}

PyObject *tuple = PyTuple_New(len);

if (tuple == NULL) {

Py_DECREF(key);

return NULL;

}

Py_ssize_t i = 0, pos = 0;

PyObject *item;

Py_hash_t hash;

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

PyObject *k = const_cache_insert(const_cache, item, recursive);

if (k == NULL) {

Py_DECREF(tuple);

Py_DECREF(key);

return NULL;

}

PyObject *u;

if (PyTuple_CheckExact(k)) {

u = Py_NewRef(PyTuple_GET_ITEM(k, 1));

Py_DECREF(k);

}

else {

u = k;

}

PyTuple_SET_ITEM(tuple, i, u); // Steals reference of u.

i++;

}

// Instead of rewriting o, we create new frozenset and embed in the

// key tuple. Caller should get merged frozenset from the key tuple.

PyObject *new = PyFrozenSet_New(tuple);

Py_DECREF(tuple);

if (new == NULL) {

Py_DECREF(key);

return NULL;

}

assert(PyTuple_GET_ITEM(key, 1) == o);

Py_DECREF(o);

PyTuple_SET_ITEM(key, 1, new);

}

return key;

}

static PyObject*

merge_consts_recursive(PyObject *const_cache, PyObject *o)

{

return const_cache_insert(const_cache, o, true);

}

_PyCompile_DictAddObj(PyObject *dict, PyObject *o)

{

PyObject *v;

Py_ssize_t arg;

if (PyDict_GetItemRef(dict, o, &v) < 0) {

return ERROR;

}

if (!v) {

arg = PyDict_GET_SIZE(dict);

v = PyLong_FromSsize_t(arg);

if (!v) {

return ERROR;

}

if (PyDict_SetItem(dict, o, v) < 0) {

Py_DECREF(v);

return ERROR;

}

}

else

arg = PyLong_AsLong(v);

Py_DECREF(v);

return arg;

}

_PyCompile_AddConst(compiler *c, PyObject *o)

{

PyObject *key = merge_consts_recursive(c->c_const_cache, o);

if (key == NULL) {

return ERROR;

}

Py_ssize_t arg = _PyCompile_DictAddObj(c->u->u_metadata.u_consts, key);

Py_DECREF(key);

return arg;

}

static PyObject *

list2dict(PyObject *list)

{

Py_ssize_t i, n;

PyObject *v, *k;

PyObject *dict = PyDict_New();

if (!dict) return NULL;

n = PyList_Size(list);

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

v = PyLong_FromSsize_t(i);

if (!v) {

Py_DECREF(dict);

return NULL;

}

k = PyList_GET_ITEM(list, i);

if (PyDict_SetItem(dict, k, v) < 0) {

Py_DECREF(v);

Py_DECREF(dict);

return NULL;

}

Py_DECREF(v);

}

return dict;

}

static PyObject *

dictbytype(PyObject *src, int scope_type, int flag, Py_ssize_t offset)

{

Py_ssize_t i = offset, num_keys, key_i;

PyObject *k, *v, *dest = PyDict_New();

PyObject *sorted_keys;

assert(offset >= 0);

if (dest == NULL)

return NULL;

/* Sort the keys so that we have a deterministic order on the indexes

sorted_keys = PyDict_Keys(src);

if (sorted_keys == NULL) {

Py_DECREF(dest);

return NULL;

}

if (PyList_Sort(sorted_keys) != 0) {

Py_DECREF(sorted_keys);

Py_DECREF(dest);

return NULL;

}

num_keys = PyList_GET_SIZE(sorted_keys);

for (key_i = 0; key_i < num_keys; key_i++) {

k = PyList_GET_ITEM(sorted_keys, key_i);

v = PyDict_GetItemWithError(src, k);

if (!v) {

if (!PyErr_Occurred()) {

PyErr_SetObject(PyExc_KeyError, k);

}

Py_DECREF(sorted_keys);

Py_DECREF(dest);

return NULL;

}

long vi = PyLong_AsLong(v);

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

Py_DECREF(sorted_keys);

Py_DECREF(dest);

return NULL;

}

if (SYMBOL_TO_SCOPE(vi) == scope_type || vi & flag) {

PyObject *item = PyLong_FromSsize_t(i);

if (item == NULL) {

Py_DECREF(sorted_keys);

Py_DECREF(dest);

return NULL;

}

i++;

if (PyDict_SetItem(dest, k, item) < 0) {

Py_DECREF(sorted_keys);

Py_DECREF(item);

Py_DECREF(dest);

return NULL;

}

Py_DECREF(item);

}

}

Py_DECREF(sorted_keys);

return dest;

}

_PyCompile_EnterScope(compiler *c, identifier name, int scope_type,

void *key, int lineno, PyObject *private,

_PyCompile_CodeUnitMetadata *umd)

{

struct compiler_unit *u;

u = (struct compiler_unit *)PyMem_Calloc(1, sizeof(struct compiler_unit));

if (!u) {

PyErr_NoMemory();

return ERROR;

}

u->u_scope_type = scope_type;

if (umd != NULL) {

u->u_metadata = *umd;

}

else {

u->u_metadata.u_argcount = 0;

u->u_metadata.u_posonlyargcount = 0;

u->u_metadata.u_kwonlyargcount = 0;

}

u->u_ste = _PySymtable_Lookup(c->c_st, key);

if (!u->u_ste) {

compiler_unit_free(u);

return ERROR;

}

u->u_metadata.u_name = Py_NewRef(name);

u->u_metadata.u_varnames = list2dict(u->u_ste->ste_varnames);

if (!u->u_metadata.u_varnames) {

compiler_unit_free(u);

return ERROR;

}

u->u_metadata.u_cellvars = dictbytype(u->u_ste->ste_symbols, CELL, DEF_COMP_CELL, 0);

if (!u->u_metadata.u_cellvars) {

compiler_unit_free(u);

return ERROR;

}

if (u->u_ste->ste_needs_class_closure) {

/* Cook up an implicit __class__ cell. */

Py_ssize_t res;

assert(u->u_scope_type == COMPILE_SCOPE_CLASS);

res = _PyCompile_DictAddObj(u->u_metadata.u_cellvars, &_Py_ID(__class__));

if (res < 0) {

compiler_unit_free(u);

return ERROR;

}

}

if (u->u_ste->ste_needs_classdict) {

/* Cook up an implicit __classdict__ cell. */

Py_ssize_t res;

assert(u->u_scope_type == COMPILE_SCOPE_CLASS);

res = _PyCompile_DictAddObj(u->u_metadata.u_cellvars, &_Py_ID(__classdict__));

if (res < 0) {

compiler_unit_free(u);

return ERROR;

}

}

if (u->u_ste->ste_has_conditional_annotations) {

/* Cook up an implicit __conditional_annotations__ cell */

Py_ssize_t res;

assert(u->u_scope_type == COMPILE_SCOPE_CLASS || u->u_scope_type == COMPILE_SCOPE_MODULE);

res = _PyCompile_DictAddObj(u->u_metadata.u_cellvars, &_Py_ID(__conditional_annotations__));

if (res < 0) {

compiler_unit_free(u);

return ERROR;

}

}

u->u_metadata.u_freevars = dictbytype(u->u_ste->ste_symbols, FREE, DEF_FREE_CLASS,

PyDict_GET_SIZE(u->u_metadata.u_cellvars));

if (!u->u_metadata.u_freevars) {

compiler_unit_free(u);

return ERROR;

}

u->u_metadata.u_fasthidden = PyDict_New();

if (!u->u_metadata.u_fasthidden) {

compiler_unit_free(u);

return ERROR;

}

u->u_nfblocks = 0;

u->u_in_inlined_comp = 0;

u->u_metadata.u_firstlineno = lineno;

u->u_metadata.u_consts = PyDict_New();

if (!u->u_metadata.u_consts) {

compiler_unit_free(u);

return ERROR;

}

u->u_metadata.u_names = PyDict_New();

if (!u->u_metadata.u_names) {

compiler_unit_free(u);

return ERROR;

}

u->u_deferred_annotations = NULL;

u->u_conditional_annotation_indices = NULL;

u->u_next_conditional_annotation_index = 0;

if (scope_type == COMPILE_SCOPE_CLASS) {

u->u_static_attributes = PySet_New(0);

if (!u->u_static_attributes) {

compiler_unit_free(u);

return ERROR;

}

}

else {

u->u_static_attributes = NULL;

}

u->u_instr_sequence = (instr_sequence*)_PyInstructionSequence_New();

if (!u->u_instr_sequence) {

compiler_unit_free(u);

return ERROR;

}

u->u_stashed_instr_sequence = NULL;

/* Push the old compiler_unit on the stack. */

if (c->u) {

PyObject *capsule = PyCapsule_New(c->u, CAPSULE_NAME, NULL);

if (!capsule || PyList_Append(c->c_stack, capsule) < 0) {

Py_XDECREF(capsule);

compiler_unit_free(u);

return ERROR;

}

Py_DECREF(capsule);

if (private == NULL) {

private = c->u->u_private;

}

}

u->u_private = Py_XNewRef(private);

c->u = u;

if (scope_type != COMPILE_SCOPE_MODULE) {

RETURN_IF_ERROR(compiler_set_qualname(c));

}

return SUCCESS;

}

_PyCompile_ExitScope(compiler *c)

{

// Don't call PySequence_DelItem() with an exception raised

PyObject *exc = PyErr_GetRaisedException();

instr_sequence *nested_seq = NULL;

if (c->c_save_nested_seqs) {

nested_seq = c->u->u_instr_sequence;

Py_INCREF(nested_seq);

}

compiler_unit_free(c->u);

/* Restore c->u to the parent unit. */

Py_ssize_t n = PyList_GET_SIZE(c->c_stack) - 1;

if (n >= 0) {

PyObject *capsule = PyList_GET_ITEM(c->c_stack, n);

c->u = (struct compiler_unit *)PyCapsule_GetPointer(capsule, CAPSULE_NAME);

assert(c->u);

/* we are deleting from a list so this really shouldn't fail */

if (PySequence_DelItem(c->c_stack, n) < 0) {

PyErr_FormatUnraisable("Exception ignored while removing "

"the last compiler stack item");

}

if (nested_seq != NULL) {

if (_PyInstructionSequence_AddNested(c->u->u_instr_sequence, nested_seq) < 0) {

PyErr_FormatUnraisable("Exception ignored while appending "

"nested instruction sequence");

}

}

}

else {

c->u = NULL;

}

Py_XDECREF(nested_seq);

PyErr_SetRaisedException(exc);

}

_PyCompile_PushFBlock(compiler *c, location loc,

fblocktype t, jump_target_label block_label,

jump_target_label exit, void *datum)

{

fblockinfo *f;

if (c->u->u_nfblocks >= CO_MAXBLOCKS) {

return _PyCompile_Error(c, loc, "too many statically nested blocks");

}

f = &c->u->u_fblock[c->u->u_nfblocks++];

f->fb_type = t;

f->fb_block = block_label;

f->fb_loc = loc;

f->fb_exit = exit;

f->fb_datum = datum;

if (t == COMPILE_FBLOCK_FINALLY_END) {

c->c_disable_warning++;

}

return SUCCESS;

}

_PyCompile_PopFBlock(compiler *c, fblocktype t, jump_target_label block_label)

{

struct compiler_unit *u = c->u;

assert(u->u_nfblocks > 0);

u->u_nfblocks--;

assert(u->u_fblock[u->u_nfblocks].fb_type == t);

assert(SAME_JUMP_TARGET_LABEL(u->u_fblock[u->u_nfblocks].fb_block, block_label));

if (t == COMPILE_FBLOCK_FINALLY_END) {

c->c_disable_warning--;

}

}

fblockinfo *

_PyCompile_TopFBlock(compiler *c)

{

if (c->u->u_nfblocks == 0) {

return NULL;

}

return &c->u->u_fblock[c->u->u_nfblocks - 1];

}

_PyCompile_InExceptionHandler(compiler *c)

{

for (Py_ssize_t i = 0; i < c->u->u_nfblocks; i++) {

fblockinfo *block = &c->u->u_fblock[i];

switch (block->fb_type) {

case COMPILE_FBLOCK_TRY_EXCEPT:

case COMPILE_FBLOCK_FINALLY_TRY:

case COMPILE_FBLOCK_FINALLY_END:

case COMPILE_FBLOCK_EXCEPTION_HANDLER:

case COMPILE_FBLOCK_EXCEPTION_GROUP_HANDLER:

case COMPILE_FBLOCK_HANDLER_CLEANUP:

return true;

default:

break;

}

}

return false;

}

_PyCompile_DeferredAnnotations(compiler *c,

PyObject **deferred_annotations,

PyObject **conditional_annotation_indices)

{

*deferred_annotations = Py_XNewRef(c->u->u_deferred_annotations);

*conditional_annotation_indices = Py_XNewRef(c->u->u_conditional_annotation_indices);

}

static location

start_location(asdl_stmt_seq *stmts)

{

if (asdl_seq_LEN(stmts) > 0) {

/* Set current line number to the line number of first statement.

stmt_ty st = (stmt_ty)asdl_seq_GET(stmts, 0);

return SRC_LOCATION_FROM_AST(st);

}

return (const _Py_SourceLocation){1, 1, 0, 0};

}

static int

compiler_codegen(compiler *c, mod_ty mod)

{

RETURN_IF_ERROR(_PyCodegen_EnterAnonymousScope(c, mod));

assert(c->u->u_scope_type == COMPILE_SCOPE_MODULE);

switch (mod->kind) {

case Module_kind: {

asdl_stmt_seq *stmts = mod->v.Module.body;

RETURN_IF_ERROR(_PyCodegen_Module(c, start_location(stmts), stmts, false));

break;

}

case Interactive_kind: {

c->c_interactive = 1;

asdl_stmt_seq *stmts = mod->v.Interactive.body;

RETURN_IF_ERROR(_PyCodegen_Module(c, start_location(stmts), stmts, true));

break;

}

case Expression_kind: {

RETURN_IF_ERROR(_PyCodegen_Expression(c, mod->v.Expression.body));

break;

}

default: {

PyErr_Format(PyExc_SystemError,

"module kind %d should not be possible",

mod->kind);

return ERROR;

}}

return SUCCESS;

}

static PyCodeObject *

compiler_mod(compiler *c, mod_ty mod)

{

PyCodeObject *co = NULL;

int addNone = mod->kind != Expression_kind;

if (compiler_codegen(c, mod) < 0) {

goto finally;

}

co = _PyCompile_OptimizeAndAssemble(c, addNone);

finally:

_PyCompile_ExitScope(c);

return co;

}

_PyCompile_GetRefType(compiler *c, PyObject *name)

{

if (c->u->u_scope_type == COMPILE_SCOPE_CLASS &&

(_PyUnicode_EqualToASCIIString(name, "__class__") ||

_PyUnicode_EqualToASCIIString(name, "__classdict__") ||

_PyUnicode_EqualToASCIIString(name, "__conditional_annotations__"))) {

return CELL;

}

PySTEntryObject *ste = c->u->u_ste;

int scope = _PyST_GetScope(ste, name);

if (scope == 0) {

PyErr_Format(PyExc_SystemError,

"_PyST_GetScope(name=%R) failed: "

"unknown scope in unit %S (%R); "

"symbols: %R; locals: %R; "

"globals: %R",

name,

c->u->u_metadata.u_name, ste->ste_id,

ste->ste_symbols, c->u->u_metadata.u_varnames,

c->u->u_metadata.u_names);

return ERROR;

}

return scope;

}

static int

dict_lookup_arg(PyObject *dict, PyObject *name)

{

PyObject *v = PyDict_GetItemWithError(dict, name);

if (v == NULL) {

return ERROR;

}

return PyLong_AsLong(v);

}

_PyCompile_LookupCellvar(compiler *c, PyObject *name)

{

assert(c->u->u_metadata.u_cellvars);

return dict_lookup_arg(c->u->u_metadata.u_cellvars, name);

}

_PyCompile_LookupArg(compiler *c, PyCodeObject *co, PyObject *name)

{

/* Special case: If a class contains a method with a

int reftype = _PyCompile_GetRefType(c, name);

if (reftype == -1) {

return ERROR;

}

int arg;

if (reftype == CELL) {

arg = dict_lookup_arg(c->u->u_metadata.u_cellvars, name);

}

else {

arg = dict_lookup_arg(c->u->u_metadata.u_freevars, name);

}

if (arg == -1 && !PyErr_Occurred()) {

PyObject *freevars = _PyCode_GetFreevars(co);

if (freevars == NULL) {

PyErr_Clear();

}

PyErr_Format(PyExc_SystemError,

"compiler_lookup_arg(name=%R) with reftype=%d failed in %S; "

"freevars of code %S: %R",

name,

reftype,

c->u->u_metadata.u_name,

co->co_name,

freevars);

Py_XDECREF(freevars);

return ERROR;

}

return arg;

}

PyObject *

_PyCompile_StaticAttributesAsTuple(compiler *c)

{

assert(c->u->u_static_attributes);

PyObject *static_attributes_unsorted = PySequence_List(c->u->u_static_attributes);

if (static_attributes_unsorted == NULL) {

return NULL;

}

if (PyList_Sort(static_attributes_unsorted) != 0) {

Py_DECREF(static_attributes_unsorted);

return NULL;

}

PyObject *static_attributes = PySequence_Tuple(static_attributes_unsorted);

Py_DECREF(static_attributes_unsorted);