/*

* This file includes functions to transform a concrete syntax tree (CST) to

* an abstract syntax tree (AST). The main function is PyAST_FromNode().

*

*/

#include "Python.h"

#include "Python-ast.h"

#include "node.h"

#include "ast.h"

#include "token.h"

#include "pythonrun.h"

#include <assert.h>

#include <stdbool.h>

static int validate_stmts(asdl_seq *);

static int validate_exprs(asdl_seq *, expr_context_ty, int);

static int validate_nonempty_seq(asdl_seq *, const char *, const char *);

static int validate_stmt(stmt_ty);

static int validate_expr(expr_ty, expr_context_ty);

static int

validate_comprehension(asdl_seq *gens)

{

int i;

if (!asdl_seq_LEN(gens)) {

PyErr_SetString(PyExc_ValueError, "comprehension with no generators");

return 0;

}

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

comprehension_ty comp = asdl_seq_GET(gens, i);

if (!validate_expr(comp->target, Store) ||

!validate_expr(comp->iter, Load) ||

!validate_exprs(comp->ifs, Load, 0))

return 0;

}

return 1;

}

static int

validate_slice(slice_ty slice)

{

switch (slice->kind) {

case Slice_kind:

return (!slice->v.Slice.lower || validate_expr(slice->v.Slice.lower, Load)) &&

(!slice->v.Slice.upper || validate_expr(slice->v.Slice.upper, Load)) &&

(!slice->v.Slice.step || validate_expr(slice->v.Slice.step, Load));

case ExtSlice_kind: {

int i;

if (!validate_nonempty_seq(slice->v.ExtSlice.dims, "dims", "ExtSlice"))

return 0;

for (i = 0; i < asdl_seq_LEN(slice->v.ExtSlice.dims); i++)

if (!validate_slice(asdl_seq_GET(slice->v.ExtSlice.dims, i)))

return 0;

return 1;

}

case Index_kind:

return validate_expr(slice->v.Index.value, Load);

default:

PyErr_SetString(PyExc_SystemError, "unknown slice node");

return 0;

}

}

static int

validate_keywords(asdl_seq *keywords)

{

int i;

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

if (!validate_expr(((keyword_ty)asdl_seq_GET(keywords, i))->value, Load))

return 0;

return 1;

}

static int

validate_args(asdl_seq *args)

{

int i;

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

arg_ty arg = asdl_seq_GET(args, i);

if (arg->annotation && !validate_expr(arg->annotation, Load))

return 0;

}

return 1;

}

static const char *

expr_context_name(expr_context_ty ctx)

{

switch (ctx) {

case Load:

return "Load";

case Store:

return "Store";

case Del:

return "Del";

case AugLoad:

return "AugLoad";

case AugStore:

return "AugStore";

case Param:

return "Param";

default:

Py_UNREACHABLE();

}

}

static int

validate_arguments(arguments_ty args)

{

if (!validate_args(args->args))

return 0;

if (args->vararg && args->vararg->annotation

&& !validate_expr(args->vararg->annotation, Load)) {

return 0;

}

if (!validate_args(args->kwonlyargs))

return 0;

if (args->kwarg && args->kwarg->annotation

&& !validate_expr(args->kwarg->annotation, Load)) {

return 0;

}

if (asdl_seq_LEN(args->defaults) > asdl_seq_LEN(args->args)) {

PyErr_SetString(PyExc_ValueError, "more positional defaults than args on arguments");

return 0;

}

if (asdl_seq_LEN(args->kw_defaults) != asdl_seq_LEN(args->kwonlyargs)) {

PyErr_SetString(PyExc_ValueError, "length of kwonlyargs is not the same as "

"kw_defaults on arguments");

return 0;

}

return validate_exprs(args->defaults, Load, 0) && validate_exprs(args->kw_defaults, Load, 1);

}

static int

validate_constant(PyObject *value)

