#include "Python.h"

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

#include "symtable.h"

#undef Yield /* undefine macro conflicting with <winbase.h> */

#include "structmember.h" // PyMemberDef

#define GLOBAL_PARAM \

"name '%U' is parameter and global"

#define NONLOCAL_PARAM \

"name '%U' is parameter and nonlocal"

#define GLOBAL_AFTER_ASSIGN \

"name '%U' is assigned to before global declaration"

#define NONLOCAL_AFTER_ASSIGN \

"name '%U' is assigned to before nonlocal declaration"

#define GLOBAL_AFTER_USE \

"name '%U' is used prior to global declaration"

#define NONLOCAL_AFTER_USE \

"name '%U' is used prior to nonlocal declaration"

#define GLOBAL_ANNOT \

"annotated name '%U' can't be global"

#define NONLOCAL_ANNOT \

"annotated name '%U' can't be nonlocal"

#define IMPORT_STAR_WARNING "import * only allowed at module level"

#define NAMED_EXPR_COMP_IN_CLASS \

"assignment expression within a comprehension cannot be used in a class body"

#define NAMED_EXPR_COMP_CONFLICT \

"assignment expression cannot rebind comprehension iteration variable '%U'"

#define NAMED_EXPR_COMP_INNER_LOOP_CONFLICT \

"comprehension inner loop cannot rebind assignment expression target '%U'"

#define NAMED_EXPR_COMP_ITER_EXPR \

"assignment expression cannot be used in a comprehension iterable expression"

static PySTEntryObject *

ste_new(struct symtable *st, identifier name, _Py_block_ty block,

void *key, int lineno, int col_offset)

{

PySTEntryObject *ste = NULL;

PyObject *k = NULL;

k = PyLong_FromVoidPtr(key);

if (k == NULL)

goto fail;

ste = PyObject_New(PySTEntryObject, &PySTEntry_Type);

if (ste == NULL) {

Py_DECREF(k);

goto fail;

}

ste->ste_table = st;

ste->ste_id = k; /* ste owns reference to k */

Py_INCREF(name);

ste->ste_name = name;

ste->ste_symbols = NULL;

ste->ste_varnames = NULL;

ste->ste_children = NULL;

ste->ste_directives = NULL;

ste->ste_type = block;

ste->ste_nested = 0;

ste->ste_free = 0;

ste->ste_varargs = 0;

ste->ste_varkeywords = 0;

ste->ste_opt_lineno = 0;

ste->ste_opt_col_offset = 0;

ste->ste_lineno = lineno;

ste->ste_col_offset = col_offset;

if (st->st_cur != NULL &&

(st->st_cur->ste_nested ||

st->st_cur->ste_type == FunctionBlock))

ste->ste_nested = 1;

ste->ste_child_free = 0;

ste->ste_generator = 0;

ste->ste_coroutine = 0;

ste->ste_comprehension = 0;

ste->ste_returns_value = 0;

ste->ste_needs_class_closure = 0;

ste->ste_comp_iter_target = 0;

ste->ste_comp_iter_expr = 0;

ste->ste_symbols = PyDict_New();

ste->ste_varnames = PyList_New(0);

ste->ste_children = PyList_New(0);

if (ste->ste_symbols == NULL

|| ste->ste_varnames == NULL

|| ste->ste_children == NULL)

goto fail;

if (PyDict_SetItem(st->st_blocks, ste->ste_id, (PyObject *)ste) < 0)

goto fail;

return ste;

fail:

Py_XDECREF(ste);

return NULL;

}

static PyObject *

ste_repr(PySTEntryObject *ste)

{

return PyUnicode_FromFormat("<symtable entry %U(%ld), line %d>",

ste->ste_name,

PyLong_AS_LONG(ste->ste_id), ste->ste_lineno);

}

static void

ste_dealloc(PySTEntryObject *ste)

{

ste->ste_table = NULL;

Py_XDECREF(ste->ste_id);

Py_XDECREF(ste->ste_name);

Py_XDECREF(ste->ste_symbols);

Py_XDECREF(ste->ste_varnames);

Py_XDECREF(ste->ste_children);

Py_XDECREF(ste->ste_directives);

PyObject_Del(ste);

}

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

