#include "Python.h"

#include "Python-ast.h"

#include "grammar.h"

#include "node.h"

#include "pyarena.h"

#include "ast.h"

#include "token.h"

#include "parsetok.h"

#include "graminit.h"

#include <assert.h>

struct compiling {

};

static asdl_seq *seq_for_testlist(struct compiling *, const node *);

static expr_ty ast_for_expr(struct compiling *, const node *);

static stmt_ty ast_for_stmt(struct compiling *, const node *);

static asdl_seq *ast_for_suite(struct compiling *, const node *);

static asdl_seq *ast_for_exprlist(struct compiling *, const node *,

expr_context_ty);

static expr_ty ast_for_testlist(struct compiling *, const node *);

static stmt_ty ast_for_classdef(struct compiling *, const node *, asdl_seq *);

static expr_ty ast_for_testlist_gexp(struct compiling *, const node *);

static expr_ty ast_for_call(struct compiling *, const node *, expr_ty);

static PyObject *parsenumber(struct compiling *, const char *);

static PyObject *parsestr(struct compiling *, const char *);

static PyObject *parsestrplus(struct compiling *, const node *n);

#ifndef LINENO

#define LINENO(n) ((n)->n_lineno)

static identifier

new_identifier(const char* n, PyArena *arena) {

PyObject* id = PyString_InternFromString(n);

if (id != NULL)

PyArena_AddPyObject(arena, id);

return id;

}

#define NEW_IDENTIFIER(n) new_identifier(STR(n), c->c_arena)

static int

ast_error(const node *n, const char *errstr)

{

PyObject *u = Py_BuildValue("zi", errstr, LINENO(n));

if (!u)

return 0;

PyErr_SetObject(PyExc_SyntaxError, u);

Py_DECREF(u);

return 0;

}

static void

ast_error_finish(const char *filename)

{

PyObject *type, *value, *tback, *errstr, *loc, *tmp;

long lineno;

assert(PyErr_Occurred());

if (!PyErr_ExceptionMatches(PyExc_SyntaxError))

return;

PyErr_Fetch(&type, &value, &tback);

errstr = PyTuple_GetItem(value, 0);

if (!errstr)

return;

Py_INCREF(errstr);

lineno = PyInt_AsLong(PyTuple_GetItem(value, 1));

if (lineno == -1) {

Py_DECREF(errstr);

return;

}

Py_DECREF(value);

loc = PyErr_ProgramText(filename, lineno);

if (!loc) {

Py_INCREF(Py_None);

loc = Py_None;

}

tmp = Py_BuildValue("(zlOO)", filename, lineno, Py_None, loc);

Py_DECREF(loc);

if (!tmp) {

Py_DECREF(errstr);

return;

}

value = PyTuple_Pack(2, errstr, tmp);

Py_DECREF(errstr);

Py_DECREF(tmp);

if (!value)

return;

PyErr_Restore(type, value, tback);

}

static int

ast_warn(struct compiling *c, const node *n, char *msg)

{

if (PyErr_WarnExplicit(PyExc_SyntaxWarning, msg, c->c_filename, LINENO(n),

NULL, NULL) < 0) {

/* if -Werr, change it to a SyntaxError */

if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_SyntaxWarning))

ast_error(n, msg);

return 0;

}

return 1;

}

static int

forbidden_check(struct compiling *c, const node *n, const char *x)

{

if (!strcmp(x, "None"))

return ast_error(n, "assignment to None");

if (Py_Py3kWarningFlag && !(strcmp(x, "True") && strcmp(x, "False")) &&

!ast_warn(c, n, "assignment to True or False is forbidden in 3.x"))

return 0;

return 1;

}

static int

num_stmts(const node *n)

{

int i, l;

node *ch;

switch (TYPE(n)) {

case single_input:

if (TYPE(CHILD(n, 0)) == NEWLINE)

return 0;

else

return num_stmts(CHILD(n, 0));

case file_input:

l = 0;

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

ch = CHILD(n, i);

if (TYPE(ch) == stmt)

l += num_stmts(ch);

}

return l;

case stmt:

return num_stmts(CHILD(n, 0));

case compound_stmt:

return 1;

case simple_stmt:

return NCH(n) / 2; /* Divide by 2 to remove count of semi-colons */

case suite:

if (NCH(n) == 1)

return num_stmts(CHILD(n, 0));

else {

l = 0;

for (i = 2; i < (NCH(n) - 1); i++)

l += num_stmts(CHILD(n, i));

return l;

}

default: {

char buf[128];

sprintf(buf, "Non-statement found: %d %d\n",

TYPE(n), NCH(n));

Py_FatalError(buf);

}

}