{

if (value == Py_None || value == Py_Ellipsis)

return 1;

if (PyLong_CheckExact(value)

|| PyFloat_CheckExact(value)

|| PyComplex_CheckExact(value)

|| PyBool_Check(value)

|| PyUnicode_CheckExact(value)

|| PyBytes_CheckExact(value))

return 1;

if (PyTuple_CheckExact(value) || PyFrozenSet_CheckExact(value)) {

PyObject *it;

it = PyObject_GetIter(value);

if (it == NULL)

return 0;

while (1) {

PyObject *item = PyIter_Next(it);

if (item == NULL) {

if (PyErr_Occurred()) {

Py_DECREF(it);

return 0;

}

break;

}

if (!validate_constant(item)) {

Py_DECREF(it);

Py_DECREF(item);

return 0;

}

Py_DECREF(item);

}

Py_DECREF(it);

return 1;

}

return 0;

}

static int

validate_expr(expr_ty exp, expr_context_ty ctx)

{

int check_ctx = 1;

expr_context_ty actual_ctx;

/* First check expression context. */

switch (exp->kind) {

case Attribute_kind:

actual_ctx = exp->v.Attribute.ctx;

break;

case Subscript_kind:

actual_ctx = exp->v.Subscript.ctx;

break;

case Starred_kind:

actual_ctx = exp->v.Starred.ctx;

break;

case Name_kind:

actual_ctx = exp->v.Name.ctx;

break;

case List_kind:

actual_ctx = exp->v.List.ctx;

break;

case Tuple_kind:

actual_ctx = exp->v.Tuple.ctx;

break;

default:

if (ctx != Load) {

PyErr_Format(PyExc_ValueError, "expression which can't be "

"assigned to in %s context", expr_context_name(ctx));

return 0;

}

check_ctx = 0;

/* set actual_ctx to prevent gcc warning */

actual_ctx = 0;

}

if (check_ctx && actual_ctx != ctx) {

PyErr_Format(PyExc_ValueError, "expression must have %s context but has %s instead",

expr_context_name(ctx), expr_context_name(actual_ctx));

return 0;

}

/* Now validate expression. */

switch (exp->kind) {

case BoolOp_kind:

if (asdl_seq_LEN(exp->v.BoolOp.values) < 2) {

PyErr_SetString(PyExc_ValueError, "BoolOp with less than 2 values");

return 0;

}

return validate_exprs(exp->v.BoolOp.values, Load, 0);

case BinOp_kind:

return validate_expr(exp->v.BinOp.left, Load) &&

validate_expr(exp->v.BinOp.right, Load);

case UnaryOp_kind:

return validate_expr(exp->v.UnaryOp.operand, Load);

case Lambda_kind:

return validate_arguments(exp->v.Lambda.args) &&

validate_expr(exp->v.Lambda.body, Load);

case IfExp_kind:

return validate_expr(exp->v.IfExp.test, Load) &&

validate_expr(exp->v.IfExp.body, Load) &&

validate_expr(exp->v.IfExp.orelse, Load);

case Dict_kind:

if (asdl_seq_LEN(exp->v.Dict.keys) != asdl_seq_LEN(exp->v.Dict.values)) {

PyErr_SetString(PyExc_ValueError,

"Dict doesn't have the same number of keys as values");

return 0;

}

/* null_ok=1 for keys expressions to allow dict unpacking to work in

dict literals, i.e. ``{**{a:b}}`` */

return validate_exprs(exp->v.Dict.keys, Load, /*null_ok=*/ 1) &&

validate_exprs(exp->v.Dict.values, Load, /*null_ok=*/ 0);

case Set_kind:

return validate_exprs(exp->v.Set.elts, Load, 0);

#define COMP(NAME) \

case NAME ## _kind: \

return validate_comprehension(exp->v.NAME.generators) && \

validate_expr(exp->v.NAME.elt, Load);

COMP(ListComp)

COMP(SetComp)

COMP(GeneratorExp)

#undef COMP

case DictComp_kind:

return validate_comprehension(exp->v.DictComp.generators) &&

validate_expr(exp->v.DictComp.key, Load) &&

validate_expr(exp->v.DictComp.value, Load);

case Yield_kind:

return !exp->v.Yield.value || validate_expr(exp->v.Yield.value, Load);

case YieldFrom_kind:

return validate_expr(exp->v.YieldFrom.value, Load);

case Await_kind:

return validate_expr(exp->v.Await.value, Load);

case Compare_kind:

if (!asdl_seq_LEN(exp->v.Compare.comparators)) {

PyErr_SetString(PyExc_ValueError, "Compare with no comparators");

return 0;

}

if (asdl_seq_LEN(exp->v.Compare.comparators) !=

asdl_seq_LEN(exp->v.Compare.ops)) {

PyErr_SetString(PyExc_ValueError, "Compare has a different number "

"of comparators and operands");

return 0;

}

return validate_exprs(exp->v.Compare.comparators, Load, 0) &&

validate_expr(exp->v.Compare.left, Load);

case Call_kind:

return validate_expr(exp->v.Call.func, Load) &&

validate_exprs(exp->v.Call.args, Load, 0) &&

validate_keywords(exp->v.Call.keywords);

case Constant_kind:

if (!validate_constant(exp->v.Constant.value)) {

PyErr_Format(PyExc_TypeError,

"got an invalid type in Constant: %s",

Py_TYPE(exp->v.Constant.value)->tp_name);

return 0;

}

return 1;

case Num_kind: {

PyObject *n = exp->v.Num.n;

if (!PyLong_CheckExact(n) && !PyFloat_CheckExact(n) &&

!PyComplex_CheckExact(n)) {

PyErr_SetString(PyExc_TypeError, "non-numeric type in Num");

return 0;

}

return 1;

}

case Str_kind: {

PyObject *s = exp->v.Str.s;

if (!PyUnicode_CheckExact(s)) {

PyErr_SetString(PyExc_TypeError, "non-string type in Str");

return 0;

}

return 1;

}

case JoinedStr_kind:

return validate_exprs(exp->v.JoinedStr.values, Load, 0);

case FormattedValue_kind:

if (validate_expr(exp->v.FormattedValue.value, Load) == 0)

return 0;

if (exp->v.FormattedValue.format_spec)

return validate_expr(exp->v.FormattedValue.format_spec, Load);

return 1;

case Bytes_kind: {

PyObject *b = exp->v.Bytes.s;

if (!PyBytes_CheckExact(b)) {

PyErr_SetString(PyExc_TypeError, "non-bytes type in Bytes");

return 0;

}

return 1;

}

case Attribute_kind:

return validate_expr(exp->v.Attribute.value, Load);

case Subscript_kind:

return validate_slice(exp->v.Subscript.slice) &&

validate_expr(exp->v.Subscript.value, Load);

case Starred_kind:

return validate_expr(exp->v.Starred.value, ctx);

case List_kind:

return validate_exprs(exp->v.List.elts, ctx, 0);

case Tuple_kind:

return validate_exprs(exp->v.Tuple.elts, ctx, 0);

/* These last cases don't have any checking. */

case Name_kind:

case NameConstant_kind:

case Ellipsis_kind:

return 1;

default:

PyErr_SetString(PyExc_SystemError, "unexpected expression");

return 0;

}

}