static PyMemberDef ste_memberlist[] = {

{"id", T_OBJECT, OFF(ste_id), READONLY},

{"name", T_OBJECT, OFF(ste_name), READONLY},

{"symbols", T_OBJECT, OFF(ste_symbols), READONLY},

{"varnames", T_OBJECT, OFF(ste_varnames), READONLY},

{"children", T_OBJECT, OFF(ste_children), READONLY},

{"nested", T_INT, OFF(ste_nested), READONLY},

{"type", T_INT, OFF(ste_type), READONLY},

{"lineno", T_INT, OFF(ste_lineno), READONLY},

{NULL}

};

PyTypeObject PySTEntry_Type = {

PyVarObject_HEAD_INIT(&PyType_Type, 0)

"symtable entry",

sizeof(PySTEntryObject),

0,

(destructor)ste_dealloc, /* tp_dealloc */

0, /* tp_vectorcall_offset */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_as_async */

(reprfunc)ste_repr, /* tp_repr */

0, /* tp_as_number */

0, /* tp_as_sequence */

0, /* tp_as_mapping */

0, /* tp_hash */

0, /* tp_call */

0, /* tp_str */

PyObject_GenericGetAttr, /* tp_getattro */

0, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT, /* tp_flags */

0, /* tp_doc */

0, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

0, /* tp_methods */

ste_memberlist, /* 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 */

};

static int symtable_analyze(struct symtable *st);

static int symtable_enter_block(struct symtable *st, identifier name,

_Py_block_ty block, void *ast, int lineno,

int col_offset);

static int symtable_exit_block(struct symtable *st);

static int symtable_visit_stmt(struct symtable *st, stmt_ty s);

static int symtable_visit_expr(struct symtable *st, expr_ty s);

static int symtable_visit_genexp(struct symtable *st, expr_ty s);

static int symtable_visit_listcomp(struct symtable *st, expr_ty s);

static int symtable_visit_setcomp(struct symtable *st, expr_ty s);

static int symtable_visit_dictcomp(struct symtable *st, expr_ty s);

static int symtable_visit_arguments(struct symtable *st, arguments_ty);

static int symtable_visit_excepthandler(struct symtable *st, excepthandler_ty);

static int symtable_visit_alias(struct symtable *st, alias_ty);

static int symtable_visit_comprehension(struct symtable *st, comprehension_ty);

static int symtable_visit_keyword(struct symtable *st, keyword_ty);

static int symtable_visit_params(struct symtable *st, asdl_seq *args);

static int symtable_visit_argannotations(struct symtable *st, asdl_seq *args);

static int symtable_implicit_arg(struct symtable *st, int pos);

static int symtable_visit_annotations(struct symtable *st, arguments_ty, expr_ty);

static int symtable_visit_withitem(struct symtable *st, withitem_ty item);

static identifier top = NULL, lambda = NULL, genexpr = NULL,

listcomp = NULL, setcomp = NULL, dictcomp = NULL,

__class__ = NULL;

#define GET_IDENTIFIER(VAR) \

