#include "Python.h"

#include "pycore_ast.h" // identifier, stmt_ty

#include "pycore_parser.h" // _PyParser_ASTFromString()

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

#include "pycore_symtable.h" // PySTEntryObject

#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_IN_TYPEVAR_BOUND \

"assignment expression within a comprehension cannot be used in a TypeVar bound"

#define NAMED_EXPR_COMP_IN_TYPEALIAS \

"assignment expression within a comprehension cannot be used in a type alias"

#define NAMED_EXPR_COMP_IN_TYPEPARAM \

"assignment expression within a comprehension cannot be used within the definition of a generic"

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

#define ANNOTATION_NOT_ALLOWED \

"%s cannot be used within an annotation"

#define TYPEVAR_BOUND_NOT_ALLOWED \

"%s cannot be used within a TypeVar bound"

#define TYPEALIAS_NOT_ALLOWED \

"%s cannot be used within a type alias"

#define TYPEPARAM_NOT_ALLOWED \

"%s cannot be used within the definition of a generic"

#define DUPLICATE_TYPE_PARAM \

"duplicate type parameter '%U'"

#define LOCATION(x) \

(x)->lineno, (x)->col_offset, (x)->end_lineno, (x)->end_col_offset

#define ST_LOCATION(x) \

(x)->ste_lineno, (x)->ste_col_offset, (x)->ste_end_lineno, (x)->ste_end_col_offset

static PySTEntryObject *

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

void *key, int lineno, int col_offset,

int end_lineno, int end_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 */

ste->ste_name = Py_NewRef(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;

ste->ste_end_lineno = end_lineno;

ste->ste_end_col_offset = end_col_offset;

if (st->st_cur != NULL &&

(st->st_cur->ste_nested ||

_PyST_IsFunctionLike(st->st_cur)))

ste->ste_nested = 1;

ste->ste_child_free = 0;

ste->ste_generator = 0;

ste->ste_coroutine = 0;

ste->ste_comprehension = NoComprehension;

ste->ste_returns_value = 0;

ste->ste_needs_class_closure = 0;

ste->ste_comp_inlined = 0;

ste->ste_comp_iter_target = 0;

ste->ste_can_see_class_scope = 0;

ste->ste_comp_iter_expr = 0;

ste->ste_needs_classdict = 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_Free(ste);

}

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