static int

validate_nonempty_seq(asdl_seq *seq, const char *what, const char *owner)

{

if (asdl_seq_LEN(seq))

return 1;

PyErr_Format(PyExc_ValueError, "empty %s on %s", what, owner);

return 0;

}

static int

validate_assignlist(asdl_seq *targets, expr_context_ty ctx)

{

return validate_nonempty_seq(targets, "targets", ctx == Del ? "Delete" : "Assign") &&

validate_exprs(targets, ctx, 0);

}

static int

validate_body(asdl_seq *body, const char *owner)

{

return validate_nonempty_seq(body, "body", owner) && validate_stmts(body);

}

static int

validate_stmt(stmt_ty stmt)

{

int i;

switch (stmt->kind) {

case FunctionDef_kind:

return validate_body(stmt->v.FunctionDef.body, "FunctionDef") &&

validate_arguments(stmt->v.FunctionDef.args) &&

validate_exprs(stmt->v.FunctionDef.decorator_list, Load, 0) &&

(!stmt->v.FunctionDef.returns ||

validate_expr(stmt->v.FunctionDef.returns, Load));

case ClassDef_kind:

return validate_body(stmt->v.ClassDef.body, "ClassDef") &&

validate_exprs(stmt->v.ClassDef.bases, Load, 0) &&

validate_keywords(stmt->v.ClassDef.keywords) &&

validate_exprs(stmt->v.ClassDef.decorator_list, Load, 0);

case Return_kind:

return !stmt->v.Return.value || validate_expr(stmt->v.Return.value, Load);

case Delete_kind:

return validate_assignlist(stmt->v.Delete.targets, Del);

case Assign_kind:

return validate_assignlist(stmt->v.Assign.targets, Store) &&

validate_expr(stmt->v.Assign.value, Load);

case AugAssign_kind:

return validate_expr(stmt->v.AugAssign.target, Store) &&

validate_expr(stmt->v.AugAssign.value, Load);

case AnnAssign_kind:

if (stmt->v.AnnAssign.target->kind != Name_kind &&

stmt->v.AnnAssign.simple) {

PyErr_SetString(PyExc_TypeError,

"AnnAssign with simple non-Name target");

return 0;

}

return validate_expr(stmt->v.AnnAssign.target, Store) &&

(!stmt->v.AnnAssign.value ||

validate_expr(stmt->v.AnnAssign.value, Load)) &&

validate_expr(stmt->v.AnnAssign.annotation, Load);

case For_kind:

return validate_expr(stmt->v.For.target, Store) &&

validate_expr(stmt->v.For.iter, Load) &&

validate_body(stmt->v.For.body, "For") &&

validate_stmts(stmt->v.For.orelse);

case AsyncFor_kind:

return validate_expr(stmt->v.AsyncFor.target, Store) &&

validate_expr(stmt->v.AsyncFor.iter, Load) &&

validate_body(stmt->v.AsyncFor.body, "AsyncFor") &&

validate_stmts(stmt->v.AsyncFor.orelse);

case While_kind:

return validate_expr(stmt->v.While.test, Load) &&

validate_body(stmt->v.While.body, "While") &&

validate_stmts(stmt->v.While.orelse);

case If_kind:

return validate_expr(stmt->v.If.test, Load) &&

validate_body(stmt->v.If.body, "If") &&

validate_stmts(stmt->v.If.orelse);

case With_kind:

if (!validate_nonempty_seq(stmt->v.With.items, "items", "With"))

return 0;

for (i = 0; i < asdl_seq_LEN(stmt->v.With.items); i++) {

withitem_ty item = asdl_seq_GET(stmt->v.With.items, i);

if (!validate_expr(item->context_expr, Load) ||

(item->optional_vars && !validate_expr(item->optional_vars, Store)))

return 0;

}

return validate_body(stmt->v.With.body, "With");

case AsyncWith_kind:

if (!validate_nonempty_seq(stmt->v.AsyncWith.items, "items", "AsyncWith"))

return 0;

for (i = 0; i < asdl_seq_LEN(stmt->v.AsyncWith.items); i++) {

withitem_ty item = asdl_seq_GET(stmt->v.AsyncWith.items, i);

if (!validate_expr(item->context_expr, Load) ||

(item->optional_vars && !validate_expr(item->optional_vars, Store)))

return 0;

}

return validate_body(stmt->v.AsyncWith.body, "AsyncWith");

case Raise_kind:

if (stmt->v.Raise.exc) {

return validate_expr(stmt->v.Raise.exc, Load) &&

(!stmt->v.Raise.cause || validate_expr(stmt->v.Raise.cause, Load));

}

if (stmt->v.Raise.cause) {

PyErr_SetString(PyExc_ValueError, "Raise with cause but no exception");

return 0;

}

return 1;

case Try_kind:

if (!validate_body(stmt->v.Try.body, "Try"))

return 0;

if (!asdl_seq_LEN(stmt->v.Try.handlers) &&

!asdl_seq_LEN(stmt->v.Try.finalbody)) {

PyErr_SetString(PyExc_ValueError, "Try has neither except handlers nor finalbody");

return 0;

}

if (!asdl_seq_LEN(stmt->v.Try.handlers) &&

asdl_seq_LEN(stmt->v.Try.orelse)) {

PyErr_SetString(PyExc_ValueError, "Try has orelse but no except handlers");

return 0;

}

for (i = 0; i < asdl_seq_LEN(stmt->v.Try.handlers); i++) {

excepthandler_ty handler = asdl_seq_GET(stmt->v.Try.handlers, i);

if ((handler->v.ExceptHandler.type &&

!validate_expr(handler->v.ExceptHandler.type, Load)) ||

!validate_body(handler->v.ExceptHandler.body, "ExceptHandler"))

return 0;

}

return (!asdl_seq_LEN(stmt->v.Try.finalbody) ||

validate_stmts(stmt->v.Try.finalbody)) &&

(!asdl_seq_LEN(stmt->v.Try.orelse) ||

validate_stmts(stmt->v.Try.orelse));

case Assert_kind:

return validate_expr(stmt->v.Assert.test, Load) &&

(!stmt->v.Assert.msg || validate_expr(stmt->v.Assert.msg, Load));

case Import_kind:

return validate_nonempty_seq(stmt->v.Import.names, "names", "Import");

case ImportFrom_kind:

if (stmt->v.ImportFrom.level < 0) {

PyErr_SetString(PyExc_ValueError, "Negative ImportFrom level");

return 0;

}

return validate_nonempty_seq(stmt->v.ImportFrom.names, "names", "ImportFrom");

case Global_kind:

return validate_nonempty_seq(stmt->v.Global.names, "names", "Global");

case Nonlocal_kind:

return validate_nonempty_seq(stmt->v.Nonlocal.names, "names", "Nonlocal");

case Expr_kind:

return validate_expr(stmt->v.Expr.value, Load);

case AsyncFunctionDef_kind:

return validate_body(stmt->v.AsyncFunctionDef.body, "AsyncFunctionDef") &&

validate_arguments(stmt->v.AsyncFunctionDef.args) &&

validate_exprs(stmt->v.AsyncFunctionDef.decorator_list, Load, 0) &&

(!stmt->v.AsyncFunctionDef.returns ||

validate_expr(stmt->v.AsyncFunctionDef.returns, Load));

case Pass_kind:

case Break_kind:

case Continue_kind:

return 1;

default:

PyErr_SetString(PyExc_SystemError, "unexpected statement");

return 0;

}

}