((VAR) ? (VAR) : ((VAR) = PyUnicode_InternFromString(# VAR)))

#define DUPLICATE_ARGUMENT \

"duplicate argument '%U' in function definition"

static struct symtable *

symtable_new(void)

{

struct symtable *st;

st = (struct symtable *)PyMem_Malloc(sizeof(struct symtable));

if (st == NULL) {

PyErr_NoMemory();

return NULL;

}

st->st_filename = NULL;

st->st_blocks = NULL;

if ((st->st_stack = PyList_New(0)) == NULL)

goto fail;

if ((st->st_blocks = PyDict_New()) == NULL)

goto fail;

st->st_cur = NULL;

st->st_private = NULL;

return st;

fail:

PySymtable_Free(st);

return NULL;

}

#define COMPILER_STACK_FRAME_SCALE 3

struct symtable *

PySymtable_BuildObject(mod_ty mod, PyObject *filename, PyFutureFeatures *future)

{

struct symtable *st = symtable_new();

asdl_seq *seq;

int i;

PyThreadState *tstate;

int recursion_limit = Py_GetRecursionLimit();

int starting_recursion_depth;

if (st == NULL)

return NULL;

if (filename == NULL) {

PySymtable_Free(st);

return NULL;

}

Py_INCREF(filename);

st->st_filename = filename;

st->st_future = future;

/* Setup recursion depth check counters */

tstate = _PyThreadState_GET();

if (!tstate) {

PySymtable_Free(st);

return NULL;

}

/* Be careful here to prevent overflow. */

starting_recursion_depth = (tstate->recursion_depth < INT_MAX / COMPILER_STACK_FRAME_SCALE) ?

tstate->recursion_depth * COMPILER_STACK_FRAME_SCALE : tstate->recursion_depth;

st->recursion_depth = starting_recursion_depth;

st->recursion_limit = (recursion_limit < INT_MAX / COMPILER_STACK_FRAME_SCALE) ?

recursion_limit * COMPILER_STACK_FRAME_SCALE : recursion_limit;

/* Make the initial symbol information gathering pass */

if (!GET_IDENTIFIER(top) ||

!symtable_enter_block(st, top, ModuleBlock, (void *)mod, 0, 0)) {

PySymtable_Free(st);

return NULL;

}

st->st_top = st->st_cur;

switch (mod->kind) {

case Module_kind:

seq = mod->v.Module.body;

for (i = 0; i < asdl_seq_LEN(seq); i++)

if (!symtable_visit_stmt(st,

(stmt_ty)asdl_seq_GET(seq, i)))

goto error;

break;

case Expression_kind:

if (!symtable_visit_expr(st, mod->v.Expression.body))

goto error;

break;

case Interactive_kind:

seq = mod->v.Interactive.body;

for (i = 0; i < asdl_seq_LEN(seq); i++)

if (!symtable_visit_stmt(st,

(stmt_ty)asdl_seq_GET(seq, i)))

goto error;

break;

case FunctionType_kind:

PyErr_SetString(PyExc_RuntimeError,

"this compiler does not handle FunctionTypes");

goto error;

}

if (!symtable_exit_block(st)) {

PySymtable_Free(st);

return NULL;

}

/* Check that the recursion depth counting balanced correctly */

if (st->recursion_depth != starting_recursion_depth) {

PyErr_Format(PyExc_SystemError,

"symtable analysis recursion depth mismatch (before=%d, after=%d)",

starting_recursion_depth, st->recursion_depth);

PySymtable_Free(st);

return NULL;

}

/* Make the second symbol analysis pass */

if (symtable_analyze(st))

return st;

PySymtable_Free(st);

return NULL;

error:

(void) symtable_exit_block(st);

PySymtable_Free(st);

return NULL;

}

struct symtable *

PySymtable_Build(mod_ty mod, const char *filename_str, PyFutureFeatures *future)

{

PyObject *filename;

struct symtable *st;

filename = PyUnicode_DecodeFSDefault(filename_str);

if (filename == NULL)

return NULL;

st = PySymtable_BuildObject(mod, filename, future);

Py_DECREF(filename);

return st;

}

PySymtable_Free(struct symtable *st)

{

Py_XDECREF(st->st_filename);

Py_XDECREF(st->st_blocks);

Py_XDECREF(st->st_stack);

PyMem_Free((void *)st);

}

PySTEntryObject *

PySymtable_Lookup(struct symtable *st, void *key)

{

PyObject *k, *v;

k = PyLong_FromVoidPtr(key);

if (k == NULL)

return NULL;

v = PyDict_GetItemWithError(st->st_blocks, k);

if (v) {

assert(PySTEntry_Check(v));

Py_INCREF(v);

}

else if (!PyErr_Occurred()) {

PyErr_SetString(PyExc_KeyError,

"unknown symbol table entry");

}

Py_DECREF(k);

return (PySTEntryObject *)v;

}

static long

_PyST_GetSymbol(PySTEntryObject *ste, PyObject *name)

{

PyObject *v = PyDict_GetItem(ste->ste_symbols, name);

if (!v)

return 0;

assert(PyLong_Check(v));

return PyLong_AS_LONG(v);

}

PyST_GetScope(PySTEntryObject *ste, PyObject *name)

{

long symbol = _PyST_GetSymbol(ste, name);

return (symbol >> SCOPE_OFFSET) & SCOPE_MASK;

}

static int

error_at_directive(PySTEntryObject *ste, PyObject *name)

{

Py_ssize_t i;

PyObject *data;

assert(ste->ste_directives);

for (i = 0; i < PyList_GET_SIZE(ste->ste_directives); i++) {

data = PyList_GET_ITEM(ste->ste_directives, i);

assert(PyTuple_CheckExact(data));

assert(PyUnicode_CheckExact(PyTuple_GET_ITEM(data, 0)));

if (PyUnicode_Compare(PyTuple_GET_ITEM(data, 0), name) == 0) {

PyErr_SyntaxLocationObject(ste->ste_table->st_filename,

PyLong_AsLong(PyTuple_GET_ITEM(data, 1)),

PyLong_AsLong(PyTuple_GET_ITEM(data, 2)) + 1);

return 0;

}

}

PyErr_SetString(PyExc_RuntimeError,

"BUG: internal directive bookkeeping broken");

return 0;

}

#define SET_SCOPE(DICT, NAME, I) { \

PyObject *o = PyLong_FromLong(I); \

if (!o) \

return 0; \

if (PyDict_SetItem((DICT), (NAME), o) < 0) { \

Py_DECREF(o); \

return 0; \

} \

Py_DECREF(o); \

}

static int

analyze_name(PySTEntryObject *ste, PyObject *scopes, PyObject *name, long flags,

PyObject *bound, PyObject *local, PyObject *free,

PyObject *global)

{

if (flags & DEF_GLOBAL) {

if (flags & DEF_NONLOCAL) {

PyErr_Format(PyExc_SyntaxError,

"name '%U' is nonlocal and global",

name);

return error_at_directive(ste, name);

}

SET_SCOPE(scopes, name, GLOBAL_EXPLICIT);

if (PySet_Add(global, name) < 0)

return 0;

if (bound && (PySet_Discard(bound, name) < 0))

return 0;

return 1;

}

if (flags & DEF_NONLOCAL) {

if (!bound) {

PyErr_Format(PyExc_SyntaxError,

"nonlocal declaration not allowed at module level");

return error_at_directive(ste, name);

}

if (!PySet_Contains(bound, name)) {

PyErr_Format(PyExc_SyntaxError,

"no binding for nonlocal '%U' found",

name);

return error_at_directive(ste, name);

}

SET_SCOPE(scopes, name, FREE);

ste->ste_free = 1;

return PySet_Add(free, name) >= 0;

}

if (flags & DEF_BOUND) {

SET_SCOPE(scopes, name, LOCAL);

if (PySet_Add(local, name) < 0)

return 0;

if (PySet_Discard(global, name) < 0)

return 0;

return 1;

}

/* If an enclosing block has a binding for this name, it

if (bound && PySet_Contains(bound, name)) {

SET_SCOPE(scopes, name, FREE);

ste->ste_free = 1;

return PySet_Add(free, name) >= 0;

}

/* If a parent has a global statement, then call it global

if (global && PySet_Contains(global, name)) {

SET_SCOPE(scopes, name, GLOBAL_IMPLICIT);

return 1;

}

if (ste->ste_nested)

ste->ste_free = 1;

SET_SCOPE(scopes, name, GLOBAL_IMPLICIT);

return 1;

}

#undef SET_SCOPE

static int

analyze_cells(PyObject *scopes, PyObject *free)

{

PyObject *name, *v, *v_cell;

int success = 0;

Py_ssize_t pos = 0;

v_cell = PyLong_FromLong(CELL);

if (!v_cell)

return 0;

while (PyDict_Next(scopes, &pos, &name, &v)) {

long scope;

assert(PyLong_Check(v));

scope = PyLong_AS_LONG(v);

if (scope != LOCAL)

continue;

if (!PySet_Contains(free, name))

continue;

/* Replace LOCAL with CELL for this name, and remove

if (PyDict_SetItem(scopes, name, v_cell) < 0)

goto error;

if (PySet_Discard(free, name) < 0)

goto error;

}

success = 1;

error:

Py_DECREF(v_cell);

return success;

}

static int

drop_class_free(PySTEntryObject *ste, PyObject *free)

{

int res;

if (!GET_IDENTIFIER(__class__))

return 0;

res = PySet_Discard(free, __class__);

if (res < 0)

return 0;

if (res)

ste->ste_needs_class_closure = 1;

return 1;

}

static int

update_symbols(PyObject *symbols, PyObject *scopes,

PyObject *bound, PyObject *free, int classflag)

{

PyObject *name = NULL, *itr = NULL;

PyObject *v = NULL, *v_scope = NULL, *v_new = NULL, *v_free = NULL;

Py_ssize_t pos = 0;

/* Update scope information for all symbols in this scope */

while (PyDict_Next(symbols, &pos, &name, &v)) {

long scope, flags;

assert(PyLong_Check(v));

flags = PyLong_AS_LONG(v);

v_scope = PyDict_GetItem(scopes, name);

assert(v_scope && PyLong_Check(v_scope));

scope = PyLong_AS_LONG(v_scope);

flags |= (scope << SCOPE_OFFSET);

v_new = PyLong_FromLong(flags);

if (!v_new)

return 0;

if (PyDict_SetItem(symbols, name, v_new) < 0) {

Py_DECREF(v_new);

return 0;

}

Py_DECREF(v_new);

}

/* Record not yet resolved free variables from children (if any) */

v_free = PyLong_FromLong(FREE << SCOPE_OFFSET);

if (!v_free)

return 0;

itr = PyObject_GetIter(free);

if (itr == NULL) {

Py_DECREF(v_free);

return 0;

}

while ((name = PyIter_Next(itr))) {

v = PyDict_GetItemWithError(symbols, name);

/* Handle symbol that already exists in this scope */

if (v) {

/* Handle a free variable in a method of

if (classflag &&

PyLong_AS_LONG(v) & (DEF_BOUND | DEF_GLOBAL)) {

long flags = PyLong_AS_LONG(v) | DEF_FREE_CLASS;

v_new = PyLong_FromLong(flags);

if (!v_new) {

goto error;

}

if (PyDict_SetItem(symbols, name, v_new) < 0) {

Py_DECREF(v_new);

goto error;

}

Py_DECREF(v_new);

}

/* It's a cell, or already free in this scope */

Py_DECREF(name);

continue;

}

else if (PyErr_Occurred()) {

goto error;

}

/* Handle global symbol */

if (bound && !PySet_Contains(bound, name)) {

Py_DECREF(name);

continue; /* it's a global */

}

/* Propagate new free symbol up the lexical stack */

if (PyDict_SetItem(symbols, name, v_free) < 0) {

goto error;

}

Py_DECREF(name);

}

Py_DECREF(itr);

Py_DECREF(v_free);

return 1;

error:

Py_XDECREF(v_free);

Py_XDECREF(itr);

Py_XDECREF(name);

return 0;

}

static int

analyze_child_block(PySTEntryObject *entry, PyObject *bound, PyObject *free,

PyObject *global, PyObject* child_free);

static int

analyze_block(PySTEntryObject *ste, PyObject *bound, PyObject *free,

PyObject *global)

{

PyObject *name, *v, *local = NULL, *scopes = NULL, *newbound = NULL;

PyObject *newglobal = NULL, *newfree = NULL, *allfree = NULL;

PyObject *temp;

int i, success = 0;

Py_ssize_t pos = 0;

local = PySet_New(NULL); /* collect new names bound in block */

if (!local)

goto error;

scopes = PyDict_New(); /* collect scopes defined for each name */

if (!scopes)

goto error;

/* Allocate new global and bound variable dictionaries. These

/* TODO(jhylton): Package these dicts in a struct so that we

newglobal = PySet_New(NULL);

if (!newglobal)

goto error;

newfree = PySet_New(NULL);

if (!newfree)

goto error;

newbound = PySet_New(NULL);

if (!newbound)

goto error;

/* Class namespace has no effect on names visible in

if (ste->ste_type == ClassBlock) {

/* Pass down known globals */

temp = PyNumber_InPlaceOr(newglobal, global);

if (!temp)

goto error;

Py_DECREF(temp);

/* Pass down previously bound symbols */

if (bound) {

temp = PyNumber_InPlaceOr(newbound, bound);

if (!temp)

goto error;

Py_DECREF(temp);

}

}

while (PyDict_Next(ste->ste_symbols, &pos, &name, &v)) {

long flags = PyLong_AS_LONG(v);

if (!analyze_name(ste, scopes, name, flags,

bound, local, free, global))

goto error;

}

/* Populate global and bound sets to be passed to children. */

if (ste->ste_type != ClassBlock) {

/* Add function locals to bound set */

if (ste->ste_type == FunctionBlock) {

temp = PyNumber_InPlaceOr(newbound, local);

if (!temp)

goto error;

Py_DECREF(temp);

}

/* Pass down previously bound symbols */

if (bound) {

temp = PyNumber_InPlaceOr(newbound, bound);

if (!temp)

goto error;

Py_DECREF(temp);

}

/* Pass down known globals */

temp = PyNumber_InPlaceOr(newglobal, global);

if (!temp)

goto error;

Py_DECREF(temp);

}

else {

/* Special-case __class__ */

if (!GET_IDENTIFIER(__class__))

goto error;

if (PySet_Add(newbound, __class__) < 0)

goto error;

}

/* Recursively call analyze_child_block() on each child block.

allfree = PySet_New(NULL);

if (!allfree)

goto error;

for (i = 0; i < PyList_GET_SIZE(ste->ste_children); ++i) {

PyObject *c = PyList_GET_ITEM(ste->ste_children, i);

PySTEntryObject* entry;

assert(c && PySTEntry_Check(c));

entry = (PySTEntryObject*)c;

if (!analyze_child_block(entry, newbound, newfree, newglobal,

allfree))

goto error;

/* Check if any children have free variables */

if (entry->ste_free || entry->ste_child_free)

ste->ste_child_free = 1;

}

temp = PyNumber_InPlaceOr(newfree, allfree);

if (!temp)

goto error;

Py_DECREF(temp);

/* Check if any local variables must be converted to cell variables */

if (ste->ste_type == FunctionBlock && !analyze_cells(scopes, newfree))

goto error;

else if (ste->ste_type == ClassBlock && !drop_class_free(ste, newfree))

goto error;

/* Records the results of the analysis in the symbol table entry */

if (!update_symbols(ste->ste_symbols, scopes, bound, newfree,

ste->ste_type == ClassBlock))

goto error;

temp = PyNumber_InPlaceOr(free, newfree);

if (!temp)

goto error;

Py_DECREF(temp);

success = 1;

error:

Py_XDECREF(scopes);

Py_XDECREF(local);

Py_XDECREF(newbound);

Py_XDECREF(newglobal);

Py_XDECREF(newfree);

Py_XDECREF(allfree);

if (!success)

assert(PyErr_Occurred());

return success;

}