assert(0);

return 0;

}

PyAST_FromNode(const node *n, PyCompilerFlags *flags, const char *filename,

PyArena *arena)

{

int i, j, k, num;

asdl_seq *stmts = NULL;

stmt_ty s;

node *ch;

struct compiling c;

if (flags && flags->cf_flags & PyCF_SOURCE_IS_UTF8) {

c.c_encoding = "utf-8";

if (TYPE(n) == encoding_decl) {

ast_error(n, "encoding declaration in Unicode string");

goto error;

}

} else if (TYPE(n) == encoding_decl) {

c.c_encoding = STR(n);

n = CHILD(n, 0);

} else {

c.c_encoding = NULL;

}

c.c_future_unicode = flags && flags->cf_flags & CO_FUTURE_UNICODE_LITERALS;

c.c_arena = arena;

c.c_filename = filename;

k = 0;

switch (TYPE(n)) {

case file_input:

stmts = asdl_seq_new(num_stmts(n), arena);

if (!stmts)

return NULL;

for (i = 0; i < NCH(n) - 1; i++) {

ch = CHILD(n, i);

if (TYPE(ch) == NEWLINE)

continue;

REQ(ch, stmt);

num = num_stmts(ch);

if (num == 1) {

s = ast_for_stmt(&c, ch);

if (!s)

goto error;

asdl_seq_SET(stmts, k++, s);

}

else {

ch = CHILD(ch, 0);

REQ(ch, simple_stmt);

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

s = ast_for_stmt(&c, CHILD(ch, j * 2));

if (!s)

goto error;

asdl_seq_SET(stmts, k++, s);

}

}

}

return Module(stmts, arena);

case eval_input: {

expr_ty testlist_ast;

/* XXX Why not gen_for here? */

testlist_ast = ast_for_testlist(&c, CHILD(n, 0));

if (!testlist_ast)

goto error;

return Expression(testlist_ast, arena);

}

case single_input:

if (TYPE(CHILD(n, 0)) == NEWLINE) {

stmts = asdl_seq_new(1, arena);

if (!stmts)

goto error;

asdl_seq_SET(stmts, 0, Pass(n->n_lineno, n->n_col_offset,

arena));

if (!asdl_seq_GET(stmts, 0))

goto error;

return Interactive(stmts, arena);

}

else {

n = CHILD(n, 0);

num = num_stmts(n);

stmts = asdl_seq_new(num, arena);

if (!stmts)

goto error;

if (num == 1) {

s = ast_for_stmt(&c, n);

if (!s)

goto error;

asdl_seq_SET(stmts, 0, s);

}

else {

/* Only a simple_stmt can contain multiple statements. */

REQ(n, simple_stmt);

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

if (TYPE(CHILD(n, i)) == NEWLINE)

break;

s = ast_for_stmt(&c, CHILD(n, i));

if (!s)

goto error;

asdl_seq_SET(stmts, i / 2, s);

}

}

return Interactive(stmts, arena);

}

default:

PyErr_Format(PyExc_SystemError,

"invalid node %d for PyAST_FromNode", TYPE(n));

goto error;

}

error:

ast_error_finish(filename);

return NULL;

}

static operator_ty

get_operator(const node *n)

{

switch (TYPE(n)) {

case VBAR:

return BitOr;

case CIRCUMFLEX:

return BitXor;

case AMPER:

return BitAnd;

case LEFTSHIFT:

return LShift;

case RIGHTSHIFT:

return RShift;

case PLUS:

return Add;

case MINUS:

return Sub;

case STAR:

return Mult;

case SLASH:

return Div;

case DOUBLESLASH:

return FloorDiv;

case PERCENT:

return Mod;

default:

return (operator_ty)0;

}

}

static int

set_context(struct compiling *c, expr_ty e, expr_context_ty ctx, const node *n)