static PyMemberDef ste_memberlist[] = {

{"id", _Py_T_OBJECT, OFF(ste_id), Py_READONLY},

{"name", _Py_T_OBJECT, OFF(ste_name), Py_READONLY},

{"symbols", _Py_T_OBJECT, OFF(ste_symbols), Py_READONLY},

{"varnames", _Py_T_OBJECT, OFF(ste_varnames), Py_READONLY},

{"children", _Py_T_OBJECT, OFF(ste_children), Py_READONLY},

{"nested", Py_T_INT, OFF(ste_nested), Py_READONLY},

{"type", Py_T_INT, OFF(ste_type), Py_READONLY},

{"lineno", Py_T_INT, OFF(ste_lineno), Py_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,

int end_lineno, int end_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_type_param(struct symtable *st, type_param_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_arg_seq *args);

static int symtable_visit_annotation(struct symtable *st, expr_ty annotation);

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

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

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

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

static int symtable_visit_match_case(struct symtable *st, match_case_ty m);

static int symtable_visit_pattern(struct symtable *st, pattern_ty s);

static int symtable_raise_if_annotation_block(struct symtable *st, const char *, expr_ty);

static int symtable_raise_if_comprehension_block(struct symtable *st, expr_ty);

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

struct symtable *

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

{

struct symtable *st = symtable_new();

asdl_stmt_seq *seq;

int i;

PyThreadState *tstate;

int starting_recursion_depth;

if (st == NULL)

return NULL;

if (filename == NULL) {

_PySymtable_Free(st);

return NULL;

}

st->st_filename = Py_NewRef(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. */

int recursion_depth = C_RECURSION_LIMIT - tstate->c_recursion_remaining;

starting_recursion_depth = recursion_depth * COMPILER_STACK_FRAME_SCALE;

st->recursion_depth = starting_recursion_depth;

st->recursion_limit = C_RECURSION_LIMIT * COMPILER_STACK_FRAME_SCALE;

/* Make the initial symbol information gathering pass */

if (!symtable_enter_block(st, &_Py_ID(top), ModuleBlock, (void *)mod, 0, 0, 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;

}

_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);

Py_DECREF(k);

if (v) {

assert(PySTEntry_Check(v));

}

else if (!PyErr_Occurred()) {

PyErr_SetString(PyExc_KeyError,

"unknown symbol table entry");

}

return (PySTEntryObject *)Py_XNewRef(v);

}

_PyST_GetSymbol(PySTEntryObject *ste, PyObject *name)

{

PyObject *v = PyDict_GetItemWithError(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;

}

_PyST_IsFunctionLike(PySTEntryObject *ste)

{

return ste->ste_type == FunctionBlock

|| ste->ste_type == TypeVarBoundBlock

|| ste->ste_type == TypeAliasBlock

|| ste->ste_type == TypeParamBlock;

}

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_RangedSyntaxLocationObject(ste->ste_table->st_filename,

PyLong_AsLong(PyTuple_GET_ITEM(data, 1)),

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

PyLong_AsLong(PyTuple_GET_ITEM(data, 3)),

PyLong_AsLong(PyTuple_GET_ITEM(data, 4)) + 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, PyObject *type_params, PySTEntryObject *class_entry)

{

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);

}

if (PySet_Contains(type_params, name)) {

PyErr_Format(PyExc_SyntaxError,

"nonlocal binding not allowed for type parameter '%U'",

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;

if (flags & DEF_TYPE_PARAM) {

if (PySet_Add(type_params, name) < 0)

return 0;

}

else {

if (PySet_Discard(type_params, name) < 0)

return 0;

}

return 1;

}

// If we were passed class_entry (i.e., we're in an ste_can_see_class_scope scope)

// and the bound name is in that set, then the name is potentially bound both by

// the immediately enclosing class namespace, and also by an outer function namespace.

// In that case, we want the runtime name resolution to look at only the class

// namespace and the globals (not the namespace providing the bound).

// Similarly, if the name is explicitly global in the class namespace (through the

// global statement), we want to also treat it as a global in this scope.

if (class_entry != NULL) {

long class_flags = _PyST_GetSymbol(class_entry, name);

if (class_flags & DEF_GLOBAL) {

SET_SCOPE(scopes, name, GLOBAL_EXPLICIT);

return 1;

}

else if (class_flags & DEF_BOUND && !(class_flags & DEF_NONLOCAL)) {

SET_SCOPE(scopes, name, GLOBAL_IMPLICIT);

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;

}

static int

is_free_in_any_child(PySTEntryObject *entry, PyObject *key)

{

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

PySTEntryObject *child_ste = (PySTEntryObject *)PyList_GET_ITEM(

entry->ste_children, i);

long scope = _PyST_GetScope(child_ste, key);

if (scope == FREE) {

return 1;

}

}

return 0;

}

static int

inline_comprehension(PySTEntryObject *ste, PySTEntryObject *comp,

PyObject *scopes, PyObject *comp_free,

PyObject *inlined_cells)

{

PyObject *k, *v;

Py_ssize_t pos = 0;

while (PyDict_Next(comp->ste_symbols, &pos, &k, &v)) {

// skip comprehension parameter

long comp_flags = PyLong_AS_LONG(v);

if (comp_flags & DEF_PARAM) {

assert(_PyUnicode_EqualToASCIIString(k, ".0"));

continue;

}

int scope = (comp_flags >> SCOPE_OFFSET) & SCOPE_MASK;

int only_flags = comp_flags & ((1 << SCOPE_OFFSET) - 1);

if (scope == CELL || only_flags & DEF_COMP_CELL) {

if (PySet_Add(inlined_cells, k) < 0) {

return 0;

}

}

PyObject *existing = PyDict_GetItemWithError(ste->ste_symbols, k);

if (existing == NULL && PyErr_Occurred()) {

return 0;

}

if (!existing) {

// name does not exist in scope, copy from comprehension

assert(scope != FREE || PySet_Contains(comp_free, k) == 1);

PyObject *v_flags = PyLong_FromLong(only_flags);

if (v_flags == NULL) {

return 0;

}

int ok = PyDict_SetItem(ste->ste_symbols, k, v_flags);

Py_DECREF(v_flags);

if (ok < 0) {

return 0;

}

SET_SCOPE(scopes, k, scope);

}

else {

if (PyLong_AsLong(existing) & DEF_BOUND) {

// free vars in comprehension that are locals in outer scope can

// now simply be locals, unless they are free in comp children,

// or if the outer scope is a class block

if (!is_free_in_any_child(comp, k) && ste->ste_type != ClassBlock) {

if (PySet_Discard(comp_free, k) < 0) {

return 0;

}

}

}

}

}

return 1;

}

#undef SET_SCOPE

static int

analyze_cells(PyObject *scopes, PyObject *free, PyObject *inlined_cells)

{

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) && !PySet_Contains(inlined_cells, 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;

res = PySet_Discard(free, &_Py_ID(__class__));

if (res < 0)

return 0;

if (res)

ste->ste_needs_class_closure = 1;

res = PySet_Discard(free, &_Py_ID(__classdict__));

if (res < 0)

return 0;

if (res)

ste->ste_needs_classdict = 1;

return 1;

}

static int

update_symbols(PyObject *symbols, PyObject *scopes,

PyObject *bound, PyObject *free,

PyObject *inlined_cells, 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);

if (PySet_Contains(inlined_cells, name)) {

flags |= DEF_COMP_CELL;

}

v_scope = PyDict_GetItemWithError(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 *type_params,

PySTEntryObject *class_entry, PyObject **child_free);

static int

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

PyObject *global, PyObject *type_params,

PySTEntryObject *class_entry)

{

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

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

PyObject *temp;

int success = 0;

Py_ssize_t i, 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, bound and free variable sets. 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;

inlined_cells = PySet_New(NULL);

if (!inlined_cells)

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, type_params, class_entry))

goto error;

}

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

if (ste->ste_type != ClassBlock) {

/* Add function locals to bound set */

if (_PyST_IsFunctionLike(ste)) {

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__ and __classdict__ */

if (PySet_Add(newbound, &_Py_ID(__class__)) < 0)

goto error;

if (PySet_Add(newbound, &_Py_ID(__classdict__)) < 0)

goto error;

}

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

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

PyObject *child_free = NULL;

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

PySTEntryObject* entry;

assert(c && PySTEntry_Check(c));

entry = (PySTEntryObject*)c;

PySTEntryObject *new_class_entry = NULL;

if (entry->ste_can_see_class_scope) {

if (ste->ste_type == ClassBlock) {

new_class_entry = ste;

}

else if (class_entry) {

new_class_entry = class_entry;

}

}

// we inline all non-generator-expression comprehensions

int inline_comp =

entry->ste_comprehension &&

!entry->ste_generator;

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

type_params, new_class_entry, &child_free))

{

goto error;