static int

analyze_child_block(PySTEntryObject *entry, PyObject *bound, PyObject *free,

PyObject *global, PyObject* child_free)

{

PyObject *temp_bound = NULL, *temp_global = NULL, *temp_free = NULL;

PyObject *temp;

/* Copy the bound and global dictionaries.

temp_bound = PySet_New(bound);

if (!temp_bound)

goto error;

temp_free = PySet_New(free);

if (!temp_free)

goto error;

temp_global = PySet_New(global);

if (!temp_global)

goto error;

if (!analyze_block(entry, temp_bound, temp_free, temp_global))

goto error;

temp = PyNumber_InPlaceOr(child_free, temp_free);

if (!temp)

goto error;

Py_DECREF(temp);

Py_DECREF(temp_bound);

Py_DECREF(temp_free);

Py_DECREF(temp_global);

return 1;

error:

Py_XDECREF(temp_bound);

Py_XDECREF(temp_free);

Py_XDECREF(temp_global);

return 0;

}

static int

symtable_analyze(struct symtable *st)

{

PyObject *free, *global;

int r;

free = PySet_New(NULL);

if (!free)

return 0;

global = PySet_New(NULL);

if (!global) {

Py_DECREF(free);

return 0;

}

r = analyze_block(st->st_top, NULL, free, global);

Py_DECREF(free);

Py_DECREF(global);

return r;

}

static int

symtable_exit_block(struct symtable *st)

{

Py_ssize_t size;

st->st_cur = NULL;

size = PyList_GET_SIZE(st->st_stack);

if (size) {

if (PyList_SetSlice(st->st_stack, size - 1, size, NULL) < 0)

return 0;

if (--size)

st->st_cur = (PySTEntryObject *)PyList_GET_ITEM(st->st_stack, size - 1);

}

return 1;

}

static int

symtable_enter_block(struct symtable *st, identifier name, _Py_block_ty block,

void *ast, int lineno, int col_offset)

{

PySTEntryObject *prev = NULL, *ste;

ste = ste_new(st, name, block, ast, lineno, col_offset);

if (ste == NULL)

return 0;

if (PyList_Append(st->st_stack, (PyObject *)ste) < 0) {

Py_DECREF(ste);

return 0;

}

prev = st->st_cur;

/* bpo-37757: For now, disallow *all* assignment expressions in the

if (prev) {

ste->ste_comp_iter_expr = prev->ste_comp_iter_expr;

}

/* The entry is owned by the stack. Borrow it for st_cur. */

Py_DECREF(ste);

st->st_cur = ste;

if (block == ModuleBlock)

st->st_global = st->st_cur->ste_symbols;

if (prev) {

if (PyList_Append(prev->ste_children, (PyObject *)ste) < 0) {

return 0;

}

}

return 1;

}