{

asdl_seq *s = NULL;

/* If a particular expression type can't be used for assign / delete,

const char* expr_name = NULL;

/* The ast defines augmented store and load contexts, but the

assert(ctx != AugStore && ctx != AugLoad);

switch (e->kind) {

case Attribute_kind:

if (ctx == Store && !forbidden_check(c, n,

PyBytes_AS_STRING(e->v.Attribute.attr)))

return 0;

e->v.Attribute.ctx = ctx;

break;

case Subscript_kind:

e->v.Subscript.ctx = ctx;

break;

case Name_kind:

if (ctx == Store && !forbidden_check(c, n,

PyBytes_AS_STRING(e->v.Name.id)))

return 0;

e->v.Name.ctx = ctx;

break;

case List_kind:

e->v.List.ctx = ctx;

s = e->v.List.elts;

break;

case Tuple_kind:

if (asdl_seq_LEN(e->v.Tuple.elts) == 0)

return ast_error(n, "can't assign to ()");

e->v.Tuple.ctx = ctx;

s = e->v.Tuple.elts;

break;

case Lambda_kind:

expr_name = "lambda";

break;

case Call_kind:

expr_name = "function call";

break;

case BoolOp_kind:

case BinOp_kind:

case UnaryOp_kind:

expr_name = "operator";

break;

case GeneratorExp_kind:

expr_name = "generator expression";

break;

case Yield_kind:

expr_name = "yield expression";

break;

case ListComp_kind:

expr_name = "list comprehension";

break;

case Dict_kind:

case Num_kind:

case Str_kind:

expr_name = "literal";

break;

case Compare_kind:

expr_name = "comparison";

break;

case Repr_kind:

expr_name = "repr";

break;

case IfExp_kind:

expr_name = "conditional expression";

break;

default:

PyErr_Format(PyExc_SystemError,

"unexpected expression in assignment %d (line %d)",

e->kind, e->lineno);

return 0;

}

/* Check for error string set by switch */

if (expr_name) {

char buf[300];

PyOS_snprintf(buf, sizeof(buf),

"can't %s %s",

ctx == Store ? "assign to" : "delete",

expr_name);

return ast_error(n, buf);

}

/* If the LHS is a list or tuple, we need to set the assignment

if (s) {

int i;

for (i = 0; i < asdl_seq_LEN(s); i++) {

if (!set_context(c, (expr_ty)asdl_seq_GET(s, i), ctx, n))

return 0;

}

}

return 1;

}

static operator_ty

ast_for_augassign(struct compiling *c, const node *n)

{

REQ(n, augassign);

n = CHILD(n, 0);

switch (STR(n)[0]) {

case '+':

return Add;

case '-':

return Sub;

case '/':

if (STR(n)[1] == '/')

return FloorDiv;

else

return Div;

case '%':

return Mod;

case '<':

return LShift;

case '>':

return RShift;

case '&':

return BitAnd;

case '^':

return BitXor;

case '|':

return BitOr;

case '*':

if (STR(n)[1] == '*')

return Pow;

else

return Mult;

default:

PyErr_Format(PyExc_SystemError, "invalid augassign: %s", STR(n));

return (operator_ty)0;

}

}

static cmpop_ty

ast_for_comp_op(struct compiling *c, const node *n)

{

/* comp_op: '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is'

REQ(n, comp_op);

if (NCH(n) == 1) {

n = CHILD(n, 0);

switch (TYPE(n)) {

case LESS:

return Lt;

case GREATER:

return Gt;

case EQEQUAL: /* == */

return Eq;

case LESSEQUAL:

return LtE;

case GREATEREQUAL:

return GtE;

case NOTEQUAL:

return NotEq;

case NAME:

if (strcmp(STR(n), "in") == 0)

return In;

if (strcmp(STR(n), "is") == 0)

return Is;

default:

PyErr_Format(PyExc_SystemError, "invalid comp_op: %s",

STR(n));

return (cmpop_ty)0;

}

}

else if (NCH(n) == 2) {

/* handle "not in" and "is not" */

switch (TYPE(CHILD(n, 0))) {

case NAME:

if (strcmp(STR(CHILD(n, 1)), "in") == 0)

return NotIn;

if (strcmp(STR(CHILD(n, 0)), "is") == 0)

return IsNot;

default:

PyErr_Format(PyExc_SystemError, "invalid comp_op: %s %s",

STR(CHILD(n, 0)), STR(CHILD(n, 1)));

return (cmpop_ty)0;

}

}

