#include "Python.h"

#include "Python-ast.h"

#include "code.h"

#include "symtable.h"

#include "structmember.h"

#define GLOBAL_AFTER_ASSIGN \

"name '%.400s' is assigned to before global declaration"

#define GLOBAL_AFTER_USE \

"name '%.400s' is used prior to global declaration"

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

#define RETURN_VAL_IN_GENERATOR \

"'return' with argument inside generator"

static PySTEntryObject *

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

void *key, int lineno)

{

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 = name;

Py_INCREF(name);

ste->ste_symbols = NULL;

ste->ste_varnames = NULL;

ste->ste_children = NULL;

ste->ste_symbols = PyDict_New();

if (ste->ste_symbols == NULL)

goto fail;

ste->ste_varnames = PyList_New(0);

if (ste->ste_varnames == NULL)

goto fail;

ste->ste_children = PyList_New(0);

if (ste->ste_children == NULL)

goto fail;

ste->ste_type = block;

ste->ste_unoptimized = 0;

ste->ste_nested = 0;

ste->ste_free = 0;

ste->ste_varargs = 0;

ste->ste_varkeywords = 0;

ste->ste_opt_lineno = 0;

ste->ste_tmpname = 0;

ste->ste_lineno = lineno;

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_returns_value = 0;

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

goto fail;

return ste;

fail:

Py_XDECREF(ste);

return NULL;

}

static PyObject *

ste_repr(PySTEntryObject *ste)

{

char buf[256];

PyOS_snprintf(buf, sizeof(buf),

"<symtable entry %.100s(%ld), line %d>",

PyString_AS_STRING(ste->ste_name),

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

return PyString_FromString(buf);

}

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

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},

{"optimized",T_INT, OFF(ste_unoptimized), 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_print */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_compare */

(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_warn(struct symtable *st,

PyObject *warn, const char *msg, int lineno);

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

_Py_block_ty block, void *ast, int lineno);

static int symtable_exit_block(struct symtable *st, void *ast);

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_listcomp(struct symtable *st, expr_ty e);

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

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

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

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_slice(struct symtable *st, slice_ty);

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

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

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

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

dictcomp = NULL;

#define GET_IDENTIFIER(VAR) \

((VAR) ? (VAR) : ((VAR) = PyString_InternFromString(# VAR)))

#define DUPLICATE_ARGUMENT \

"duplicate argument '%s' in function definition"

static struct symtable *

symtable_new(void)

{

struct symtable *st;

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

if (st == NULL)

return NULL;

st->st_filename = NULL;

st->st_symbols = NULL;

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

goto fail;

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

goto fail;

st->st_cur = NULL;

st->st_private = NULL;

return st;

fail:

PySymtable_Free(st);

return NULL;

}

struct symtable *

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

{

struct symtable *st = symtable_new();

asdl_seq *seq;

int i;

if (st == NULL)

return st;

st->st_filename = filename;

st->st_future = future;

if (!GET_IDENTIFIER(top) ||

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

PySymtable_Free(st);

return NULL;

}

st->st_top = st->st_cur;

st->st_cur->ste_unoptimized = OPT_TOPLEVEL;

/* Any other top-level initialization? */

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 Suite_kind:

PyErr_SetString(PyExc_RuntimeError,

"this compiler does not handle Suites");

goto error;

}

if (!symtable_exit_block(st, (void *)mod)) {

PySymtable_Free(st);

return NULL;

}

if (symtable_analyze(st))

return st;

PySymtable_Free(st);

return NULL;

error:

(void) symtable_exit_block(st, (void *)mod);

PySymtable_Free(st);

return NULL;

}

PySymtable_Free(struct symtable *st)

{

Py_XDECREF(st->st_symbols);

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_GetItem(st->st_symbols, k);

if (v) {

assert(PySTEntry_Check(v));

Py_INCREF(v);

}

else {

PyErr_SetString(PyExc_KeyError,

"unknown symbol table entry");

}

Py_DECREF(k);

return (PySTEntryObject *)v;

}

PyST_GetScope(PySTEntryObject *ste, PyObject *name)

{

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

if (!v)

return 0;

assert(PyInt_Check(v));

return (PyInt_AS_LONG(v) >> SCOPE_OFF) & SCOPE_MASK;

}

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

PyObject *o = PyInt_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 *dict, PyObject *name, long flags,

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

PyObject *global)

{

if (flags & DEF_GLOBAL) {

if (flags & DEF_PARAM) {

PyErr_Format(PyExc_SyntaxError,

"name '%s' is local and global",

PyString_AS_STRING(name));

PyErr_SyntaxLocation(ste->ste_table->st_filename,

ste->ste_lineno);

return 0;

}

SET_SCOPE(dict, name, GLOBAL_EXPLICIT);

if (PyDict_SetItem(global, name, Py_None) < 0)

return 0;

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

if (PyDict_DelItem(bound, name) < 0)

return 0;

}

return 1;

}

if (flags & DEF_BOUND) {

SET_SCOPE(dict, name, LOCAL);

if (PyDict_SetItem(local, name, Py_None) < 0)

return 0;

if (PyDict_GetItem(global, name)) {

if (PyDict_DelItem(global, name) < 0)

return 0;

}

return 1;

}

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

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

SET_SCOPE(dict, name, FREE);

ste->ste_free = 1;

if (PyDict_SetItem(free, name, Py_None) < 0)

return 0;

return 1;

}

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

else if (global && PyDict_GetItem(global, name)) {

SET_SCOPE(dict, name, GLOBAL_IMPLICIT);

return 1;

}

else {

if (ste->ste_nested)

ste->ste_free = 1;

SET_SCOPE(dict, name, GLOBAL_IMPLICIT);

return 1;

}

/* Should never get here. */

PyErr_Format(PyExc_SystemError, "failed to set scope for %s",

PyString_AS_STRING(name));

return 0;

}