static int

validate_stmts(asdl_seq *seq)

{

int i;

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

stmt_ty stmt = asdl_seq_GET(seq, i);

if (stmt) {

if (!validate_stmt(stmt))

return 0;

}

else {

PyErr_SetString(PyExc_ValueError,

"None disallowed in statement list");

return 0;

}

}

return 1;

}

static int

validate_exprs(asdl_seq *exprs, expr_context_ty ctx, int null_ok)

{

int i;

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

expr_ty expr = asdl_seq_GET(exprs, i);

if (expr) {

if (!validate_expr(expr, ctx))

return 0;

}

else if (!null_ok) {

PyErr_SetString(PyExc_ValueError,

"None disallowed in expression list");

return 0;

}

}

return 1;

}

int

PyAST_Validate(mod_ty mod)

{

int res = 0;

switch (mod->kind) {

case Module_kind:

res = validate_stmts(mod->v.Module.body);

break;

case Interactive_kind:

res = validate_stmts(mod->v.Interactive.body);

break;

case Expression_kind:

res = validate_expr(mod->v.Expression.body, Load);

break;

case Suite_kind:

PyErr_SetString(PyExc_ValueError, "Suite is not valid in the CPython compiler");

break;

default:

PyErr_SetString(PyExc_SystemError, "impossible module node");

res = 0;

break;

}

return res;

}