PyErr_Format(PyExc_SystemError, "invalid comp_op: has %d children",

NCH(n));

return (cmpop_ty)0;

}

static asdl_seq *

seq_for_testlist(struct compiling *c, const node *n)

{

/* testlist: test (',' test)* [','] */

asdl_seq *seq;

expr_ty expression;

int i;

assert(TYPE(n) == testlist ||

TYPE(n) == listmaker ||

TYPE(n) == testlist_gexp ||

TYPE(n) == testlist_safe ||

TYPE(n) == testlist1);

seq = asdl_seq_new((NCH(n) + 1) / 2, c->c_arena);

if (!seq)

return NULL;

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

assert(TYPE(CHILD(n, i)) == test || TYPE(CHILD(n, i)) == old_test);

expression = ast_for_expr(c, CHILD(n, i));

if (!expression)

return NULL;

assert(i / 2 < seq->size);

asdl_seq_SET(seq, i / 2, expression);

}

return seq;

}

static expr_ty

compiler_complex_args(struct compiling *c, const node *n)

{

int i, len = (NCH(n) + 1) / 2;

expr_ty result;

asdl_seq *args = asdl_seq_new(len, c->c_arena);

if (!args)

return NULL;

/* fpdef: NAME | '(' fplist ')'

REQ(n, fplist);

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

PyObject *arg_id;

const node *fpdef_node = CHILD(n, 2*i);

const node *child;

expr_ty arg;

set_name:

/* fpdef_node is either a NAME or an fplist */

child = CHILD(fpdef_node, 0);

if (TYPE(child) == NAME) {

if (!forbidden_check(c, n, STR(child)))

return NULL;

arg_id = NEW_IDENTIFIER(child);

if (!arg_id)

return NULL;

arg = Name(arg_id, Store, LINENO(child), child->n_col_offset,

c->c_arena);

}

else {

assert(TYPE(fpdef_node) == fpdef);

/* fpdef_node[0] is not a name, so it must be '(', get CHILD[1] */

child = CHILD(fpdef_node, 1);

assert(TYPE(child) == fplist);

/* NCH == 1 means we have (x), we need to elide the extra parens */

if (NCH(child) == 1) {

fpdef_node = CHILD(child, 0);

assert(TYPE(fpdef_node) == fpdef);

goto set_name;

}

arg = compiler_complex_args(c, child);

}

asdl_seq_SET(args, i, arg);

}

result = Tuple(args, Store, LINENO(n), n->n_col_offset, c->c_arena);

if (!set_context(c, result, Store, n))

return NULL;

return result;

}

static arguments_ty

ast_for_arguments(struct compiling *c, const node *n)

{

/* parameters: '(' [varargslist] ')'

int i, j, k, n_args = 0, n_defaults = 0, found_default = 0;

asdl_seq *args, *defaults;

identifier vararg = NULL, kwarg = NULL;

node *ch;

if (TYPE(n) == parameters) {

if (NCH(n) == 2) /* () as argument list */

return arguments(NULL, NULL, NULL, NULL, c->c_arena);

n = CHILD(n, 1);

}

REQ(n, varargslist);

/* first count the number of normal args & defaults */

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

ch = CHILD(n, i);

if (TYPE(ch) == fpdef)

n_args++;

if (TYPE(ch) == EQUAL)

n_defaults++;

}

args = (n_args ? asdl_seq_new(n_args, c->c_arena) : NULL);

if (!args && n_args)

return NULL; /* Don't need to goto error; no objects allocated */

defaults = (n_defaults ? asdl_seq_new(n_defaults, c->c_arena) : NULL);

if (!defaults && n_defaults)

return NULL; /* Don't need to goto error; no objects allocated */

/* fpdef: NAME | '(' fplist ')'

i = 0;

j = 0; /* index for defaults */

k = 0; /* index for args */