#undef SET_SCOPE

static int

analyze_cells(PyObject *scope, PyObject *free)

{

PyObject *name, *v, *w;

int success = 0;

Py_ssize_t pos = 0;

w = PyInt_FromLong(CELL);

if (!w)

return 0;

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

long flags;

assert(PyInt_Check(v));

flags = PyInt_AS_LONG(v);

if (flags != LOCAL)

continue;

if (!PyDict_GetItem(free, name))

continue;

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

if (PyDict_SetItem(scope, name, w) < 0)

goto error;

if (PyDict_DelItem(free, name) < 0)

goto error;

}

success = 1;

error:

Py_DECREF(w);

return success;

}

static int

check_unoptimized(const PySTEntryObject* ste) {

char buf[300];

const char* trailer;

if (ste->ste_type != FunctionBlock || !ste->ste_unoptimized

|| !(ste->ste_free || ste->ste_child_free))

return 1;

trailer = (ste->ste_child_free ?

"contains a nested function with free variables" :

"is a nested function");

switch (ste->ste_unoptimized) {

case OPT_TOPLEVEL: /* exec / import * at top-level is fine */

case OPT_EXEC: /* qualified exec is fine */

return 1;

case OPT_IMPORT_STAR:

PyOS_snprintf(buf, sizeof(buf),

"import * is not allowed in function '%.100s' "

"because it %s",

PyString_AS_STRING(ste->ste_name), trailer);

break;

case OPT_BARE_EXEC:

PyOS_snprintf(buf, sizeof(buf),

"unqualified exec is not allowed in function "

"'%.100s' because it %s",

PyString_AS_STRING(ste->ste_name), trailer);

break;

default:

PyOS_snprintf(buf, sizeof(buf),

"function '%.100s' uses import * and bare exec, "

"which are illegal because it %s",

PyString_AS_STRING(ste->ste_name), trailer);

break;

}

PyErr_SetString(PyExc_SyntaxError, buf);

PyErr_SyntaxLocation(ste->ste_table->st_filename,

ste->ste_opt_lineno);

return 0;

}

static int

update_symbols(PyObject *symbols, PyObject *scope,

PyObject *bound, PyObject *free, int classflag)