/* This is done here, so defines like "test" don't interfere with AST use above. */

#include "grammar.h"

#include "parsetok.h"

#include "graminit.h"

/* Data structure used internally */

struct compiling {

PyArena *c_arena; /* Arena for allocating memory. */

PyObject *c_filename; /* filename */

PyObject *c_normalize; /* Normalization function from unicodedata. */

};

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 *c, const node *n);

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 stmt_ty ast_for_with_stmt(struct compiling *, const node *, bool);

static stmt_ty ast_for_for_stmt(struct compiling *, const node *, bool);

/* Note different signature for ast_for_call */

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

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

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

#define COMP_GENEXP 0

#define COMP_LISTCOMP 1

#define COMP_SETCOMP 2

static int

init_normalization(struct compiling *c)

{

PyObject *m = PyImport_ImportModuleNoBlock("unicodedata");

if (!m)

return 0;

c->c_normalize = PyObject_GetAttrString(m, "normalize");

Py_DECREF(m);

if (!c->c_normalize)

return 0;

return 1;

}

static identifier

new_identifier(const char *n, struct compiling *c)

{

PyObject *id = PyUnicode_DecodeUTF8(n, strlen(n), NULL);

if (!id)

return NULL;

/* PyUnicode_DecodeUTF8 should always return a ready string. */

assert(PyUnicode_IS_READY(id));

/* Check whether there are non-ASCII characters in the

identifier; if so, normalize to NFKC. */

if (!PyUnicode_IS_ASCII(id)) {

PyObject *id2;

_Py_IDENTIFIER(NFKC);

if (!c->c_normalize && !init_normalization(c)) {

Py_DECREF(id);

return NULL;

}

PyObject *form = _PyUnicode_FromId(&PyId_NFKC);

if (form == NULL) {

Py_DECREF(id);

return NULL;

}

PyObject *args[2] = {form, id};

id2 = _PyObject_FastCall(c->c_normalize, args, 2);

Py_DECREF(id);

if (!id2)

return NULL;

if (!PyUnicode_Check(id2)) {

PyErr_Format(PyExc_TypeError,

"unicodedata.normalize() must return a string, not "

"%.200s",

Py_TYPE(id2)->tp_name);

Py_DECREF(id2);

return NULL;

}

id = id2;

}

PyUnicode_InternInPlace(&id);

if (PyArena_AddPyObject(c->c_arena, id) < 0) {

Py_DECREF(id);

return NULL;

}

return id;

}