while (i < NCH(n)) {

ch = CHILD(n, i);

switch (TYPE(ch)) {

case fpdef: {

int complex_args = 0, parenthesized = 0;

handle_fpdef:

/* XXX Need to worry about checking if TYPE(CHILD(n, i+1)) is

/* XXX Should NCH(n) check be made a separate check? */

if (i + 1 < NCH(n) && TYPE(CHILD(n, i + 1)) == EQUAL) {

expr_ty expression = ast_for_expr(c, CHILD(n, i + 2));

if (!expression)

goto error;

assert(defaults != NULL);

asdl_seq_SET(defaults, j++, expression);

i += 2;

found_default = 1;

}

else if (found_default) {

/* def f((x)=4): pass should raise an error.

if (parenthesized && !complex_args) {

ast_error(n, "parenthesized arg with default");

goto error;

}

ast_error(n,

"non-default argument follows default argument");

goto error;

}

if (NCH(ch) == 3) {

ch = CHILD(ch, 1);

/* def foo((x)): is not complex, special case. */

if (NCH(ch) != 1) {

/* We have complex arguments, setup for unpacking. */

if (Py_Py3kWarningFlag && !ast_warn(c, ch,

"tuple parameter unpacking has been removed in 3.x"))

goto error;

complex_args = 1;

asdl_seq_SET(args, k++, compiler_complex_args(c, ch));

if (!asdl_seq_GET(args, k-1))

goto error;

} else {

/* def foo((x)): setup for checking NAME below. */

/* Loop because there can be many parens and tuple

parenthesized = 1;

ch = CHILD(ch, 0);

assert(TYPE(ch) == fpdef);

goto handle_fpdef;

}

}

if (TYPE(CHILD(ch, 0)) == NAME) {

PyObject *id;

expr_ty name;

if (!forbidden_check(c, n, STR(CHILD(ch, 0))))

goto error;

id = NEW_IDENTIFIER(CHILD(ch, 0));

if (!id)

goto error;

name = Name(id, Param, LINENO(ch), ch->n_col_offset,

c->c_arena);

if (!name)

goto error;

asdl_seq_SET(args, k++, name);

}

i += 2; /* the name and the comma */

if (parenthesized && Py_Py3kWarningFlag &&

!ast_warn(c, ch, "parenthesized argument names "

"are invalid in 3.x"))

goto error;

break;

}

case STAR:

if (!forbidden_check(c, CHILD(n, i+1), STR(CHILD(n, i+1))))

goto error;

vararg = NEW_IDENTIFIER(CHILD(n, i+1));

if (!vararg)

goto error;

i += 3;

break;

case DOUBLESTAR:

if (!forbidden_check(c, CHILD(n, i+1), STR(CHILD(n, i+1))))

goto error;

kwarg = NEW_IDENTIFIER(CHILD(n, i+1));

if (!kwarg)

goto error;

i += 3;

break;

default:

PyErr_Format(PyExc_SystemError,

"unexpected node in varargslist: %d @ %d",

TYPE(ch), i);

goto error;

}

}

return arguments(args, vararg, kwarg, defaults, c->c_arena);

error:

Py_XDECREF(vararg);

Py_XDECREF(kwarg);

return NULL;

}

static expr_ty

ast_for_dotted_name(struct compiling *c, const node *n)

{

expr_ty e;

identifier id;

int lineno, col_offset;

int i;

REQ(n, dotted_name);

lineno = LINENO(n);

col_offset = n->n_col_offset;

id = NEW_IDENTIFIER(CHILD(n, 0));

if (!id)

return NULL;

e = Name(id, Load, lineno, col_offset, c->c_arena);

if (!e)

return NULL;

for (i = 2; i < NCH(n); i+=2) {

id = NEW_IDENTIFIER(CHILD(n, i));

if (!id)

return NULL;

e = Attribute(e, id, Load, lineno, col_offset, c->c_arena);

if (!e)

return NULL;

}

return e;

}

static expr_ty

ast_for_decorator(struct compiling *c, const node *n)

{

/* decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE */

expr_ty d = NULL;

expr_ty name_expr;

REQ(n, decorator);

REQ(CHILD(n, 0), AT);

REQ(RCHILD(n, -1), NEWLINE);

name_expr = ast_for_dotted_name(c, CHILD(n, 1));

if (!name_expr)

return NULL;

if (NCH(n) == 3) { /* No arguments */

d = name_expr;

name_expr = NULL;

}

else if (NCH(n) == 5) { /* Call with no arguments */

d = Call(name_expr, NULL, NULL, NULL, NULL, LINENO(n),

n->n_col_offset, c->c_arena);

if (!d)

return NULL;

name_expr = NULL;

}

else {

d = ast_for_call(c, CHILD(n, 3), name_expr);

if (!d)

return NULL;

name_expr = NULL;

}

return d;

}

static asdl_seq*

ast_for_decorators(struct compiling *c, const node *n)

{

asdl_seq* decorator_seq;

expr_ty d;

int i;

REQ(n, decorators);

decorator_seq = asdl_seq_new(NCH(n), c->c_arena);

if (!decorator_seq)

return NULL;

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

d = ast_for_decorator(c, CHILD(n, i));

if (!d)

return NULL;

asdl_seq_SET(decorator_seq, i, d);

}

return decorator_seq;

}