{

PyObject *name, *v, *u, *w, *free_value = NULL;

Py_ssize_t pos = 0;

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

long i, flags;

assert(PyInt_Check(v));

flags = PyInt_AS_LONG(v);

w = PyDict_GetItem(scope, name);

assert(w && PyInt_Check(w));

i = PyInt_AS_LONG(w);

flags |= (i << SCOPE_OFF);

u = PyInt_FromLong(flags);

if (!u)

return 0;

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

Py_DECREF(u);

return 0;

}

Py_DECREF(u);

}

free_value = PyInt_FromLong(FREE << SCOPE_OFF);

if (!free_value)

return 0;

/* add a free variable when it's only use is for creating a closure */

pos = 0;

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

PyObject *o = PyDict_GetItem(symbols, name);

if (o) {

/* It could be a free variable in a method of

if (classflag &&

PyInt_AS_LONG(o) & (DEF_BOUND | DEF_GLOBAL)) {

long i = PyInt_AS_LONG(o) | DEF_FREE_CLASS;

o = PyInt_FromLong(i);

if (!o) {

Py_DECREF(free_value);

return 0;

}

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

Py_DECREF(o);

Py_DECREF(free_value);

return 0;

}

Py_DECREF(o);

}

/* else it's not free, probably a cell */

continue;

}

if (!PyDict_GetItem(bound, name))

continue; /* it's a global */

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

Py_DECREF(free_value);

return 0;

}

}

Py_DECREF(free_value);

return 1;

}

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, *scope = NULL;

PyObject *newbound = NULL, *newglobal = NULL;

PyObject *newfree = NULL, *allfree = NULL;

int i, success = 0;

Py_ssize_t pos = 0;

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

if (!local)

goto error;

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

if (!scope)

goto error;

/* Allocate new global and bound variable dictionaries. These

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

newglobal = PyDict_New();

if (!newglobal)

goto error;

newbound = PyDict_New();

if (!newbound)

goto error;

newfree = PyDict_New();

if (!newfree)

goto error;

if (ste->ste_type == ClassBlock) {

if (PyDict_Update(newglobal, global) < 0)

goto error;

if (bound)

if (PyDict_Update(newbound, bound) < 0)

goto error;

}

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

long flags = PyInt_AS_LONG(v);

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

bound, local, free, global))

goto error;

}

if (ste->ste_type != ClassBlock) {

if (ste->ste_type == FunctionBlock) {

if (PyDict_Update(newbound, local) < 0)

goto error;

}

if (bound) {

if (PyDict_Update(newbound, bound) < 0)

goto error;

}

if (PyDict_Update(newglobal, global) < 0)

goto error;

}

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

allfree = PyDict_New();

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;

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

ste->ste_child_free = 1;

}

if (PyDict_Update(newfree, allfree) < 0)

goto error;

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

goto error;

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

ste->ste_type == ClassBlock))

goto error;

if (!check_unoptimized(ste))

goto error;

if (PyDict_Update(free, newfree) < 0)

goto error;

success = 1;

error:

Py_XDECREF(local);

Py_XDECREF(scope);

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;

/* Copy the bound and global dictionaries.

temp_bound = PyDict_New();

if (!temp_bound)

goto error;

if (PyDict_Update(temp_bound, bound) < 0)

goto error;

temp_free = PyDict_New();

if (!temp_free)

goto error;

if (PyDict_Update(temp_free, free) < 0)

goto error;

temp_global = PyDict_New();

if (!temp_global)

goto error;

if (PyDict_Update(temp_global, global) < 0)

goto error;

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

goto error;

if (PyDict_Update(child_free, temp_free) < 0)

goto error;

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 = PyDict_New();

if (!free)

return 0;

global = PyDict_New();

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_warn(struct symtable *st, PyObject *warn, const char *msg, int lineno)

{

if (lineno < 0) {

lineno = st->st_cur->ste_lineno;

}

if (PyErr_WarnExplicit(warn, msg, st->st_filename, lineno, NULL, NULL) < 0) {

if (PyErr_ExceptionMatches(warn)) {

/* Replace the warning exception with a SyntaxError

PyErr_Clear();

PyErr_SetString(PyExc_SyntaxError, msg);

PyErr_SyntaxLocation(st->st_filename, lineno);

}

return 0;

}

return 1;

}

static int

symtable_exit_block(struct symtable *st, void *ast)

{

Py_ssize_t end;

Py_CLEAR(st->st_cur);

end = PyList_GET_SIZE(st->st_stack) - 1;

if (end >= 0) {

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

end);

if (st->st_cur == NULL)

return 0;

Py_INCREF(st->st_cur);

if (PySequence_DelItem(st->st_stack, end) < 0)

return 0;

}

return 1;

}

static int

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

void *ast, int lineno)

{

PySTEntryObject *prev = NULL;

if (st->st_cur) {

prev = st->st_cur;

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

return 0;

}

Py_DECREF(st->st_cur);

}

st->st_cur = ste_new(st, name, block, ast, lineno);

if (st->st_cur == NULL)

return 0;

if (block == ModuleBlock)

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

if (prev) {

if (PyList_Append(prev->ste_children,

(PyObject *)st->st_cur) < 0) {

return 0;

}

}

return 1;

}

static long

symtable_lookup(struct symtable *st, PyObject *name)

{

PyObject *o;

PyObject *mangled = _Py_Mangle(st->st_private, name);

if (!mangled)

return 0;

o = PyDict_GetItem(st->st_cur->ste_symbols, mangled);

Py_DECREF(mangled);

if (!o)

return 0;

return PyInt_AsLong(o);

}

static int

symtable_add_def(struct symtable *st, PyObject *name, int flag)

{

PyObject *o;

PyObject *dict;

long val;

PyObject *mangled = _Py_Mangle(st->st_private, name);

if (!mangled)

return 0;

dict = st->st_cur->ste_symbols;

if ((o = PyDict_GetItem(dict, mangled))) {

val = PyInt_AS_LONG(o);

if ((flag & DEF_PARAM) && (val & DEF_PARAM)) {

/* Is it better to use 'mangled' or 'name' here? */