#define NEW_IDENTIFIER(n) new_identifier(STR(n), c)

static int

ast_error(struct compiling *c, const node *n, const char *errmsg)

{

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

loc = PyErr_ProgramTextObject(c->c_filename, LINENO(n));

if (!loc) {

Py_INCREF(Py_None);

loc = Py_None;

}

tmp = Py_BuildValue("(OiiN)", c->c_filename, LINENO(n), n->n_col_offset, loc);

if (!tmp)

return 0;

errstr = PyUnicode_FromString(errmsg);

if (!errstr) {

Py_DECREF(tmp);

return 0;

}

value = PyTuple_Pack(2, errstr, tmp);

Py_DECREF(errstr);

Py_DECREF(tmp);

if (value) {

PyErr_SetObject(PyExc_SyntaxError, value);

Py_DECREF(value);

}

return 0;

}

/* num_stmts() returns number of contained statements.

Use this routine to determine how big a sequence is needed for

the statements in a parse tree. Its raison d'etre is this bit of

grammar:

stmt: simple_stmt | compound_stmt

simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE

A simple_stmt can contain multiple small_stmt elements joined

by semicolons. If the arg is a simple_stmt, the number of

small_stmt elements is returned.

*/

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

TYPE(n), NCH(n));

Py_FatalError(buf);

}

}

Py_UNREACHABLE();

}

/* Transform the CST rooted at node * to the appropriate AST

*/

mod_ty