static stmt_ty

ast_for_funcdef(struct compiling *c, const node *n, asdl_seq *decorator_seq)

{

/* funcdef: 'def' NAME parameters ':' suite */

identifier name;

arguments_ty args;

asdl_seq *body;

int name_i = 1;

REQ(n, funcdef);

name = NEW_IDENTIFIER(CHILD(n, name_i));

if (!name)

return NULL;

else if (!forbidden_check(c, CHILD(n, name_i), STR(CHILD(n, name_i))))

return NULL;

args = ast_for_arguments(c, CHILD(n, name_i + 1));

if (!args)

return NULL;

body = ast_for_suite(c, CHILD(n, name_i + 3));

if (!body)

return NULL;

return FunctionDef(name, args, body, decorator_seq, LINENO(n),

n->n_col_offset, c->c_arena);

}

static stmt_ty

ast_for_decorated(struct compiling *c, const node *n)

{

/* decorated: decorators (classdef | funcdef) */

stmt_ty thing = NULL;

asdl_seq *decorator_seq = NULL;

REQ(n, decorated);

decorator_seq = ast_for_decorators(c, CHILD(n, 0));

if (!decorator_seq)

return NULL;

assert(TYPE(CHILD(n, 1)) == funcdef ||

TYPE(CHILD(n, 1)) == classdef);

if (TYPE(CHILD(n, 1)) == funcdef) {

thing = ast_for_funcdef(c, CHILD(n, 1), decorator_seq);

} else if (TYPE(CHILD(n, 1)) == classdef) {

thing = ast_for_classdef(c, CHILD(n, 1), decorator_seq);

}

/* we count the decorators in when talking about the class' or

if (thing) {

thing->lineno = LINENO(n);

thing->col_offset = n->n_col_offset;

}

return thing;

}

static expr_ty

ast_for_lambdef(struct compiling *c, const node *n)

{

/* lambdef: 'lambda' [varargslist] ':' test */

arguments_ty args;

expr_ty expression;

if (NCH(n) == 3) {

args = arguments(NULL, NULL, NULL, NULL, c->c_arena);

if (!args)

return NULL;

expression = ast_for_expr(c, CHILD(n, 2));

if (!expression)

return NULL;

}

else {

args = ast_for_arguments(c, CHILD(n, 1));

if (!args)

return NULL;

expression = ast_for_expr(c, CHILD(n, 3));

if (!expression)

return NULL;

}

return Lambda(args, expression, LINENO(n), n->n_col_offset, c->c_arena);

}

static expr_ty

ast_for_ifexpr(struct compiling *c, const node *n)

{

/* test: or_test 'if' or_test 'else' test */

expr_ty expression, body, orelse;

assert(NCH(n) == 5);

body = ast_for_expr(c, CHILD(n, 0));

if (!body)

return NULL;

expression = ast_for_expr(c, CHILD(n, 2));

if (!expression)

return NULL;

orelse = ast_for_expr(c, CHILD(n, 4));

if (!orelse)

return NULL;

return IfExp(expression, body, orelse, LINENO(n), n->n_col_offset,

c->c_arena);

}

static int

count_list_fors(struct compiling *c, const node *n)

{

int n_fors = 0;

node *ch = CHILD(n, 1);

count_list_for:

n_fors++;

REQ(ch, list_for);

if (NCH(ch) == 5)