PyErr_Format(PyExc_SyntaxError, DUPLICATE_ARGUMENT,

PyString_AsString(name));

PyErr_SyntaxLocation(st->st_filename,

st->st_cur->ste_lineno);

goto error;

}

val |= flag;

} else

val = flag;

o = PyInt_FromLong(val);

if (o == NULL)

goto error;

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

Py_DECREF(o);

goto error;

}

Py_DECREF(o);

if (flag & DEF_PARAM) {

if (PyList_Append(st->st_cur->ste_varnames, mangled) < 0)

goto error;

} else if (flag & DEF_GLOBAL) {

/* XXX need to update DEF_GLOBAL for other flags too;

val = flag;

if ((o = PyDict_GetItem(st->st_global, mangled))) {

val |= PyInt_AS_LONG(o);

}

o = PyInt_FromLong(val);

if (o == NULL)

goto error;

if (PyDict_SetItem(st->st_global, mangled, o) < 0) {

Py_DECREF(o);

goto error;

}

Py_DECREF(o);

}

Py_DECREF(mangled);

return 1;

error:

Py_DECREF(mangled);

return 0;

}

#define VISIT(ST, TYPE, V) \

if (!symtable_visit_ ## TYPE((ST), (V))) \

return 0;

#define VISIT_IN_BLOCK(ST, TYPE, V, S) \

if (!symtable_visit_ ## TYPE((ST), (V))) { \

symtable_exit_block((ST), (S)); \

return 0; \

}

#define VISIT_SEQ(ST, TYPE, SEQ) { \

int i; \

asdl_seq *seq = (SEQ); /* avoid variable capture */ \

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

#define VISIT_SEQ_IN_BLOCK(ST, TYPE, SEQ, S) { \

int i; \

asdl_seq *seq = (SEQ); /* avoid variable capture */ \

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

#define VISIT_SEQ_TAIL(ST, TYPE, SEQ, START) { \

int i; \

asdl_seq *seq = (SEQ); /* avoid variable capture */ \

for (i = (START); i < asdl_seq_LEN(seq); i++) { \

#define VISIT_SEQ_TAIL_IN_BLOCK(ST, TYPE, SEQ, START, S) { \

int i; \

asdl_seq *seq = (SEQ); /* avoid variable capture */ \

for (i = (START); i < asdl_seq_LEN(seq); i++) { \