PyAST_FromNodeObject(const node *n, PyCompilerFlags *flags,

PyObject *filename, PyArena *arena)

{

int i, j, k, num;

asdl_seq *stmts = NULL;

stmt_ty s;

node *ch;

struct compiling c;

mod_ty res = NULL;

c.c_arena = arena;

/* borrowed reference */

c.c_filename = filename;

c.c_normalize = NULL;

if (TYPE(n) == encoding_decl)

n = CHILD(n, 0);

k = 0;

switch (TYPE(n)) {

case file_input:

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

if (!stmts)

goto out;

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

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

asdl_seq_SET(stmts, k++, s);

}

}

}

res = Module(stmts, arena);

break;

case eval_input: {

expr_ty testlist_ast;

/* XXX Why not comp_for here? */

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

if (!testlist_ast)

goto out;

res = Expression(testlist_ast, arena);

break;

}

case single_input:

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

stmts = _Py_asdl_seq_new(1, arena);

if (!stmts)

goto out;

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

arena));

if (!asdl_seq_GET(stmts, 0))

goto out;

res = Interactive(stmts, arena);

}

else {

n = CHILD(n, 0);

num = num_stmts(n);

stmts = _Py_asdl_seq_new(num, arena);

if (!stmts)

goto out;

if (num == 1) {

s = ast_for_stmt(&c, n);

if (!s)

goto out;

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

asdl_seq_SET(stmts, i / 2, s);

}

}

res = Interactive(stmts, arena);

}

break;

default:

PyErr_Format(PyExc_SystemError,

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

goto out;

}

out:

if (c.c_normalize) {

Py_DECREF(c.c_normalize);

}

return res;

}

mod_ty

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

PyArena *arena)

{

mod_ty mod;

PyObject *filename;

filename = PyUnicode_DecodeFSDefault(filename_str);

if (filename == NULL)

return NULL;

mod = PyAST_FromNodeObject(n, flags, filename, arena);

Py_DECREF(filename);

return mod;

}

/* Return the AST repr. of the operator represented as syntax (|, ^, etc.)

*/

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

return MatMult;

case SLASH:

return Div;

case DOUBLESLASH:

return FloorDiv;

case PERCENT:

return Mod;

default:

return (operator_ty)0;

}

}

static const char * const FORBIDDEN[] = {

"None",

"True",

"False",

NULL,

};

static int

forbidden_name(struct compiling *c, identifier name, const node *n,

int full_checks)

{

assert(PyUnicode_Check(name));

if (_PyUnicode_EqualToASCIIString(name, "__debug__")) {

ast_error(c, n, "assignment to keyword");

return 1;

}

if (full_checks) {

const char * const *p;

for (p = FORBIDDEN; *p; p++) {

if (_PyUnicode_EqualToASCIIString(name, *p)) {

ast_error(c, n, "assignment to keyword");

return 1;

}

}

}

return 0;

}

/* Set the context ctx for expr_ty e, recursively traversing e.

Only sets context for expr kinds that "can appear in assignment context"

(according to ../Parser/Python.asdl). For other expr kinds, it sets

an appropriate syntax error and returns false.

*/

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,

set expr_name to its name and an error message will be generated.

*/

const char* expr_name = NULL;

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

implementation here doesn't actually use them. The code may be

a little more complex than necessary as a result. It also means

that expressions in an augmented assignment have a Store context.

Consider restructuring so that augmented assignment uses

set_context(), too.

*/

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

switch (e->kind) {

case Attribute_kind:

e->v.Attribute.ctx = ctx;

if (ctx == Store && forbidden_name(c, e->v.Attribute.attr, n, 1))

return 0;

break;

case Subscript_kind:

e->v.Subscript.ctx = ctx;

break;

case Starred_kind:

e->v.Starred.ctx = ctx;

if (!set_context(c, e->v.Starred.value, ctx, n))

return 0;

break;

case Name_kind:

if (ctx == Store) {

if (forbidden_name(c, e->v.Name.id, n, 0))

return 0; /* forbidden_name() calls ast_error() */

}