?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
:stmt: -> :keyword:
[python.git] / Python / ast.c
blobc8875e074762996c9250ef16ffe8fb2ca231d2dc
1 /*
2 * This file includes functions to transform a concrete syntax tree (CST) to
3 * an abstract syntax tree (AST). The main function is PyAST_FromNode().
4 *
5 */
6 #include "Python.h"
7 #include "Python-ast.h"
8 #include "grammar.h"
9 #include "node.h"
10 #include "pyarena.h"
11 #include "ast.h"
12 #include "token.h"
13 #include "parsetok.h"
14 #include "graminit.h"
15
16 #include <assert.h>
17
18 /* Data structure used internally */
19 struct compiling {
20 char *c_encoding; /* source encoding */
21 int c_future_unicode; /* __future__ unicode literals flag */
22 PyArena *c_arena; /* arena for allocating memeory */
23 const char *c_filename; /* filename */
24 };
25
26 static asdl_seq *seq_for_testlist(struct compiling *, const node *);
27 static expr_ty ast_for_expr(struct compiling *, const node *);
28 static stmt_ty ast_for_stmt(struct compiling *, const node *);
29 static asdl_seq *ast_for_suite(struct compiling *, const node *);
30 static asdl_seq *ast_for_exprlist(struct compiling *, const node *,
31 expr_context_ty);
32 static expr_ty ast_for_testlist(struct compiling *, const node *);
33 static stmt_ty ast_for_classdef(struct compiling *, const node *, asdl_seq *);
34 static expr_ty ast_for_testlist_gexp(struct compiling *, const node *);
35
36 /* Note different signature for ast_for_call */
37 static expr_ty ast_for_call(struct compiling *, const node *, expr_ty);
38
39 static PyObject *parsenumber(struct compiling *, const char *);
40 static PyObject *parsestr(struct compiling *, const char *);
41 static PyObject *parsestrplus(struct compiling *, const node *n);
42
43 #ifndef LINENO
44 #define LINENO(n) ((n)->n_lineno)
45 #endif
46
47 static identifier
48 new_identifier(const char* n, PyArena *arena) {
49 PyObject* id = PyString_InternFromString(n);
50 if (id != NULL)
51 PyArena_AddPyObject(arena, id);
52 return id;
53 }
54
55 #define NEW_IDENTIFIER(n) new_identifier(STR(n), c->c_arena)
56
57 /* This routine provides an invalid object for the syntax error.
58 The outermost routine must unpack this error and create the
59 proper object. We do this so that we don't have to pass
60 the filename to everything function.
61
62 XXX Maybe we should just pass the filename...
63 */
64
65 static int
66 ast_error(const node *n, const char *errstr)
67 {
68 PyObject *u = Py_BuildValue("zi", errstr, LINENO(n));
69 if (!u)
70 return 0;
71 PyErr_SetObject(PyExc_SyntaxError, u);
72 Py_DECREF(u);
73 return 0;
74 }
75
76 static void
77 ast_error_finish(const char *filename)
78 {
79 PyObject *type, *value, *tback, *errstr, *loc, *tmp;
80 long lineno;
81
82 assert(PyErr_Occurred());
83 if (!PyErr_ExceptionMatches(PyExc_SyntaxError))
84 return;
85
86 PyErr_Fetch(&type, &value, &tback);
87 errstr = PyTuple_GetItem(value, 0);
88 if (!errstr)
89 return;
90 Py_INCREF(errstr);
91 lineno = PyInt_AsLong(PyTuple_GetItem(value, 1));
92 if (lineno == -1) {
93 Py_DECREF(errstr);
94 return;
95 }
96 Py_DECREF(value);
97
98 loc = PyErr_ProgramText(filename, lineno);
99 if (!loc) {
100 Py_INCREF(Py_None);
101 loc = Py_None;
102 }
103 tmp = Py_BuildValue("(zlOO)", filename, lineno, Py_None, loc);
104 Py_DECREF(loc);
105 if (!tmp) {
106 Py_DECREF(errstr);
107 return;
108 }
109 value = PyTuple_Pack(2, errstr, tmp);
110 Py_DECREF(errstr);
111 Py_DECREF(tmp);
112 if (!value)
113 return;
114 PyErr_Restore(type, value, tback);
115 }
116
117 static int
118 ast_warn(struct compiling *c, const node *n, char *msg)
119 {
120 if (PyErr_WarnExplicit(PyExc_SyntaxWarning, msg, c->c_filename, LINENO(n),
121 NULL, NULL) < 0) {
122 /* if -Werr, change it to a SyntaxError */
123 if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_SyntaxWarning))
124 ast_error(n, msg);
125 return 0;
126 }
127 return 1;
128 }
129
130 static int
131 forbidden_check(struct compiling *c, const node *n, const char *x)
132 {
133 if (!strcmp(x, "None"))
134 return ast_error(n, "cannot assign to None");
135 if (!strcmp(x, "__debug__"))
136 return ast_error(n, "cannot assign to __debug__");
137 if (Py_Py3kWarningFlag) {
138 if (!(strcmp(x, "True") && strcmp(x, "False")) &&
139 !ast_warn(c, n, "assignment to True or False is forbidden in 3.x"))
140 return 0;
141 if (!strcmp(x, "nonlocal") &&
142 !ast_warn(c, n, "nonlocal is a keyword in 3.x"))
143 return 0;
144 }
145 return 1;
146 }
147
148 /* num_stmts() returns number of contained statements.
149
150 Use this routine to determine how big a sequence is needed for
151 the statements in a parse tree. Its raison d'etre is this bit of
152 grammar:
153
154 stmt: simple_stmt | compound_stmt
155 simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE
156
157 A simple_stmt can contain multiple small_stmt elements joined
158 by semicolons. If the arg is a simple_stmt, the number of
159 small_stmt elements is returned.
160 */
161
162 static int
163 num_stmts(const node *n)
164 {
165 int i, l;
166 node *ch;
167
168 switch (TYPE(n)) {
169 case single_input:
170 if (TYPE(CHILD(n, 0)) == NEWLINE)
171 return 0;
172 else
173 return num_stmts(CHILD(n, 0));
174 case file_input:
175 l = 0;
176 for (i = 0; i < NCH(n); i++) {
177 ch = CHILD(n, i);
178 if (TYPE(ch) == stmt)
179 l += num_stmts(ch);
180 }
181 return l;
182 case stmt:
183 return num_stmts(CHILD(n, 0));
184 case compound_stmt:
185 return 1;
186 case simple_stmt:
187 return NCH(n) / 2; /* Divide by 2 to remove count of semi-colons */
188 case suite:
189 if (NCH(n) == 1)
190 return num_stmts(CHILD(n, 0));
191 else {
192 l = 0;
193 for (i = 2; i < (NCH(n) - 1); i++)
194 l += num_stmts(CHILD(n, i));
195 return l;
196 }
197 default: {
198 char buf[128];
199
200 sprintf(buf, "Non-statement found: %d %d",
201 TYPE(n), NCH(n));
202 Py_FatalError(buf);
203 }
204 }
205 assert(0);
206 return 0;
207 }
208
209 /* Transform the CST rooted at node * to the appropriate AST
210 */
211
212 mod_ty
213 PyAST_FromNode(const node *n, PyCompilerFlags *flags, const char *filename,
214 PyArena *arena)
215 {
216 int i, j, k, num;
217 asdl_seq *stmts = NULL;
218 stmt_ty s;
219 node *ch;
220 struct compiling c;
221
222 if (flags && flags->cf_flags & PyCF_SOURCE_IS_UTF8) {
223 c.c_encoding = "utf-8";
224 if (TYPE(n) == encoding_decl) {
225 ast_error(n, "encoding declaration in Unicode string");
226 goto error;
227 }
228 } else if (TYPE(n) == encoding_decl) {
229 c.c_encoding = STR(n);
230 n = CHILD(n, 0);
231 } else {
232 c.c_encoding = NULL;
233 }
234 c.c_future_unicode = flags && flags->cf_flags & CO_FUTURE_UNICODE_LITERALS;
235 c.c_arena = arena;
236 c.c_filename = filename;
237
238 k = 0;
239 switch (TYPE(n)) {
240 case file_input:
241 stmts = asdl_seq_new(num_stmts(n), arena);
242 if (!stmts)
243 return NULL;
244 for (i = 0; i < NCH(n) - 1; i++) {
245 ch = CHILD(n, i);
246 if (TYPE(ch) == NEWLINE)
247 continue;
248 REQ(ch, stmt);
249 num = num_stmts(ch);
250 if (num == 1) {
251 s = ast_for_stmt(&c, ch);
252 if (!s)
253 goto error;
254 asdl_seq_SET(stmts, k++, s);
255 }
256 else {
257 ch = CHILD(ch, 0);
258 REQ(ch, simple_stmt);
259 for (j = 0; j < num; j++) {
260 s = ast_for_stmt(&c, CHILD(ch, j * 2));
261 if (!s)
262 goto error;
263 asdl_seq_SET(stmts, k++, s);
264 }
265 }
266 }
267 return Module(stmts, arena);
268 case eval_input: {
269 expr_ty testlist_ast;
270
271 /* XXX Why not gen_for here? */
272 testlist_ast = ast_for_testlist(&c, CHILD(n, 0));
273 if (!testlist_ast)
274 goto error;
275 return Expression(testlist_ast, arena);
276 }
277 case single_input:
278 if (TYPE(CHILD(n, 0)) == NEWLINE) {
279 stmts = asdl_seq_new(1, arena);
280 if (!stmts)
281 goto error;
282 asdl_seq_SET(stmts, 0, Pass(n->n_lineno, n->n_col_offset,
283 arena));
284 if (!asdl_seq_GET(stmts, 0))
285 goto error;
286 return Interactive(stmts, arena);
287 }
288 else {
289 n = CHILD(n, 0);
290 num = num_stmts(n);
291 stmts = asdl_seq_new(num, arena);
292 if (!stmts)
293 goto error;
294 if (num == 1) {
295 s = ast_for_stmt(&c, n);
296 if (!s)
297 goto error;
298 asdl_seq_SET(stmts, 0, s);
299 }
300 else {
301 /* Only a simple_stmt can contain multiple statements. */
302 REQ(n, simple_stmt);
303 for (i = 0; i < NCH(n); i += 2) {
304 if (TYPE(CHILD(n, i)) == NEWLINE)
305 break;
306 s = ast_for_stmt(&c, CHILD(n, i));
307 if (!s)
308 goto error;
309 asdl_seq_SET(stmts, i / 2, s);
310 }
311 }
312
313 return Interactive(stmts, arena);
314 }
315 default:
316 PyErr_Format(PyExc_SystemError,
317 "invalid node %d for PyAST_FromNode", TYPE(n));
318 goto error;
319 }
320 error:
321 ast_error_finish(filename);
322 return NULL;
323 }
324
325 /* Return the AST repr. of the operator represented as syntax (|, ^, etc.)
326 */
327
328 static operator_ty
329 get_operator(const node *n)
330 {
331 switch (TYPE(n)) {
332 case VBAR:
333 return BitOr;
334 case CIRCUMFLEX:
335 return BitXor;
336 case AMPER:
337 return BitAnd;
338 case LEFTSHIFT:
339 return LShift;
340 case RIGHTSHIFT:
341 return RShift;
342 case PLUS:
343 return Add;
344 case MINUS:
345 return Sub;
346 case STAR:
347 return Mult;
348 case SLASH:
349 return Div;
350 case DOUBLESLASH:
351 return FloorDiv;
352 case PERCENT:
353 return Mod;
354 default:
355 return (operator_ty)0;
356 }
357 }
358
359 /* Set the context ctx for expr_ty e, recursively traversing e.
360
361 Only sets context for expr kinds that "can appear in assignment context"
362 (according to ../Parser/Python.asdl). For other expr kinds, it sets
363 an appropriate syntax error and returns false.
364 */
365
366 static int
367 set_context(struct compiling *c, expr_ty e, expr_context_ty ctx, const node *n)
368 {
369 asdl_seq *s = NULL;
370 /* If a particular expression type can't be used for assign / delete,
371 set expr_name to its name and an error message will be generated.
372 */
373 const char* expr_name = NULL;
374
375 /* The ast defines augmented store and load contexts, but the
376 implementation here doesn't actually use them. The code may be
377 a little more complex than necessary as a result. It also means
378 that expressions in an augmented assignment have a Store context.
379 Consider restructuring so that augmented assignment uses
380 set_context(), too.
381 */
382 assert(ctx != AugStore && ctx != AugLoad);
383
384 switch (e->kind) {
385 case Attribute_kind:
386 if (ctx == Store && !forbidden_check(c, n,
387 PyBytes_AS_STRING(e->v.Attribute.attr)))
388 return 0;
389 e->v.Attribute.ctx = ctx;
390 break;
391 case Subscript_kind:
392 e->v.Subscript.ctx = ctx;
393 break;
394 case Name_kind:
395 if (ctx == Store && !forbidden_check(c, n,
396 PyBytes_AS_STRING(e->v.Name.id)))
397 return 0;
398 e->v.Name.ctx = ctx;
399 break;
400 case List_kind:
401 e->v.List.ctx = ctx;
402 s = e->v.List.elts;
403 break;
404 case Tuple_kind:
405 if (asdl_seq_LEN(e->v.Tuple.elts)) {
406 e->v.Tuple.ctx = ctx;
407 s = e->v.Tuple.elts;
408 }
409 else {
410 expr_name = "()";
411 }
412 break;
413 case Lambda_kind:
414 expr_name = "lambda";
415 break;
416 case Call_kind:
417 expr_name = "function call";
418 break;
419 case BoolOp_kind:
420 case BinOp_kind:
421 case UnaryOp_kind:
422 expr_name = "operator";
423 break;
424 case GeneratorExp_kind:
425 expr_name = "generator expression";
426 break;
427 case Yield_kind:
428 expr_name = "yield expression";
429 break;
430 case ListComp_kind:
431 expr_name = "list comprehension";
432 break;
433 case Dict_kind:
434 case Num_kind:
435 case Str_kind:
436 expr_name = "literal";
437 break;
438 case Compare_kind:
439 expr_name = "comparison";
440 break;
441 case Repr_kind:
442 expr_name = "repr";
443 break;
444 case IfExp_kind:
445 expr_name = "conditional expression";
446 break;
447 default:
448 PyErr_Format(PyExc_SystemError,
449 "unexpected expression in assignment %d (line %d)",
450 e->kind, e->lineno);
451 return 0;
452 }
453 /* Check for error string set by switch */
454 if (expr_name) {
455 char buf[300];
456 PyOS_snprintf(buf, sizeof(buf),
457 "can't %s %s",
458 ctx == Store ? "assign to" : "delete",
459 expr_name);
460 return ast_error(n, buf);
461 }
462
463 /* If the LHS is a list or tuple, we need to set the assignment
464 context for all the contained elements.
465 */
466 if (s) {
467 int i;
468
469 for (i = 0; i < asdl_seq_LEN(s); i++) {
470 if (!set_context(c, (expr_ty)asdl_seq_GET(s, i), ctx, n))
471 return 0;
472 }
473 }
474 return 1;
475 }
476
477 static operator_ty
478 ast_for_augassign(struct compiling *c, const node *n)
479 {
480 REQ(n, augassign);
481 n = CHILD(n, 0);
482 switch (STR(n)[0]) {
483 case '+':
484 return Add;
485 case '-':
486 return Sub;
487 case '/':
488 if (STR(n)[1] == '/')
489 return FloorDiv;
490 else
491 return Div;
492 case '%':
493 return Mod;
494 case '<':
495 return LShift;
496 case '>':
497 return RShift;
498 case '&':
499 return BitAnd;
500 case '^':
501 return BitXor;
502 case '|':
503 return BitOr;
504 case '*':
505 if (STR(n)[1] == '*')
506 return Pow;
507 else
508 return Mult;
509 default:
510 PyErr_Format(PyExc_SystemError, "invalid augassign: %s", STR(n));
511 return (operator_ty)0;
512 }
513 }
514
515 static cmpop_ty
516 ast_for_comp_op(struct compiling *c, const node *n)
517 {
518 /* comp_op: '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is'
519 |'is' 'not'
520 */
521 REQ(n, comp_op);
522 if (NCH(n) == 1) {
523 n = CHILD(n, 0);
524 switch (TYPE(n)) {
525 case LESS:
526 return Lt;
527 case GREATER:
528 return Gt;
529 case EQEQUAL: /* == */
530 return Eq;
531 case LESSEQUAL:
532 return LtE;
533 case GREATEREQUAL:
534 return GtE;
535 case NOTEQUAL:
536 return NotEq;
537 case NAME:
538 if (strcmp(STR(n), "in") == 0)
539 return In;
540 if (strcmp(STR(n), "is") == 0)
541 return Is;
542 default:
543 PyErr_Format(PyExc_SystemError, "invalid comp_op: %s",
544 STR(n));
545 return (cmpop_ty)0;
546 }
547 }
548 else if (NCH(n) == 2) {
549 /* handle "not in" and "is not" */
550 switch (TYPE(CHILD(n, 0))) {
551 case NAME:
552 if (strcmp(STR(CHILD(n, 1)), "in") == 0)
553 return NotIn;
554 if (strcmp(STR(CHILD(n, 0)), "is") == 0)
555 return IsNot;
556 default:
557 PyErr_Format(PyExc_SystemError, "invalid comp_op: %s %s",
558 STR(CHILD(n, 0)), STR(CHILD(n, 1)));
559 return (cmpop_ty)0;
560 }
561 }
562 PyErr_Format(PyExc_SystemError, "invalid comp_op: has %d children",
563 NCH(n));
564 return (cmpop_ty)0;
565 }
566
567 static asdl_seq *
568 seq_for_testlist(struct compiling *c, const node *n)
569 {
570 /* testlist: test (',' test)* [','] */
571 asdl_seq *seq;
572 expr_ty expression;
573 int i;
574 assert(TYPE(n) == testlist ||
575 TYPE(n) == listmaker ||
576 TYPE(n) == testlist_gexp ||
577 TYPE(n) == testlist_safe ||
578 TYPE(n) == testlist1);
579
580 seq = asdl_seq_new((NCH(n) + 1) / 2, c->c_arena);
581 if (!seq)
582 return NULL;
583
584 for (i = 0; i < NCH(n); i += 2) {
585 assert(TYPE(CHILD(n, i)) == test || TYPE(CHILD(n, i)) == old_test);
586
587 expression = ast_for_expr(c, CHILD(n, i));
588 if (!expression)
589 return NULL;
590
591 assert(i / 2 < seq->size);
592 asdl_seq_SET(seq, i / 2, expression);
593 }
594 return seq;
595 }
596
597 static expr_ty
598 compiler_complex_args(struct compiling *c, const node *n)
599 {
600 int i, len = (NCH(n) + 1) / 2;
601 expr_ty result;
602 asdl_seq *args = asdl_seq_new(len, c->c_arena);
603 if (!args)
604 return NULL;
605
606 /* fpdef: NAME | '(' fplist ')'
607 fplist: fpdef (',' fpdef)* [',']
608 */
609 REQ(n, fplist);
610 for (i = 0; i < len; i++) {
611 PyObject *arg_id;
612 const node *fpdef_node = CHILD(n, 2*i);
613 const node *child;
614 expr_ty arg;
615 set_name:
616 /* fpdef_node is either a NAME or an fplist */
617 child = CHILD(fpdef_node, 0);
618 if (TYPE(child) == NAME) {
619 if (!forbidden_check(c, n, STR(child)))
620 return NULL;
621 arg_id = NEW_IDENTIFIER(child);
622 if (!arg_id)
623 return NULL;
624 arg = Name(arg_id, Store, LINENO(child), child->n_col_offset,
625 c->c_arena);
626 }
627 else {
628 assert(TYPE(fpdef_node) == fpdef);
629 /* fpdef_node[0] is not a name, so it must be '(', get CHILD[1] */
630 child = CHILD(fpdef_node, 1);
631 assert(TYPE(child) == fplist);
632 /* NCH == 1 means we have (x), we need to elide the extra parens */
633 if (NCH(child) == 1) {
634 fpdef_node = CHILD(child, 0);
635 assert(TYPE(fpdef_node) == fpdef);
636 goto set_name;
637 }
638 arg = compiler_complex_args(c, child);
639 }
640 asdl_seq_SET(args, i, arg);
641 }
642
643 result = Tuple(args, Store, LINENO(n), n->n_col_offset, c->c_arena);
644 if (!set_context(c, result, Store, n))
645 return NULL;
646 return result;
647 }
648
649
650 /* Create AST for argument list. */
651
652 static arguments_ty
653 ast_for_arguments(struct compiling *c, const node *n)
654 {
655 /* parameters: '(' [varargslist] ')'
656 varargslist: (fpdef ['=' test] ',')* ('*' NAME [',' '**' NAME]
657 | '**' NAME) | fpdef ['=' test] (',' fpdef ['=' test])* [',']
658 */
659 int i, j, k, n_args = 0, n_defaults = 0, found_default = 0;
660 asdl_seq *args, *defaults;
661 identifier vararg = NULL, kwarg = NULL;
662 node *ch;
663
664 if (TYPE(n) == parameters) {
665 if (NCH(n) == 2) /* () as argument list */
666 return arguments(NULL, NULL, NULL, NULL, c->c_arena);
667 n = CHILD(n, 1);
668 }
669 REQ(n, varargslist);
670
671 /* first count the number of normal args & defaults */
672 for (i = 0; i < NCH(n); i++) {
673 ch = CHILD(n, i);
674 if (TYPE(ch) == fpdef)
675 n_args++;
676 if (TYPE(ch) == EQUAL)
677 n_defaults++;
678 }
679 args = (n_args ? asdl_seq_new(n_args, c->c_arena) : NULL);
680 if (!args && n_args)
681 return NULL; /* Don't need to goto error; no objects allocated */
682 defaults = (n_defaults ? asdl_seq_new(n_defaults, c->c_arena) : NULL);
683 if (!defaults && n_defaults)
684 return NULL; /* Don't need to goto error; no objects allocated */
685
686 /* fpdef: NAME | '(' fplist ')'
687 fplist: fpdef (',' fpdef)* [',']
688 */
689 i = 0;
690 j = 0; /* index for defaults */
691 k = 0; /* index for args */
692 while (i < NCH(n)) {
693 ch = CHILD(n, i);
694 switch (TYPE(ch)) {
695 case fpdef: {
696 int complex_args = 0, parenthesized = 0;
697 handle_fpdef:
698 /* XXX Need to worry about checking if TYPE(CHILD(n, i+1)) is
699 anything other than EQUAL or a comma? */
700 /* XXX Should NCH(n) check be made a separate check? */
701 if (i + 1 < NCH(n) && TYPE(CHILD(n, i + 1)) == EQUAL) {
702 expr_ty expression = ast_for_expr(c, CHILD(n, i + 2));
703 if (!expression)
704 goto error;
705 assert(defaults != NULL);
706 asdl_seq_SET(defaults, j++, expression);
707 i += 2;
708 found_default = 1;
709 }
710 else if (found_default) {
711 /* def f((x)=4): pass should raise an error.
712 def f((x, (y))): pass will just incur the tuple unpacking warning. */
713 if (parenthesized && !complex_args) {
714 ast_error(n, "parenthesized arg with default");
715 goto error;
716 }
717 ast_error(n,
718 "non-default argument follows default argument");
719 goto error;
720 }
721 if (NCH(ch) == 3) {
722 ch = CHILD(ch, 1);
723 /* def foo((x)): is not complex, special case. */
724 if (NCH(ch) != 1) {
725 /* We have complex arguments, setup for unpacking. */
726 if (Py_Py3kWarningFlag && !ast_warn(c, ch,
727 "tuple parameter unpacking has been removed in 3.x"))
728 goto error;
729 complex_args = 1;
730 asdl_seq_SET(args, k++, compiler_complex_args(c, ch));
731 if (!asdl_seq_GET(args, k-1))
732 goto error;
733 } else {
734 /* def foo((x)): setup for checking NAME below. */
735 /* Loop because there can be many parens and tuple
736 unpacking mixed in. */
737 parenthesized = 1;
738 ch = CHILD(ch, 0);
739 assert(TYPE(ch) == fpdef);
740 goto handle_fpdef;
741 }
742 }
743 if (TYPE(CHILD(ch, 0)) == NAME) {
744 PyObject *id;
745 expr_ty name;
746 if (!forbidden_check(c, n, STR(CHILD(ch, 0))))
747 goto error;
748 id = NEW_IDENTIFIER(CHILD(ch, 0));
749 if (!id)
750 goto error;
751 name = Name(id, Param, LINENO(ch), ch->n_col_offset,
752 c->c_arena);
753 if (!name)
754 goto error;
755 asdl_seq_SET(args, k++, name);
756
757 }
758 i += 2; /* the name and the comma */
759 if (parenthesized && Py_Py3kWarningFlag &&
760 !ast_warn(c, ch, "parenthesized argument names "
761 "are invalid in 3.x"))
762 goto error;
763
764 break;
765 }
766 case STAR:
767 if (!forbidden_check(c, CHILD(n, i+1), STR(CHILD(n, i+1))))
768 goto error;
769 vararg = NEW_IDENTIFIER(CHILD(n, i+1));
770 if (!vararg)
771 goto error;
772 i += 3;
773 break;
774 case DOUBLESTAR:
775 if (!forbidden_check(c, CHILD(n, i+1), STR(CHILD(n, i+1))))
776 goto error;
777 kwarg = NEW_IDENTIFIER(CHILD(n, i+1));
778 if (!kwarg)
779 goto error;
780 i += 3;
781 break;
782 default:
783 PyErr_Format(PyExc_SystemError,
784 "unexpected node in varargslist: %d @ %d",
785 TYPE(ch), i);
786 goto error;
787 }
788 }
789
790 return arguments(args, vararg, kwarg, defaults, c->c_arena);
791
792 error:
793 Py_XDECREF(vararg);
794 Py_XDECREF(kwarg);
795 return NULL;
796 }
797
798 static expr_ty
799 ast_for_dotted_name(struct compiling *c, const node *n)
800 {
801 expr_ty e;
802 identifier id;
803 int lineno, col_offset;
804 int i;
805
806 REQ(n, dotted_name);
807
808 lineno = LINENO(n);
809 col_offset = n->n_col_offset;
810
811 id = NEW_IDENTIFIER(CHILD(n, 0));
812 if (!id)
813 return NULL;
814 e = Name(id, Load, lineno, col_offset, c->c_arena);
815 if (!e)
816 return NULL;
817
818 for (i = 2; i < NCH(n); i+=2) {
819 id = NEW_IDENTIFIER(CHILD(n, i));
820 if (!id)
821 return NULL;
822 e = Attribute(e, id, Load, lineno, col_offset, c->c_arena);
823 if (!e)
824 return NULL;
825 }
826
827 return e;
828 }
829
830 static expr_ty
831 ast_for_decorator(struct compiling *c, const node *n)
832 {
833 /* decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE */
834 expr_ty d = NULL;
835 expr_ty name_expr;
836
837 REQ(n, decorator);
838 REQ(CHILD(n, 0), AT);
839 REQ(RCHILD(n, -1), NEWLINE);
840
841 name_expr = ast_for_dotted_name(c, CHILD(n, 1));
842 if (!name_expr)
843 return NULL;
844
845 if (NCH(n) == 3) { /* No arguments */
846 d = name_expr;
847 name_expr = NULL;
848 }
849 else if (NCH(n) == 5) { /* Call with no arguments */
850 d = Call(name_expr, NULL, NULL, NULL, NULL, LINENO(n),
851 n->n_col_offset, c->c_arena);
852 if (!d)
853 return NULL;
854 name_expr = NULL;
855 }
856 else {
857 d = ast_for_call(c, CHILD(n, 3), name_expr);
858 if (!d)
859 return NULL;
860 name_expr = NULL;
861 }
862
863 return d;
864 }
865
866 static asdl_seq*
867 ast_for_decorators(struct compiling *c, const node *n)
868 {
869 asdl_seq* decorator_seq;
870 expr_ty d;
871 int i;
872
873 REQ(n, decorators);
874 decorator_seq = asdl_seq_new(NCH(n), c->c_arena);
875 if (!decorator_seq)
876 return NULL;
877
878 for (i = 0; i < NCH(n); i++) {
879 d = ast_for_decorator(c, CHILD(n, i));
880 if (!d)
881 return NULL;
882 asdl_seq_SET(decorator_seq, i, d);
883 }
884 return decorator_seq;
885 }
886
887 static stmt_ty
888 ast_for_funcdef(struct compiling *c, const node *n, asdl_seq *decorator_seq)
889 {
890 /* funcdef: 'def' NAME parameters ':' suite */
891 identifier name;
892 arguments_ty args;
893 asdl_seq *body;
894 int name_i = 1;
895
896 REQ(n, funcdef);
897
898 name = NEW_IDENTIFIER(CHILD(n, name_i));
899 if (!name)
900 return NULL;
901 else if (!forbidden_check(c, CHILD(n, name_i), STR(CHILD(n, name_i))))
902 return NULL;
903 args = ast_for_arguments(c, CHILD(n, name_i + 1));
904 if (!args)
905 return NULL;
906 body = ast_for_suite(c, CHILD(n, name_i + 3));
907 if (!body)
908 return NULL;
909
910 return FunctionDef(name, args, body, decorator_seq, LINENO(n),
911 n->n_col_offset, c->c_arena);
912 }
913
914 static stmt_ty
915 ast_for_decorated(struct compiling *c, const node *n)
916 {
917 /* decorated: decorators (classdef | funcdef) */
918 stmt_ty thing = NULL;
919 asdl_seq *decorator_seq = NULL;
920
921 REQ(n, decorated);
922
923 decorator_seq = ast_for_decorators(c, CHILD(n, 0));
924 if (!decorator_seq)
925 return NULL;
926
927 assert(TYPE(CHILD(n, 1)) == funcdef ||
928 TYPE(CHILD(n, 1)) == classdef);
929
930 if (TYPE(CHILD(n, 1)) == funcdef) {
931 thing = ast_for_funcdef(c, CHILD(n, 1), decorator_seq);
932 } else if (TYPE(CHILD(n, 1)) == classdef) {
933 thing = ast_for_classdef(c, CHILD(n, 1), decorator_seq);
934 }
935 /* we count the decorators in when talking about the class' or
936 function's line number */
937 if (thing) {
938 thing->lineno = LINENO(n);
939 thing->col_offset = n->n_col_offset;
940 }
941 return thing;
942 }
943
944 static expr_ty
945 ast_for_lambdef(struct compiling *c, const node *n)
946 {
947 /* lambdef: 'lambda' [varargslist] ':' test */
948 arguments_ty args;
949 expr_ty expression;
950
951 if (NCH(n) == 3) {
952 args = arguments(NULL, NULL, NULL, NULL, c->c_arena);
953 if (!args)
954 return NULL;
955 expression = ast_for_expr(c, CHILD(n, 2));
956 if (!expression)
957 return NULL;
958 }
959 else {
960 args = ast_for_arguments(c, CHILD(n, 1));
961 if (!args)
962 return NULL;
963 expression = ast_for_expr(c, CHILD(n, 3));
964 if (!expression)
965 return NULL;
966 }
967
968 return Lambda(args, expression, LINENO(n), n->n_col_offset, c->c_arena);
969 }
970
971 static expr_ty
972 ast_for_ifexpr(struct compiling *c, const node *n)
973 {
974 /* test: or_test 'if' or_test 'else' test */
975 expr_ty expression, body, orelse;
976
977 assert(NCH(n) == 5);
978 body = ast_for_expr(c, CHILD(n, 0));
979 if (!body)
980 return NULL;
981 expression = ast_for_expr(c, CHILD(n, 2));
982 if (!expression)
983 return NULL;
984 orelse = ast_for_expr(c, CHILD(n, 4));
985 if (!orelse)
986 return NULL;
987 return IfExp(expression, body, orelse, LINENO(n), n->n_col_offset,
988 c->c_arena);
989 }
990
991 /* XXX(nnorwitz): the listcomp and genexpr code should be refactored
992 so there is only a single version. Possibly for loops can also re-use
993 the code.
994 */
995
996 /* Count the number of 'for' loop in a list comprehension.
997
998 Helper for ast_for_listcomp().
999 */
1000
1001 static int
1002 count_list_fors(struct compiling *c, const node *n)
1003 {
1004 int n_fors = 0;
1005 node *ch = CHILD(n, 1);
1006
1007 count_list_for:
1008 n_fors++;
1009 REQ(ch, list_for);
1010 if (NCH(ch) == 5)
1011 ch = CHILD(ch, 4);
1012 else
1013 return n_fors;
1014 count_list_iter:
1015 REQ(ch, list_iter);
1016 ch = CHILD(ch, 0);
1017 if (TYPE(ch) == list_for)
1018 goto count_list_for;
1019 else if (TYPE(ch) == list_if) {
1020 if (NCH(ch) == 3) {
1021 ch = CHILD(ch, 2);
1022 goto count_list_iter;
1023 }
1024 else
1025 return n_fors;
1026 }
1027
1028 /* Should never be reached */
1029 PyErr_SetString(PyExc_SystemError, "logic error in count_list_fors");
1030 return -1;
1031 }
1032
1033 /* Count the number of 'if' statements in a list comprehension.
1034
1035 Helper for ast_for_listcomp().
1036 */
1037
1038 static int
1039 count_list_ifs(struct compiling *c, const node *n)
1040 {
1041 int n_ifs = 0;
1042
1043 count_list_iter:
1044 REQ(n, list_iter);
1045 if (TYPE(CHILD(n, 0)) == list_for)
1046 return n_ifs;
1047 n = CHILD(n, 0);
1048 REQ(n, list_if);
1049 n_ifs++;
1050 if (NCH(n) == 2)
1051 return n_ifs;
1052 n = CHILD(n, 2);
1053 goto count_list_iter;
1054 }
1055
1056 static expr_ty
1057 ast_for_listcomp(struct compiling *c, const node *n)
1058 {
1059 /* listmaker: test ( list_for | (',' test)* [','] )
1060 list_for: 'for' exprlist 'in' testlist_safe [list_iter]
1061 list_iter: list_for | list_if
1062 list_if: 'if' test [list_iter]
1063 testlist_safe: test [(',' test)+ [',']]
1064 */
1065 expr_ty elt, first;
1066 asdl_seq *listcomps;
1067 int i, n_fors;
1068 node *ch;
1069
1070 REQ(n, listmaker);
1071 assert(NCH(n) > 1);
1072
1073 elt = ast_for_expr(c, CHILD(n, 0));
1074 if (!elt)
1075 return NULL;
1076
1077 n_fors = count_list_fors(c, n);
1078 if (n_fors == -1)
1079 return NULL;
1080
1081 listcomps = asdl_seq_new(n_fors, c->c_arena);
1082 if (!listcomps)
1083 return NULL;
1084
1085 ch = CHILD(n, 1);
1086 for (i = 0; i < n_fors; i++) {
1087 comprehension_ty lc;
1088 asdl_seq *t;
1089 expr_ty expression;
1090 node *for_ch;
1091
1092 REQ(ch, list_for);
1093
1094 for_ch = CHILD(ch, 1);
1095 t = ast_for_exprlist(c, for_ch, Store);
1096 if (!t)
1097 return NULL;
1098 expression = ast_for_testlist(c, CHILD(ch, 3));
1099 if (!expression)
1100 return NULL;
1101
1102 /* Check the # of children rather than the length of t, since
1103 [x for x, in ... ] has 1 element in t, but still requires a Tuple.
1104 */
1105 first = (expr_ty)asdl_seq_GET(t, 0);
1106 if (NCH(for_ch) == 1)
1107 lc = comprehension(first, expression, NULL, c->c_arena);
1108 else
1109 lc = comprehension(Tuple(t, Store, first->lineno, first->col_offset,
1110 c->c_arena),
1111 expression, NULL, c->c_arena);
1112 if (!lc)
1113 return NULL;
1114
1115 if (NCH(ch) == 5) {
1116 int j, n_ifs;
1117 asdl_seq *ifs;
1118 expr_ty list_for_expr;
1119
1120 ch = CHILD(ch, 4);
1121 n_ifs = count_list_ifs(c, ch);
1122 if (n_ifs == -1)
1123 return NULL;
1124
1125 ifs = asdl_seq_new(n_ifs, c->c_arena);
1126 if (!ifs)
1127 return NULL;
1128
1129 for (j = 0; j < n_ifs; j++) {
1130 REQ(ch, list_iter);
1131 ch = CHILD(ch, 0);
1132 REQ(ch, list_if);
1133
1134 list_for_expr = ast_for_expr(c, CHILD(ch, 1));
1135 if (!list_for_expr)
1136 return NULL;
1137
1138 asdl_seq_SET(ifs, j, list_for_expr);
1139 if (NCH(ch) == 3)
1140 ch = CHILD(ch, 2);
1141 }
1142 /* on exit, must guarantee that ch is a list_for */
1143 if (TYPE(ch) == list_iter)
1144 ch = CHILD(ch, 0);
1145 lc->ifs = ifs;
1146 }
1147 asdl_seq_SET(listcomps, i, lc);
1148 }
1149
1150 return ListComp(elt, listcomps, LINENO(n), n->n_col_offset, c->c_arena);
1151 }
1152
1153 /* Count the number of 'for' loops in a generator expression.
1154
1155 Helper for ast_for_genexp().
1156 */
1157
1158 static int
1159 count_gen_fors(struct compiling *c, const node *n)
1160 {
1161 int n_fors = 0;
1162 node *ch = CHILD(n, 1);
1163
1164 count_gen_for:
1165 n_fors++;
1166 REQ(ch, gen_for);
1167 if (NCH(ch) == 5)
1168 ch = CHILD(ch, 4);
1169 else
1170 return n_fors;
1171 count_gen_iter:
1172 REQ(ch, gen_iter);
1173 ch = CHILD(ch, 0);
1174 if (TYPE(ch) == gen_for)
1175 goto count_gen_for;
1176 else if (TYPE(ch) == gen_if) {
1177 if (NCH(ch) == 3) {
1178 ch = CHILD(ch, 2);
1179 goto count_gen_iter;
1180 }
1181 else
1182 return n_fors;
1183 }
1184
1185 /* Should never be reached */
1186 PyErr_SetString(PyExc_SystemError,
1187 "logic error in count_gen_fors");
1188 return -1;
1189 }
1190
1191 /* Count the number of 'if' statements in a generator expression.
1192
1193 Helper for ast_for_genexp().
1194 */
1195
1196 static int
1197 count_gen_ifs(struct compiling *c, const node *n)
1198 {
1199 int n_ifs = 0;
1200
1201 while (1) {
1202 REQ(n, gen_iter);
1203 if (TYPE(CHILD(n, 0)) == gen_for)
1204 return n_ifs;
1205 n = CHILD(n, 0);
1206 REQ(n, gen_if);
1207 n_ifs++;
1208 if (NCH(n) == 2)
1209 return n_ifs;
1210 n = CHILD(n, 2);
1211 }
1212 }
1213
1214 /* TODO(jhylton): Combine with list comprehension code? */
1215 static expr_ty
1216 ast_for_genexp(struct compiling *c, const node *n)
1217 {
1218 /* testlist_gexp: test ( gen_for | (',' test)* [','] )
1219 argument: [test '='] test [gen_for] # Really [keyword '='] test */
1220 expr_ty elt;
1221 asdl_seq *genexps;
1222 int i, n_fors;
1223 node *ch;
1224
1225 assert(TYPE(n) == (testlist_gexp) || TYPE(n) == (argument));
1226 assert(NCH(n) > 1);
1227
1228 elt = ast_for_expr(c, CHILD(n, 0));
1229 if (!elt)
1230 return NULL;
1231
1232 n_fors = count_gen_fors(c, n);
1233 if (n_fors == -1)
1234 return NULL;
1235
1236 genexps = asdl_seq_new(n_fors, c->c_arena);
1237 if (!genexps)
1238 return NULL;
1239
1240 ch = CHILD(n, 1);
1241 for (i = 0; i < n_fors; i++) {
1242 comprehension_ty ge;
1243 asdl_seq *t;
1244 expr_ty expression, first;
1245 node *for_ch;
1246
1247 REQ(ch, gen_for);
1248
1249 for_ch = CHILD(ch, 1);
1250 t = ast_for_exprlist(c, for_ch, Store);
1251 if (!t)
1252 return NULL;
1253 expression = ast_for_expr(c, CHILD(ch, 3));
1254 if (!expression)
1255 return NULL;
1256
1257 /* Check the # of children rather than the length of t, since
1258 (x for x, in ...) has 1 element in t, but still requires a Tuple. */
1259 first = (expr_ty)asdl_seq_GET(t, 0);
1260 if (NCH(for_ch) == 1)
1261 ge = comprehension(first, expression, NULL, c->c_arena);
1262 else
1263 ge = comprehension(Tuple(t, Store, first->lineno, first->col_offset,
1264 c->c_arena),
1265 expression, NULL, c->c_arena);
1266
1267 if (!ge)
1268 return NULL;
1269
1270 if (NCH(ch) == 5) {
1271 int j, n_ifs;
1272 asdl_seq *ifs;
1273
1274 ch = CHILD(ch, 4);
1275 n_ifs = count_gen_ifs(c, ch);
1276 if (n_ifs == -1)
1277 return NULL;
1278
1279 ifs = asdl_seq_new(n_ifs, c->c_arena);
1280 if (!ifs)
1281 return NULL;
1282
1283 for (j = 0; j < n_ifs; j++) {
1284 REQ(ch, gen_iter);
1285 ch = CHILD(ch, 0);
1286 REQ(ch, gen_if);
1287
1288 expression = ast_for_expr(c, CHILD(ch, 1));
1289 if (!expression)
1290 return NULL;
1291 asdl_seq_SET(ifs, j, expression);
1292 if (NCH(ch) == 3)
1293 ch = CHILD(ch, 2);
1294 }
1295 /* on exit, must guarantee that ch is a gen_for */
1296 if (TYPE(ch) == gen_iter)
1297 ch = CHILD(ch, 0);
1298 ge->ifs = ifs;
1299 }
1300 asdl_seq_SET(genexps, i, ge);
1301 }
1302
1303 return GeneratorExp(elt, genexps, LINENO(n), n->n_col_offset, c->c_arena);
1304 }
1305
1306 static expr_ty
1307 ast_for_atom(struct compiling *c, const node *n)
1308 {
1309 /* atom: '(' [yield_expr|testlist_gexp] ')' | '[' [listmaker] ']'
1310 | '{' [dictmaker] '}' | '`' testlist '`' | NAME | NUMBER | STRING+
1311 */
1312 node *ch = CHILD(n, 0);
1313
1314 switch (TYPE(ch)) {
1315 case NAME: {
1316 /* All names start in Load context, but may later be
1317 changed. */
1318 PyObject *name = NEW_IDENTIFIER(ch);
1319 if (!name)
1320 return NULL;
1321 return Name(name, Load, LINENO(n), n->n_col_offset, c->c_arena);
1322 }
1323 case STRING: {
1324 PyObject *str = parsestrplus(c, n);
1325 if (!str) {
1326 #ifdef Py_USING_UNICODE
1327 if (PyErr_ExceptionMatches(PyExc_UnicodeError)){
1328 PyObject *type, *value, *tback, *errstr;
1329 PyErr_Fetch(&type, &value, &tback);
1330 errstr = PyObject_Str(value);
1331 if (errstr) {
1332 char *s = "";
1333 char buf[128];
1334 s = PyString_AsString(errstr);
1335 PyOS_snprintf(buf, sizeof(buf), "(unicode error) %s", s);
1336 ast_error(n, buf);
1337 Py_DECREF(errstr);
1338 } else {
1339 ast_error(n, "(unicode error) unknown error");
1340 }
1341 Py_DECREF(type);
1342 Py_DECREF(value);
1343 Py_XDECREF(tback);
1344 }
1345 #endif
1346 return NULL;
1347 }
1348 PyArena_AddPyObject(c->c_arena, str);
1349 return Str(str, LINENO(n), n->n_col_offset, c->c_arena);
1350 }
1351 case NUMBER: {
1352 PyObject *pynum = parsenumber(c, STR(ch));
1353 if (!pynum)
1354 return NULL;
1355
1356 PyArena_AddPyObject(c->c_arena, pynum);
1357 return Num(pynum, LINENO(n), n->n_col_offset, c->c_arena);
1358 }
1359 case LPAR: /* some parenthesized expressions */
1360 ch = CHILD(n, 1);
1361
1362 if (TYPE(ch) == RPAR)
1363 return Tuple(NULL, Load, LINENO(n), n->n_col_offset, c->c_arena);
1364
1365 if (TYPE(ch) == yield_expr)
1366 return ast_for_expr(c, ch);
1367
1368 return ast_for_testlist_gexp(c, ch);
1369 case LSQB: /* list (or list comprehension) */
1370 ch = CHILD(n, 1);
1371
1372 if (TYPE(ch) == RSQB)
1373 return List(NULL, Load, LINENO(n), n->n_col_offset, c->c_arena);
1374
1375 REQ(ch, listmaker);
1376 if (NCH(ch) == 1 || TYPE(CHILD(ch, 1)) == COMMA) {
1377 asdl_seq *elts = seq_for_testlist(c, ch);
1378 if (!elts)
1379 return NULL;
1380
1381 return List(elts, Load, LINENO(n), n->n_col_offset, c->c_arena);
1382 }
1383 else
1384 return ast_for_listcomp(c, ch);
1385 case LBRACE: {
1386 /* dictmaker: test ':' test (',' test ':' test)* [','] */
1387 int i, size;
1388 asdl_seq *keys, *values;
1389
1390 ch = CHILD(n, 1);
1391 size = (NCH(ch) + 1) / 4; /* +1 in case no trailing comma */
1392 keys = asdl_seq_new(size, c->c_arena);
1393 if (!keys)
1394 return NULL;
1395
1396 values = asdl_seq_new(size, c->c_arena);
1397 if (!values)
1398 return NULL;
1399
1400 for (i = 0; i < NCH(ch); i += 4) {
1401 expr_ty expression;
1402
1403 expression = ast_for_expr(c, CHILD(ch, i));
1404 if (!expression)
1405 return NULL;
1406
1407 asdl_seq_SET(keys, i / 4, expression);
1408
1409 expression = ast_for_expr(c, CHILD(ch, i + 2));
1410 if (!expression)
1411 return NULL;
1412
1413 asdl_seq_SET(values, i / 4, expression);
1414 }
1415 return Dict(keys, values, LINENO(n), n->n_col_offset, c->c_arena);
1416 }
1417 case BACKQUOTE: { /* repr */
1418 expr_ty expression;
1419 if (Py_Py3kWarningFlag &&
1420 !ast_warn(c, n, "backquote not supported in 3.x; use repr()"))
1421 return NULL;
1422 expression = ast_for_testlist(c, CHILD(n, 1));
1423 if (!expression)
1424 return NULL;
1425
1426 return Repr(expression, LINENO(n), n->n_col_offset, c->c_arena);
1427 }
1428 default:
1429 PyErr_Format(PyExc_SystemError, "unhandled atom %d", TYPE(ch));
1430 return NULL;
1431 }
1432 }
1433
1434 static slice_ty
1435 ast_for_slice(struct compiling *c, const node *n)
1436 {
1437 node *ch;
1438 expr_ty lower = NULL, upper = NULL, step = NULL;
1439
1440 REQ(n, subscript);
1441
1442 /*
1443 subscript: '.' '.' '.' | test | [test] ':' [test] [sliceop]
1444 sliceop: ':' [test]
1445 */
1446 ch = CHILD(n, 0);
1447 if (TYPE(ch) == DOT)
1448 return Ellipsis(c->c_arena);
1449
1450 if (NCH(n) == 1 && TYPE(ch) == test) {
1451 /* 'step' variable hold no significance in terms of being used over
1452 other vars */
1453 step = ast_for_expr(c, ch);
1454 if (!step)
1455 return NULL;
1456
1457 return Index(step, c->c_arena);
1458 }
1459
1460 if (TYPE(ch) == test) {
1461 lower = ast_for_expr(c, ch);
1462 if (!lower)
1463 return NULL;
1464 }
1465
1466 /* If there's an upper bound it's in the second or third position. */
1467 if (TYPE(ch) == COLON) {
1468 if (NCH(n) > 1) {
1469 node *n2 = CHILD(n, 1);
1470
1471 if (TYPE(n2) == test) {
1472 upper = ast_for_expr(c, n2);
1473 if (!upper)
1474 return NULL;
1475 }
1476 }
1477 } else if (NCH(n) > 2) {
1478 node *n2 = CHILD(n, 2);
1479
1480 if (TYPE(n2) == test) {
1481 upper = ast_for_expr(c, n2);
1482 if (!upper)
1483 return NULL;
1484 }
1485 }
1486
1487 ch = CHILD(n, NCH(n) - 1);
1488 if (TYPE(ch) == sliceop) {
1489 if (NCH(ch) == 1) {
1490 /*
1491 This is an extended slice (ie "x[::]") with no expression in the
1492 step field. We set this literally to "None" in order to
1493 disambiguate it from x[:]. (The interpreter might have to call
1494 __getslice__ for x[:], but it must call __getitem__ for x[::].)
1495 */
1496 identifier none = new_identifier("None", c->c_arena);
1497 if (!none)
1498 return NULL;
1499 ch = CHILD(ch, 0);
1500 step = Name(none, Load, LINENO(ch), ch->n_col_offset, c->c_arena);
1501 if (!step)
1502 return NULL;
1503 } else {
1504 ch = CHILD(ch, 1);
1505 if (TYPE(ch) == test) {
1506 step = ast_for_expr(c, ch);
1507 if (!step)
1508 return NULL;
1509 }
1510 }
1511 }
1512
1513 return Slice(lower, upper, step, c->c_arena);
1514 }
1515
1516 static expr_ty
1517 ast_for_binop(struct compiling *c, const node *n)
1518 {
1519 /* Must account for a sequence of expressions.
1520 How should A op B op C by represented?
1521 BinOp(BinOp(A, op, B), op, C).
1522 */
1523
1524 int i, nops;
1525 expr_ty expr1, expr2, result;
1526 operator_ty newoperator;
1527
1528 expr1 = ast_for_expr(c, CHILD(n, 0));
1529 if (!expr1)
1530 return NULL;
1531
1532 expr2 = ast_for_expr(c, CHILD(n, 2));
1533 if (!expr2)
1534 return NULL;
1535
1536 newoperator = get_operator(CHILD(n, 1));
1537 if (!newoperator)
1538 return NULL;
1539
1540 result = BinOp(expr1, newoperator, expr2, LINENO(n), n->n_col_offset,
1541 c->c_arena);
1542 if (!result)
1543 return NULL;
1544
1545 nops = (NCH(n) - 1) / 2;
1546 for (i = 1; i < nops; i++) {
1547 expr_ty tmp_result, tmp;
1548 const node* next_oper = CHILD(n, i * 2 + 1);
1549
1550 newoperator = get_operator(next_oper);
1551 if (!newoperator)
1552 return NULL;
1553
1554 tmp = ast_for_expr(c, CHILD(n, i * 2 + 2));
1555 if (!tmp)
1556 return NULL;
1557
1558 tmp_result = BinOp(result, newoperator, tmp,
1559 LINENO(next_oper), next_oper->n_col_offset,
1560 c->c_arena);
1561 if (!tmp_result)
1562 return NULL;
1563 result = tmp_result;
1564 }
1565 return result;
1566 }
1567
1568 static expr_ty
1569 ast_for_trailer(struct compiling *c, const node *n, expr_ty left_expr)
1570 {
1571 /* trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME
1572 subscriptlist: subscript (',' subscript)* [',']
1573 subscript: '.' '.' '.' | test | [test] ':' [test] [sliceop]
1574 */
1575 REQ(n, trailer);
1576 if (TYPE(CHILD(n, 0)) == LPAR) {
1577 if (NCH(n) == 2)
1578 return Call(left_expr, NULL, NULL, NULL, NULL, LINENO(n),
1579 n->n_col_offset, c->c_arena);
1580 else
1581 return ast_for_call(c, CHILD(n, 1), left_expr);
1582 }
1583 else if (TYPE(CHILD(n, 0)) == DOT ) {
1584 PyObject *attr_id = NEW_IDENTIFIER(CHILD(n, 1));
1585 if (!attr_id)
1586 return NULL;
1587 return Attribute(left_expr, attr_id, Load,
1588 LINENO(n), n->n_col_offset, c->c_arena);
1589 }
1590 else {
1591 REQ(CHILD(n, 0), LSQB);
1592 REQ(CHILD(n, 2), RSQB);
1593 n = CHILD(n, 1);
1594 if (NCH(n) == 1) {
1595 slice_ty slc = ast_for_slice(c, CHILD(n, 0));
1596 if (!slc)
1597 return NULL;
1598 return Subscript(left_expr, slc, Load, LINENO(n), n->n_col_offset,
1599 c->c_arena);
1600 }
1601 else {
1602 /* The grammar is ambiguous here. The ambiguity is resolved
1603 by treating the sequence as a tuple literal if there are
1604 no slice features.
1605 */
1606 int j;
1607 slice_ty slc;
1608 expr_ty e;
1609 bool simple = true;
1610 asdl_seq *slices, *elts;
1611 slices = asdl_seq_new((NCH(n) + 1) / 2, c->c_arena);
1612 if (!slices)
1613 return NULL;
1614 for (j = 0; j < NCH(n); j += 2) {
1615 slc = ast_for_slice(c, CHILD(n, j));
1616 if (!slc)
1617 return NULL;
1618 if (slc->kind != Index_kind)
1619 simple = false;
1620 asdl_seq_SET(slices, j / 2, slc);
1621 }
1622 if (!simple) {
1623 return Subscript(left_expr, ExtSlice(slices, c->c_arena),
1624 Load, LINENO(n), n->n_col_offset, c->c_arena);
1625 }
1626 /* extract Index values and put them in a Tuple */
1627 elts = asdl_seq_new(asdl_seq_LEN(slices), c->c_arena);
1628 if (!elts)
1629 return NULL;
1630 for (j = 0; j < asdl_seq_LEN(slices); ++j) {
1631 slc = (slice_ty)asdl_seq_GET(slices, j);
1632 assert(slc->kind == Index_kind && slc->v.Index.value);
1633 asdl_seq_SET(elts, j, slc->v.Index.value);
1634 }
1635 e = Tuple(elts, Load, LINENO(n), n->n_col_offset, c->c_arena);
1636 if (!e)
1637 return NULL;
1638 return Subscript(left_expr, Index(e, c->c_arena),
1639 Load, LINENO(n), n->n_col_offset, c->c_arena);
1640 }
1641 }
1642 }
1643
1644 static expr_ty
1645 ast_for_factor(struct compiling *c, const node *n)
1646 {
1647 node *pfactor, *ppower, *patom, *pnum;
1648 expr_ty expression;
1649
1650 /* If the unary - operator is applied to a constant, don't generate
1651 a UNARY_NEGATIVE opcode. Just store the approriate value as a
1652 constant. The peephole optimizer already does something like
1653 this but it doesn't handle the case where the constant is
1654 (sys.maxint - 1). In that case, we want a PyIntObject, not a
1655 PyLongObject.
1656 */
1657 if (TYPE(CHILD(n, 0)) == MINUS &&
1658 NCH(n) == 2 &&
1659 TYPE((pfactor = CHILD(n, 1))) == factor &&
1660 NCH(pfactor) == 1 &&
1661 TYPE((ppower = CHILD(pfactor, 0))) == power &&
1662 NCH(ppower) == 1 &&
1663 TYPE((patom = CHILD(ppower, 0))) == atom &&
1664 TYPE((pnum = CHILD(patom, 0))) == NUMBER) {
1665 char *s = PyObject_MALLOC(strlen(STR(pnum)) + 2);
1666 if (s == NULL)
1667 return NULL;
1668 s[0] = '-';
1669 strcpy(s + 1, STR(pnum));
1670 PyObject_FREE(STR(pnum));
1671 STR(pnum) = s;
1672 return ast_for_atom(c, patom);
1673 }
1674
1675 expression = ast_for_expr(c, CHILD(n, 1));
1676 if (!expression)
1677 return NULL;
1678
1679 switch (TYPE(CHILD(n, 0))) {
1680 case PLUS:
1681 return UnaryOp(UAdd, expression, LINENO(n), n->n_col_offset,
1682 c->c_arena);
1683 case MINUS:
1684 return UnaryOp(USub, expression, LINENO(n), n->n_col_offset,
1685 c->c_arena);
1686 case TILDE:
1687 return UnaryOp(Invert, expression, LINENO(n),
1688 n->n_col_offset, c->c_arena);
1689 }
1690 PyErr_Format(PyExc_SystemError, "unhandled factor: %d",
1691 TYPE(CHILD(n, 0)));
1692 return NULL;
1693 }
1694
1695 static expr_ty
1696 ast_for_power(struct compiling *c, const node *n)
1697 {
1698 /* power: atom trailer* ('**' factor)*
1699 */
1700 int i;
1701 expr_ty e, tmp;
1702 REQ(n, power);
1703 e = ast_for_atom(c, CHILD(n, 0));
1704 if (!e)
1705 return NULL;
1706 if (NCH(n) == 1)
1707 return e;
1708 for (i = 1; i < NCH(n); i++) {
1709 node *ch = CHILD(n, i);
1710 if (TYPE(ch) != trailer)
1711 break;
1712 tmp = ast_for_trailer(c, ch, e);
1713 if (!tmp)
1714 return NULL;
1715 tmp->lineno = e->lineno;
1716 tmp->col_offset = e->col_offset;
1717 e = tmp;
1718 }
1719 if (TYPE(CHILD(n, NCH(n) - 1)) == factor) {
1720 expr_ty f = ast_for_expr(c, CHILD(n, NCH(n) - 1));
1721 if (!f)
1722 return NULL;
1723 tmp = BinOp(e, Pow, f, LINENO(n), n->n_col_offset, c->c_arena);
1724 if (!tmp)
1725 return NULL;
1726 e = tmp;
1727 }
1728 return e;
1729 }
1730
1731 /* Do not name a variable 'expr'! Will cause a compile error.
1732 */
1733
1734 static expr_ty
1735 ast_for_expr(struct compiling *c, const node *n)
1736 {
1737 /* handle the full range of simple expressions
1738 test: or_test ['if' or_test 'else' test] | lambdef
1739 or_test: and_test ('or' and_test)*
1740 and_test: not_test ('and' not_test)*
1741 not_test: 'not' not_test | comparison
1742 comparison: expr (comp_op expr)*
1743 expr: xor_expr ('|' xor_expr)*
1744 xor_expr: and_expr ('^' and_expr)*
1745 and_expr: shift_expr ('&' shift_expr)*
1746 shift_expr: arith_expr (('<<'|'>>') arith_expr)*
1747 arith_expr: term (('+'|'-') term)*
1748 term: factor (('*'|'/'|'%'|'//') factor)*
1749 factor: ('+'|'-'|'~') factor | power
1750 power: atom trailer* ('**' factor)*
1751
1752 As well as modified versions that exist for backward compatibility,
1753 to explicitly allow:
1754 [ x for x in lambda: 0, lambda: 1 ]
1755 (which would be ambiguous without these extra rules)
1756
1757 old_test: or_test | old_lambdef
1758 old_lambdef: 'lambda' [vararglist] ':' old_test
1759
1760 */
1761
1762 asdl_seq *seq;
1763 int i;
1764
1765 loop:
1766 switch (TYPE(n)) {
1767 case test:
1768 case old_test:
1769 if (TYPE(CHILD(n, 0)) == lambdef ||
1770 TYPE(CHILD(n, 0)) == old_lambdef)
1771 return ast_for_lambdef(c, CHILD(n, 0));
1772 else if (NCH(n) > 1)
1773 return ast_for_ifexpr(c, n);
1774 /* Fallthrough */
1775 case or_test:
1776 case and_test:
1777 if (NCH(n) == 1) {
1778 n = CHILD(n, 0);
1779 goto loop;
1780 }
1781 seq = asdl_seq_new((NCH(n) + 1) / 2, c->c_arena);
1782 if (!seq)
1783 return NULL;
1784 for (i = 0; i < NCH(n); i += 2) {
1785 expr_ty e = ast_for_expr(c, CHILD(n, i));
1786 if (!e)
1787 return NULL;
1788 asdl_seq_SET(seq, i / 2, e);
1789 }
1790 if (!strcmp(STR(CHILD(n, 1)), "and"))
1791 return BoolOp(And, seq, LINENO(n), n->n_col_offset,
1792 c->c_arena);
1793 assert(!strcmp(STR(CHILD(n, 1)), "or"));
1794 return BoolOp(Or, seq, LINENO(n), n->n_col_offset, c->c_arena);
1795 case not_test:
1796 if (NCH(n) == 1) {
1797 n = CHILD(n, 0);
1798 goto loop;
1799 }
1800 else {
1801 expr_ty expression = ast_for_expr(c, CHILD(n, 1));
1802 if (!expression)
1803 return NULL;
1804
1805 return UnaryOp(Not, expression, LINENO(n), n->n_col_offset,
1806 c->c_arena);
1807 }
1808 case comparison:
1809 if (NCH(n) == 1) {
1810 n = CHILD(n, 0);
1811 goto loop;
1812 }
1813 else {
1814 expr_ty expression;
1815 asdl_int_seq *ops;
1816 asdl_seq *cmps;
1817 ops = asdl_int_seq_new(NCH(n) / 2, c->c_arena);
1818 if (!ops)
1819 return NULL;
1820 cmps = asdl_seq_new(NCH(n) / 2, c->c_arena);
1821 if (!cmps) {
1822 return NULL;
1823 }
1824 for (i = 1; i < NCH(n); i += 2) {
1825 cmpop_ty newoperator;
1826
1827 newoperator = ast_for_comp_op(c, CHILD(n, i));
1828 if (!newoperator) {
1829 return NULL;
1830 }
1831
1832 expression = ast_for_expr(c, CHILD(n, i + 1));
1833 if (!expression) {
1834 return NULL;
1835 }
1836
1837 asdl_seq_SET(ops, i / 2, newoperator);
1838 asdl_seq_SET(cmps, i / 2, expression);
1839 }
1840 expression = ast_for_expr(c, CHILD(n, 0));
1841 if (!expression) {
1842 return NULL;
1843 }
1844
1845 return Compare(expression, ops, cmps, LINENO(n),
1846 n->n_col_offset, c->c_arena);
1847 }
1848 break;
1849
1850 /* The next five cases all handle BinOps. The main body of code
1851 is the same in each case, but the switch turned inside out to
1852 reuse the code for each type of operator.
1853 */
1854 case expr:
1855 case xor_expr:
1856 case and_expr:
1857 case shift_expr:
1858 case arith_expr:
1859 case term:
1860 if (NCH(n) == 1) {
1861 n = CHILD(n, 0);
1862 goto loop;
1863 }
1864 return ast_for_binop(c, n);
1865 case yield_expr: {
1866 expr_ty exp = NULL;
1867 if (NCH(n) == 2) {
1868 exp = ast_for_testlist(c, CHILD(n, 1));
1869 if (!exp)
1870 return NULL;
1871 }
1872 return Yield(exp, LINENO(n), n->n_col_offset, c->c_arena);
1873 }
1874 case factor:
1875 if (NCH(n) == 1) {
1876 n = CHILD(n, 0);
1877 goto loop;
1878 }
1879 return ast_for_factor(c, n);
1880 case power:
1881 return ast_for_power(c, n);
1882 default:
1883 PyErr_Format(PyExc_SystemError, "unhandled expr: %d", TYPE(n));
1884 return NULL;
1885 }
1886 /* should never get here unless if error is set */
1887 return NULL;
1888 }
1889
1890 static expr_ty
1891 ast_for_call(struct compiling *c, const node *n, expr_ty func)
1892 {
1893 /*
1894 arglist: (argument ',')* (argument [',']| '*' test [',' '**' test]
1895 | '**' test)
1896 argument: [test '='] test [gen_for] # Really [keyword '='] test
1897 */
1898
1899 int i, nargs, nkeywords, ngens;
1900 asdl_seq *args;
1901 asdl_seq *keywords;
1902 expr_ty vararg = NULL, kwarg = NULL;
1903
1904 REQ(n, arglist);
1905
1906 nargs = 0;
1907 nkeywords = 0;
1908 ngens = 0;
1909 for (i = 0; i < NCH(n); i++) {
1910 node *ch = CHILD(n, i);
1911 if (TYPE(ch) == argument) {
1912 if (NCH(ch) == 1)
1913 nargs++;
1914 else if (TYPE(CHILD(ch, 1)) == gen_for)
1915 ngens++;
1916 else
1917 nkeywords++;
1918 }
1919 }
1920 if (ngens > 1 || (ngens && (nargs || nkeywords))) {
1921 ast_error(n, "Generator expression must be parenthesized "
1922 "if not sole argument");
1923 return NULL;
1924 }
1925
1926 if (nargs + nkeywords + ngens > 255) {
1927 ast_error(n, "more than 255 arguments");
1928 return NULL;
1929 }
1930
1931 args = asdl_seq_new(nargs + ngens, c->c_arena);
1932 if (!args)
1933 return NULL;
1934 keywords = asdl_seq_new(nkeywords, c->c_arena);
1935 if (!keywords)
1936 return NULL;
1937 nargs = 0;
1938 nkeywords = 0;
1939 for (i = 0; i < NCH(n); i++) {
1940 node *ch = CHILD(n, i);
1941 if (TYPE(ch) == argument) {
1942 expr_ty e;
1943 if (NCH(ch) == 1) {
1944 if (nkeywords) {
1945 ast_error(CHILD(ch, 0),
1946 "non-keyword arg after keyword arg");
1947 return NULL;
1948 }
1949 if (vararg) {
1950 ast_error(CHILD(ch, 0),
1951 "only named arguments may follow *expression");
1952 return NULL;
1953 }
1954 e = ast_for_expr(c, CHILD(ch, 0));
1955 if (!e)
1956 return NULL;
1957 asdl_seq_SET(args, nargs++, e);
1958 }
1959 else if (TYPE(CHILD(ch, 1)) == gen_for) {
1960 e = ast_for_genexp(c, ch);
1961 if (!e)
1962 return NULL;
1963 asdl_seq_SET(args, nargs++, e);
1964 }
1965 else {
1966 keyword_ty kw;
1967 identifier key;
1968 int k;
1969 char *tmp;
1970
1971 /* CHILD(ch, 0) is test, but must be an identifier? */
1972 e = ast_for_expr(c, CHILD(ch, 0));
1973 if (!e)
1974 return NULL;
1975 /* f(lambda x: x[0] = 3) ends up getting parsed with
1976 * LHS test = lambda x: x[0], and RHS test = 3.
1977 * SF bug 132313 points out that complaining about a keyword
1978 * then is very confusing.
1979 */
1980 if (e->kind == Lambda_kind) {
1981 ast_error(CHILD(ch, 0),
1982 "lambda cannot contain assignment");
1983 return NULL;
1984 } else if (e->kind != Name_kind) {
1985 ast_error(CHILD(ch, 0), "keyword can't be an expression");
1986 return NULL;
1987 }
1988 key = e->v.Name.id;
1989 if (!forbidden_check(c, CHILD(ch, 0), PyBytes_AS_STRING(key)))
1990 return NULL;
1991 for (k = 0; k < nkeywords; k++) {
1992 tmp = PyString_AS_STRING(
1993 ((keyword_ty)asdl_seq_GET(keywords, k))->arg);
1994 if (!strcmp(tmp, PyString_AS_STRING(key))) {
1995 ast_error(CHILD(ch, 0), "keyword argument repeated");
1996 return NULL;
1997 }
1998 }
1999 e = ast_for_expr(c, CHILD(ch, 2));
2000 if (!e)
2001 return NULL;
2002 kw = keyword(key, e, c->c_arena);
2003 if (!kw)
2004 return NULL;
2005 asdl_seq_SET(keywords, nkeywords++, kw);
2006 }
2007 }
2008 else if (TYPE(ch) == STAR) {
2009 vararg = ast_for_expr(c, CHILD(n, i+1));
2010 if (!vararg)
2011 return NULL;
2012 i++;
2013 }
2014 else if (TYPE(ch) == DOUBLESTAR) {
2015 kwarg = ast_for_expr(c, CHILD(n, i+1));
2016 if (!kwarg)
2017 return NULL;
2018 i++;
2019 }
2020 }
2021
2022 return Call(func, args, keywords, vararg, kwarg, func->lineno,
2023 func->col_offset, c->c_arena);
2024 }
2025
2026 static expr_ty
2027 ast_for_testlist(struct compiling *c, const node* n)
2028 {
2029 /* testlist_gexp: test (',' test)* [','] */
2030 /* testlist: test (',' test)* [','] */
2031 /* testlist_safe: test (',' test)+ [','] */
2032 /* testlist1: test (',' test)* */
2033 assert(NCH(n) > 0);
2034 if (TYPE(n) == testlist_gexp) {
2035 if (NCH(n) > 1)
2036 assert(TYPE(CHILD(n, 1)) != gen_for);
2037 }
2038 else {
2039 assert(TYPE(n) == testlist ||
2040 TYPE(n) == testlist_safe ||
2041 TYPE(n) == testlist1);
2042 }
2043 if (NCH(n) == 1)
2044 return ast_for_expr(c, CHILD(n, 0));
2045 else {
2046 asdl_seq *tmp = seq_for_testlist(c, n);
2047 if (!tmp)
2048 return NULL;
2049 return Tuple(tmp, Load, LINENO(n), n->n_col_offset, c->c_arena);
2050 }
2051 }
2052
2053 static expr_ty
2054 ast_for_testlist_gexp(struct compiling *c, const node* n)
2055 {
2056 /* testlist_gexp: test ( gen_for | (',' test)* [','] ) */
2057 /* argument: test [ gen_for ] */
2058 assert(TYPE(n) == testlist_gexp || TYPE(n) == argument);
2059 if (NCH(n) > 1 && TYPE(CHILD(n, 1)) == gen_for)
2060 return ast_for_genexp(c, n);
2061 return ast_for_testlist(c, n);
2062 }
2063
2064 /* like ast_for_testlist() but returns a sequence */
2065 static asdl_seq*
2066 ast_for_class_bases(struct compiling *c, const node* n)
2067 {
2068 /* testlist: test (',' test)* [','] */
2069 assert(NCH(n) > 0);
2070 REQ(n, testlist);
2071 if (NCH(n) == 1) {
2072 expr_ty base;
2073 asdl_seq *bases = asdl_seq_new(1, c->c_arena);
2074 if (!bases)
2075 return NULL;
2076 base = ast_for_expr(c, CHILD(n, 0));
2077 if (!base)
2078 return NULL;
2079 asdl_seq_SET(bases, 0, base);
2080 return bases;
2081 }
2082
2083 return seq_for_testlist(c, n);
2084 }
2085
2086 static stmt_ty
2087 ast_for_expr_stmt(struct compiling *c, const node *n)
2088 {
2089 REQ(n, expr_stmt);
2090 /* expr_stmt: testlist (augassign (yield_expr|testlist)
2091 | ('=' (yield_expr|testlist))*)
2092 testlist: test (',' test)* [',']
2093 augassign: '+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '|=' | '^='
2094 | '<<=' | '>>=' | '**=' | '//='
2095 test: ... here starts the operator precendence dance
2096 */
2097
2098 if (NCH(n) == 1) {
2099 expr_ty e = ast_for_testlist(c, CHILD(n, 0));
2100 if (!e)
2101 return NULL;
2102
2103 return Expr(e, LINENO(n), n->n_col_offset, c->c_arena);
2104 }
2105 else if (TYPE(CHILD(n, 1)) == augassign) {
2106 expr_ty expr1, expr2;
2107 operator_ty newoperator;
2108 node *ch = CHILD(n, 0);
2109
2110 expr1 = ast_for_testlist(c, ch);
2111 if (!expr1)
2112 return NULL;
2113 if(!set_context(c, expr1, Store, ch))
2114 return NULL;
2115 /* set_context checks that most expressions are not the left side.
2116 Augmented assignments can only have a name, a subscript, or an
2117 attribute on the left, though, so we have to explicitly check for
2118 those. */
2119 switch (expr1->kind) {
2120 case Name_kind:
2121 case Attribute_kind:
2122 case Subscript_kind:
2123 break;
2124 default:
2125 ast_error(ch, "illegal expression for augmented assignment");
2126 return NULL;
2127 }
2128
2129 ch = CHILD(n, 2);
2130 if (TYPE(ch) == testlist)
2131 expr2 = ast_for_testlist(c, ch);
2132 else
2133 expr2 = ast_for_expr(c, ch);
2134 if (!expr2)
2135 return NULL;
2136
2137 newoperator = ast_for_augassign(c, CHILD(n, 1));
2138 if (!newoperator)
2139 return NULL;
2140
2141 return AugAssign(expr1, newoperator, expr2, LINENO(n), n->n_col_offset,
2142 c->c_arena);
2143 }
2144 else {
2145 int i;
2146 asdl_seq *targets;
2147 node *value;
2148 expr_ty expression;
2149
2150 /* a normal assignment */
2151 REQ(CHILD(n, 1), EQUAL);
2152 targets = asdl_seq_new(NCH(n) / 2, c->c_arena);
2153 if (!targets)
2154 return NULL;
2155 for (i = 0; i < NCH(n) - 2; i += 2) {
2156 expr_ty e;
2157 node *ch = CHILD(n, i);
2158 if (TYPE(ch) == yield_expr) {
2159 ast_error(ch, "assignment to yield expression not possible");
2160 return NULL;
2161 }
2162 e = ast_for_testlist(c, ch);
2163
2164 /* set context to assign */
2165 if (!e)
2166 return NULL;
2167
2168 if (!set_context(c, e, Store, CHILD(n, i)))
2169 return NULL;
2170
2171 asdl_seq_SET(targets, i / 2, e);
2172 }
2173 value = CHILD(n, NCH(n) - 1);
2174 if (TYPE(value) == testlist)
2175 expression = ast_for_testlist(c, value);
2176 else
2177 expression = ast_for_expr(c, value);
2178 if (!expression)
2179 return NULL;
2180 return Assign(targets, expression, LINENO(n), n->n_col_offset,
2181 c->c_arena);
2182 }
2183 }
2184
2185 static stmt_ty
2186 ast_for_print_stmt(struct compiling *c, const node *n)
2187 {
2188 /* print_stmt: 'print' ( [ test (',' test)* [','] ]
2189 | '>>' test [ (',' test)+ [','] ] )
2190 */
2191 expr_ty dest = NULL, expression;
2192 asdl_seq *seq = NULL;
2193 bool nl;
2194 int i, j, values_count, start = 1;
2195
2196 REQ(n, print_stmt);
2197 if (NCH(n) >= 2 && TYPE(CHILD(n, 1)) == RIGHTSHIFT) {
2198 dest = ast_for_expr(c, CHILD(n, 2));
2199 if (!dest)
2200 return NULL;
2201 start = 4;
2202 }
2203 values_count = (NCH(n) + 1 - start) / 2;
2204 if (values_count) {
2205 seq = asdl_seq_new(values_count, c->c_arena);
2206 if (!seq)
2207 return NULL;
2208 for (i = start, j = 0; i < NCH(n); i += 2, ++j) {
2209 expression = ast_for_expr(c, CHILD(n, i));
2210 if (!expression)
2211 return NULL;
2212 asdl_seq_SET(seq, j, expression);
2213 }
2214 }
2215 nl = (TYPE(CHILD(n, NCH(n) - 1)) == COMMA) ? false : true;
2216 return Print(dest, seq, nl, LINENO(n), n->n_col_offset, c->c_arena);
2217 }
2218
2219 static asdl_seq *
2220 ast_for_exprlist(struct compiling *c, const node *n, expr_context_ty context)
2221 {
2222 asdl_seq *seq;
2223 int i;
2224 expr_ty e;
2225
2226 REQ(n, exprlist);
2227
2228 seq = asdl_seq_new((NCH(n) + 1) / 2, c->c_arena);
2229 if (!seq)
2230 return NULL;
2231 for (i = 0; i < NCH(n); i += 2) {
2232 e = ast_for_expr(c, CHILD(n, i));
2233 if (!e)
2234 return NULL;
2235 asdl_seq_SET(seq, i / 2, e);
2236 if (context && !set_context(c, e, context, CHILD(n, i)))
2237 return NULL;
2238 }
2239 return seq;
2240 }
2241
2242 static stmt_ty
2243 ast_for_del_stmt(struct compiling *c, const node *n)
2244 {
2245 asdl_seq *expr_list;
2246
2247 /* del_stmt: 'del' exprlist */
2248 REQ(n, del_stmt);
2249
2250 expr_list = ast_for_exprlist(c, CHILD(n, 1), Del);
2251 if (!expr_list)
2252 return NULL;
2253 return Delete(expr_list, LINENO(n), n->n_col_offset, c->c_arena);
2254 }
2255
2256 static stmt_ty
2257 ast_for_flow_stmt(struct compiling *c, const node *n)
2258 {
2259 /*
2260 flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt
2261 | yield_stmt
2262 break_stmt: 'break'
2263 continue_stmt: 'continue'
2264 return_stmt: 'return' [testlist]
2265 yield_stmt: yield_expr
2266 yield_expr: 'yield' testlist
2267 raise_stmt: 'raise' [test [',' test [',' test]]]
2268 */
2269 node *ch;
2270
2271 REQ(n, flow_stmt);
2272 ch = CHILD(n, 0);
2273 switch (TYPE(ch)) {
2274 case break_stmt:
2275 return Break(LINENO(n), n->n_col_offset, c->c_arena);
2276 case continue_stmt:
2277 return Continue(LINENO(n), n->n_col_offset, c->c_arena);
2278 case yield_stmt: { /* will reduce to yield_expr */
2279 expr_ty exp = ast_for_expr(c, CHILD(ch, 0));
2280 if (!exp)
2281 return NULL;
2282 return Expr(exp, LINENO(n), n->n_col_offset, c->c_arena);
2283 }
2284 case return_stmt:
2285 if (NCH(ch) == 1)
2286 return Return(NULL, LINENO(n), n->n_col_offset, c->c_arena);
2287 else {
2288 expr_ty expression = ast_for_testlist(c, CHILD(ch, 1));
2289 if (!expression)
2290 return NULL;
2291 return Return(expression, LINENO(n), n->n_col_offset,
2292 c->c_arena);
2293 }
2294 case raise_stmt:
2295 if (NCH(ch) == 1)
2296 return Raise(NULL, NULL, NULL, LINENO(n), n->n_col_offset,
2297 c->c_arena);
2298 else if (NCH(ch) == 2) {
2299 expr_ty expression = ast_for_expr(c, CHILD(ch, 1));
2300 if (!expression)
2301 return NULL;
2302 return Raise(expression, NULL, NULL, LINENO(n),
2303 n->n_col_offset, c->c_arena);
2304 }
2305 else if (NCH(ch) == 4) {
2306 expr_ty expr1, expr2;
2307
2308 expr1 = ast_for_expr(c, CHILD(ch, 1));
2309 if (!expr1)
2310 return NULL;
2311 expr2 = ast_for_expr(c, CHILD(ch, 3));
2312 if (!expr2)
2313 return NULL;
2314
2315 return Raise(expr1, expr2, NULL, LINENO(n), n->n_col_offset,
2316 c->c_arena);
2317 }
2318 else if (NCH(ch) == 6) {
2319 expr_ty expr1, expr2, expr3;
2320
2321 expr1 = ast_for_expr(c, CHILD(ch, 1));
2322 if (!expr1)
2323 return NULL;
2324 expr2 = ast_for_expr(c, CHILD(ch, 3));
2325 if (!expr2)
2326 return NULL;
2327 expr3 = ast_for_expr(c, CHILD(ch, 5));
2328 if (!expr3)
2329 return NULL;
2330
2331 return Raise(expr1, expr2, expr3, LINENO(n), n->n_col_offset,
2332 c->c_arena);
2333 }
2334 default:
2335 PyErr_Format(PyExc_SystemError,
2336 "unexpected flow_stmt: %d", TYPE(ch));
2337 return NULL;
2338 }
2339
2340 PyErr_SetString(PyExc_SystemError, "unhandled flow statement");
2341 return NULL;
2342 }
2343
2344 static alias_ty
2345 alias_for_import_name(struct compiling *c, const node *n, int store)
2346 {
2347 /*
2348 import_as_name: NAME ['as' NAME]
2349 dotted_as_name: dotted_name ['as' NAME]
2350 dotted_name: NAME ('.' NAME)*
2351 */
2352 PyObject *str, *name;
2353
2354 loop:
2355 switch (TYPE(n)) {
2356 case import_as_name: {
2357 node *name_node = CHILD(n, 0);
2358 str = NULL;
2359 if (NCH(n) == 3) {
2360 node *str_node = CHILD(n, 2);
2361 if (store && !forbidden_check(c, str_node, STR(str_node)))
2362 return NULL;
2363 str = NEW_IDENTIFIER(str_node);
2364 if (!str)
2365 return NULL;
2366 }
2367 else {
2368 if (!forbidden_check(c, name_node, STR(name_node)))
2369 return NULL;
2370 }
2371 name = NEW_IDENTIFIER(name_node);
2372 if (!name)
2373 return NULL;
2374 return alias(name, str, c->c_arena);
2375 }
2376 case dotted_as_name:
2377 if (NCH(n) == 1) {
2378 n = CHILD(n, 0);
2379 goto loop;
2380 }
2381 else {
2382 node *asname_node = CHILD(n, 2);
2383 alias_ty a = alias_for_import_name(c, CHILD(n, 0), 0);
2384 if (!a)
2385 return NULL;
2386 assert(!a->asname);
2387 if (!forbidden_check(c, asname_node, STR(asname_node)))
2388 return NULL;
2389 a->asname = NEW_IDENTIFIER(asname_node);
2390 if (!a->asname)
2391 return NULL;
2392 return a;
2393 }
2394 break;
2395 case dotted_name:
2396 if (NCH(n) == 1) {
2397 node *name_node = CHILD(n, 0);
2398 if (store && !forbidden_check(c, name_node, STR(name_node)))
2399 return NULL;
2400 name = NEW_IDENTIFIER(name_node);
2401 if (!name)
2402 return NULL;
2403 return alias(name, NULL, c->c_arena);
2404 }
2405 else {
2406 /* Create a string of the form "a.b.c" */
2407 int i;
2408 size_t len;
2409 char *s;
2410
2411 len = 0;
2412 for (i = 0; i < NCH(n); i += 2)
2413 /* length of string plus one for the dot */
2414 len += strlen(STR(CHILD(n, i))) + 1;
2415 len--; /* the last name doesn't have a dot */
2416 str = PyString_FromStringAndSize(NULL, len);
2417 if (!str)
2418 return NULL;
2419 s = PyString_AS_STRING(str);
2420 if (!s)
2421 return NULL;
2422 for (i = 0; i < NCH(n); i += 2) {
2423 char *sch = STR(CHILD(n, i));
2424 strcpy(s, STR(CHILD(n, i)));
2425 s += strlen(sch);
2426 *s++ = '.';
2427 }
2428 --s;
2429 *s = '\0';
2430 PyString_InternInPlace(&str);
2431 PyArena_AddPyObject(c->c_arena, str);
2432 return alias(str, NULL, c->c_arena);
2433 }
2434 break;
2435 case STAR:
2436 str = PyString_InternFromString("*");
2437 PyArena_AddPyObject(c->c_arena, str);
2438 return alias(str, NULL, c->c_arena);
2439 default:
2440 PyErr_Format(PyExc_SystemError,
2441 "unexpected import name: %d", TYPE(n));
2442 return NULL;
2443 }
2444
2445 PyErr_SetString(PyExc_SystemError, "unhandled import name condition");
2446 return NULL;
2447 }
2448
2449 static stmt_ty
2450 ast_for_import_stmt(struct compiling *c, const node *n)
2451 {
2452 /*
2453 import_stmt: import_name | import_from
2454 import_name: 'import' dotted_as_names
2455 import_from: 'from' ('.'* dotted_name | '.') 'import'
2456 ('*' | '(' import_as_names ')' | import_as_names)
2457 */
2458 int lineno;
2459 int col_offset;
2460 int i;
2461 asdl_seq *aliases;
2462
2463 REQ(n, import_stmt);
2464 lineno = LINENO(n);
2465 col_offset = n->n_col_offset;
2466 n = CHILD(n, 0);
2467 if (TYPE(n) == import_name) {
2468 n = CHILD(n, 1);
2469 REQ(n, dotted_as_names);
2470 aliases = asdl_seq_new((NCH(n) + 1) / 2, c->c_arena);
2471 if (!aliases)
2472 return NULL;
2473 for (i = 0; i < NCH(n); i += 2) {
2474 alias_ty import_alias = alias_for_import_name(c, CHILD(n, i), 1);
2475 if (!import_alias)
2476 return NULL;
2477 asdl_seq_SET(aliases, i / 2, import_alias);
2478 }
2479 return Import(aliases, lineno, col_offset, c->c_arena);
2480 }
2481 else if (TYPE(n) == import_from) {
2482 int n_children;
2483 int idx, ndots = 0;
2484 alias_ty mod = NULL;
2485 identifier modname = NULL;
2486
2487 /* Count the number of dots (for relative imports) and check for the
2488 optional module name */
2489 for (idx = 1; idx < NCH(n); idx++) {
2490 if (TYPE(CHILD(n, idx)) == dotted_name) {
2491 mod = alias_for_import_name(c, CHILD(n, idx), 0);
2492 if (!mod)
2493 return NULL;
2494 idx++;
2495 break;
2496 } else if (TYPE(CHILD(n, idx)) != DOT) {
2497 break;
2498 }
2499 ndots++;
2500 }
2501 idx++; /* skip over the 'import' keyword */
2502 switch (TYPE(CHILD(n, idx))) {
2503 case STAR:
2504 /* from ... import * */
2505 n = CHILD(n, idx);
2506 n_children = 1;
2507 break;
2508 case LPAR:
2509 /* from ... import (x, y, z) */
2510 n = CHILD(n, idx + 1);
2511 n_children = NCH(n);
2512 break;
2513 case import_as_names:
2514 /* from ... import x, y, z */
2515 n = CHILD(n, idx);
2516 n_children = NCH(n);
2517 if (n_children % 2 == 0) {
2518 ast_error(n, "trailing comma not allowed without"
2519 " surrounding parentheses");
2520 return NULL;
2521 }
2522 break;
2523 default:
2524 ast_error(n, "Unexpected node-type in from-import");
2525 return NULL;
2526 }
2527
2528 aliases = asdl_seq_new((n_children + 1) / 2, c->c_arena);
2529 if (!aliases)
2530 return NULL;
2531
2532 /* handle "from ... import *" special b/c there's no children */
2533 if (TYPE(n) == STAR) {
2534 alias_ty import_alias = alias_for_import_name(c, n, 1);
2535 if (!import_alias)
2536 return NULL;
2537 asdl_seq_SET(aliases, 0, import_alias);
2538 }
2539 else {
2540 for (i = 0; i < NCH(n); i += 2) {
2541 alias_ty import_alias = alias_for_import_name(c, CHILD(n, i), 1);
2542 if (!import_alias)
2543 return NULL;
2544 asdl_seq_SET(aliases, i / 2, import_alias);
2545 }
2546 }
2547 if (mod != NULL)
2548 modname = mod->name;
2549 return ImportFrom(modname, aliases, ndots, lineno, col_offset,
2550 c->c_arena);
2551 }
2552 PyErr_Format(PyExc_SystemError,
2553 "unknown import statement: starts with command '%s'",
2554 STR(CHILD(n, 0)));
2555 return NULL;
2556 }
2557
2558 static stmt_ty
2559 ast_for_global_stmt(struct compiling *c, const node *n)
2560 {
2561 /* global_stmt: 'global' NAME (',' NAME)* */
2562 identifier name;
2563 asdl_seq *s;
2564 int i;
2565
2566 REQ(n, global_stmt);
2567 s = asdl_seq_new(NCH(n) / 2, c->c_arena);
2568 if (!s)
2569 return NULL;
2570 for (i = 1; i < NCH(n); i += 2) {
2571 name = NEW_IDENTIFIER(CHILD(n, i));
2572 if (!name)
2573 return NULL;
2574 asdl_seq_SET(s, i / 2, name);
2575 }
2576 return Global(s, LINENO(n), n->n_col_offset, c->c_arena);
2577 }
2578
2579 static stmt_ty
2580 ast_for_exec_stmt(struct compiling *c, const node *n)
2581 {
2582 expr_ty expr1, globals = NULL, locals = NULL;
2583 int n_children = NCH(n);
2584 if (n_children != 2 && n_children != 4 && n_children != 6) {
2585 PyErr_Format(PyExc_SystemError,
2586 "poorly formed 'exec' statement: %d parts to statement",
2587 n_children);
2588 return NULL;
2589 }
2590
2591 /* exec_stmt: 'exec' expr ['in' test [',' test]] */
2592 REQ(n, exec_stmt);
2593 expr1 = ast_for_expr(c, CHILD(n, 1));
2594 if (!expr1)
2595 return NULL;
2596 if (n_children >= 4) {
2597 globals = ast_for_expr(c, CHILD(n, 3));
2598 if (!globals)
2599 return NULL;
2600 }
2601 if (n_children == 6) {
2602 locals = ast_for_expr(c, CHILD(n, 5));
2603 if (!locals)
2604 return NULL;
2605 }
2606
2607 return Exec(expr1, globals, locals, LINENO(n), n->n_col_offset,
2608 c->c_arena);
2609 }
2610
2611 static stmt_ty
2612 ast_for_assert_stmt(struct compiling *c, const node *n)
2613 {
2614 /* assert_stmt: 'assert' test [',' test] */
2615 REQ(n, assert_stmt);
2616 if (NCH(n) == 2) {
2617 expr_ty expression = ast_for_expr(c, CHILD(n, 1));
2618 if (!expression)
2619 return NULL;
2620 return Assert(expression, NULL, LINENO(n), n->n_col_offset,
2621 c->c_arena);
2622 }
2623 else if (NCH(n) == 4) {
2624 expr_ty expr1, expr2;
2625
2626 expr1 = ast_for_expr(c, CHILD(n, 1));
2627 if (!expr1)
2628 return NULL;
2629 expr2 = ast_for_expr(c, CHILD(n, 3));
2630 if (!expr2)
2631 return NULL;
2632
2633 return Assert(expr1, expr2, LINENO(n), n->n_col_offset, c->c_arena);
2634 }
2635 PyErr_Format(PyExc_SystemError,
2636 "improper number of parts to 'assert' statement: %d",
2637 NCH(n));
2638 return NULL;
2639 }
2640
2641 static asdl_seq *
2642 ast_for_suite(struct compiling *c, const node *n)
2643 {
2644 /* suite: simple_stmt | NEWLINE INDENT stmt+ DEDENT */
2645 asdl_seq *seq;
2646 stmt_ty s;
2647 int i, total, num, end, pos = 0;
2648 node *ch;
2649
2650 REQ(n, suite);
2651
2652 total = num_stmts(n);
2653 seq = asdl_seq_new(total, c->c_arena);
2654 if (!seq)
2655 return NULL;
2656 if (TYPE(CHILD(n, 0)) == simple_stmt) {
2657 n = CHILD(n, 0);
2658 /* simple_stmt always ends with a NEWLINE,
2659 and may have a trailing SEMI
2660 */
2661 end = NCH(n) - 1;
2662 if (TYPE(CHILD(n, end - 1)) == SEMI)
2663 end--;
2664 /* loop by 2 to skip semi-colons */
2665 for (i = 0; i < end; i += 2) {
2666 ch = CHILD(n, i);
2667 s = ast_for_stmt(c, ch);
2668 if (!s)
2669 return NULL;
2670 asdl_seq_SET(seq, pos++, s);
2671 }
2672 }
2673 else {
2674 for (i = 2; i < (NCH(n) - 1); i++) {
2675 ch = CHILD(n, i);
2676 REQ(ch, stmt);
2677 num = num_stmts(ch);
2678 if (num == 1) {
2679 /* small_stmt or compound_stmt with only one child */
2680 s = ast_for_stmt(c, ch);
2681 if (!s)
2682 return NULL;
2683 asdl_seq_SET(seq, pos++, s);
2684 }
2685 else {
2686 int j;
2687 ch = CHILD(ch, 0);
2688 REQ(ch, simple_stmt);
2689 for (j = 0; j < NCH(ch); j += 2) {
2690 /* statement terminates with a semi-colon ';' */
2691 if (NCH(CHILD(ch, j)) == 0) {
2692 assert((j + 1) == NCH(ch));
2693 break;
2694 }
2695 s = ast_for_stmt(c, CHILD(ch, j));
2696 if (!s)
2697 return NULL;
2698 asdl_seq_SET(seq, pos++, s);
2699 }
2700 }
2701 }
2702 }
2703 assert(pos == seq->size);
2704 return seq;
2705 }
2706
2707 static stmt_ty
2708 ast_for_if_stmt(struct compiling *c, const node *n)
2709 {
2710 /* if_stmt: 'if' test ':' suite ('elif' test ':' suite)*
2711 ['else' ':' suite]
2712 */
2713 char *s;
2714
2715 REQ(n, if_stmt);
2716
2717 if (NCH(n) == 4) {
2718 expr_ty expression;
2719 asdl_seq *suite_seq;
2720
2721 expression = ast_for_expr(c, CHILD(n, 1));
2722 if (!expression)
2723 return NULL;
2724 suite_seq = ast_for_suite(c, CHILD(n, 3));
2725 if (!suite_seq)
2726 return NULL;
2727
2728 return If(expression, suite_seq, NULL, LINENO(n), n->n_col_offset,
2729 c->c_arena);
2730 }
2731
2732 s = STR(CHILD(n, 4));
2733 /* s[2], the third character in the string, will be
2734 's' for el_s_e, or
2735 'i' for el_i_f
2736 */
2737 if (s[2] == 's') {
2738 expr_ty expression;
2739 asdl_seq *seq1, *seq2;
2740
2741 expression = ast_for_expr(c, CHILD(n, 1));
2742 if (!expression)
2743 return NULL;
2744 seq1 = ast_for_suite(c, CHILD(n, 3));
2745 if (!seq1)
2746 return NULL;
2747 seq2 = ast_for_suite(c, CHILD(n, 6));
2748 if (!seq2)
2749 return NULL;
2750
2751 return If(expression, seq1, seq2, LINENO(n), n->n_col_offset,
2752 c->c_arena);
2753 }
2754 else if (s[2] == 'i') {
2755 int i, n_elif, has_else = 0;
2756 expr_ty expression;
2757 asdl_seq *suite_seq;
2758 asdl_seq *orelse = NULL;
2759 n_elif = NCH(n) - 4;
2760 /* must reference the child n_elif+1 since 'else' token is third,
2761 not fourth, child from the end. */
2762 if (TYPE(CHILD(n, (n_elif + 1))) == NAME
2763 && STR(CHILD(n, (n_elif + 1)))[2] == 's') {
2764 has_else = 1;
2765 n_elif -= 3;
2766 }
2767 n_elif /= 4;
2768
2769 if (has_else) {
2770 asdl_seq *suite_seq2;
2771
2772 orelse = asdl_seq_new(1, c->c_arena);
2773 if (!orelse)
2774 return NULL;
2775 expression = ast_for_expr(c, CHILD(n, NCH(n) - 6));
2776 if (!expression)
2777 return NULL;
2778 suite_seq = ast_for_suite(c, CHILD(n, NCH(n) - 4));
2779 if (!suite_seq)
2780 return NULL;
2781 suite_seq2 = ast_for_suite(c, CHILD(n, NCH(n) - 1));
2782 if (!suite_seq2)
2783 return NULL;
2784
2785 asdl_seq_SET(orelse, 0,
2786 If(expression, suite_seq, suite_seq2,
2787 LINENO(CHILD(n, NCH(n) - 6)),
2788 CHILD(n, NCH(n) - 6)->n_col_offset,
2789 c->c_arena));
2790 /* the just-created orelse handled the last elif */
2791 n_elif--;
2792 }
2793
2794 for (i = 0; i < n_elif; i++) {
2795 int off = 5 + (n_elif - i - 1) * 4;
2796 asdl_seq *newobj = asdl_seq_new(1, c->c_arena);
2797 if (!newobj)
2798 return NULL;
2799 expression = ast_for_expr(c, CHILD(n, off));
2800 if (!expression)
2801 return NULL;
2802 suite_seq = ast_for_suite(c, CHILD(n, off + 2));
2803 if (!suite_seq)
2804 return NULL;
2805
2806 asdl_seq_SET(newobj, 0,
2807 If(expression, suite_seq, orelse,
2808 LINENO(CHILD(n, off)),
2809 CHILD(n, off)->n_col_offset, c->c_arena));
2810 orelse = newobj;
2811 }
2812 expression = ast_for_expr(c, CHILD(n, 1));
2813 if (!expression)
2814 return NULL;
2815 suite_seq = ast_for_suite(c, CHILD(n, 3));
2816 if (!suite_seq)
2817 return NULL;
2818 return If(expression, suite_seq, orelse,
2819 LINENO(n), n->n_col_offset, c->c_arena);
2820 }
2821
2822 PyErr_Format(PyExc_SystemError,
2823 "unexpected token in 'if' statement: %s", s);
2824 return NULL;
2825 }
2826
2827 static stmt_ty
2828 ast_for_while_stmt(struct compiling *c, const node *n)
2829 {
2830 /* while_stmt: 'while' test ':' suite ['else' ':' suite] */
2831 REQ(n, while_stmt);
2832
2833 if (NCH(n) == 4) {
2834 expr_ty expression;
2835 asdl_seq *suite_seq;
2836
2837 expression = ast_for_expr(c, CHILD(n, 1));
2838 if (!expression)
2839 return NULL;
2840 suite_seq = ast_for_suite(c, CHILD(n, 3));
2841 if (!suite_seq)
2842 return NULL;
2843 return While(expression, suite_seq, NULL, LINENO(n), n->n_col_offset,
2844 c->c_arena);
2845 }
2846 else if (NCH(n) == 7) {
2847 expr_ty expression;
2848 asdl_seq *seq1, *seq2;
2849
2850 expression = ast_for_expr(c, CHILD(n, 1));
2851 if (!expression)
2852 return NULL;
2853 seq1 = ast_for_suite(c, CHILD(n, 3));
2854 if (!seq1)
2855 return NULL;
2856 seq2 = ast_for_suite(c, CHILD(n, 6));
2857 if (!seq2)
2858 return NULL;
2859
2860 return While(expression, seq1, seq2, LINENO(n), n->n_col_offset,
2861 c->c_arena);
2862 }
2863
2864 PyErr_Format(PyExc_SystemError,
2865 "wrong number of tokens for 'while' statement: %d",
2866 NCH(n));
2867 return NULL;
2868 }
2869
2870 static stmt_ty
2871 ast_for_for_stmt(struct compiling *c, const node *n)
2872 {
2873 asdl_seq *_target, *seq = NULL, *suite_seq;
2874 expr_ty expression;
2875 expr_ty target, first;
2876 const node *node_target;
2877 /* for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite] */
2878 REQ(n, for_stmt);
2879
2880 if (NCH(n) == 9) {
2881 seq = ast_for_suite(c, CHILD(n, 8));
2882 if (!seq)
2883 return NULL;
2884 }
2885
2886 node_target = CHILD(n, 1);
2887 _target = ast_for_exprlist(c, node_target, Store);
2888 if (!_target)
2889 return NULL;
2890 /* Check the # of children rather than the length of _target, since
2891 for x, in ... has 1 element in _target, but still requires a Tuple. */
2892 first = (expr_ty)asdl_seq_GET(_target, 0);
2893 if (NCH(node_target) == 1)
2894 target = first;
2895 else
2896 target = Tuple(_target, Store, first->lineno, first->col_offset, c->c_arena);
2897
2898 expression = ast_for_testlist(c, CHILD(n, 3));
2899 if (!expression)
2900 return NULL;
2901 suite_seq = ast_for_suite(c, CHILD(n, 5));
2902 if (!suite_seq)
2903 return NULL;
2904
2905 return For(target, expression, suite_seq, seq, LINENO(n), n->n_col_offset,
2906 c->c_arena);
2907 }
2908
2909 static excepthandler_ty
2910 ast_for_except_clause(struct compiling *c, const node *exc, node *body)
2911 {
2912 /* except_clause: 'except' [test [(',' | 'as') test]] */
2913 REQ(exc, except_clause);
2914 REQ(body, suite);
2915
2916 if (NCH(exc) == 1) {
2917 asdl_seq *suite_seq = ast_for_suite(c, body);
2918 if (!suite_seq)
2919 return NULL;
2920
2921 return ExceptHandler(NULL, NULL, suite_seq, LINENO(exc),
2922 exc->n_col_offset, c->c_arena);
2923 }
2924 else if (NCH(exc) == 2) {
2925 expr_ty expression;
2926 asdl_seq *suite_seq;
2927
2928 expression = ast_for_expr(c, CHILD(exc, 1));
2929 if (!expression)
2930 return NULL;
2931 suite_seq = ast_for_suite(c, body);
2932 if (!suite_seq)
2933 return NULL;
2934
2935 return ExceptHandler(expression, NULL, suite_seq, LINENO(exc),
2936 exc->n_col_offset, c->c_arena);
2937 }
2938 else if (NCH(exc) == 4) {
2939 asdl_seq *suite_seq;
2940 expr_ty expression;
2941 expr_ty e = ast_for_expr(c, CHILD(exc, 3));
2942 if (!e)
2943 return NULL;
2944 if (!set_context(c, e, Store, CHILD(exc, 3)))
2945 return NULL;
2946 expression = ast_for_expr(c, CHILD(exc, 1));
2947 if (!expression)
2948 return NULL;
2949 suite_seq = ast_for_suite(c, body);
2950 if (!suite_seq)
2951 return NULL;
2952
2953 return ExceptHandler(expression, e, suite_seq, LINENO(exc),
2954 exc->n_col_offset, c->c_arena);
2955 }
2956
2957 PyErr_Format(PyExc_SystemError,
2958 "wrong number of children for 'except' clause: %d",
2959 NCH(exc));
2960 return NULL;
2961 }
2962
2963 static stmt_ty
2964 ast_for_try_stmt(struct compiling *c, const node *n)
2965 {
2966 const int nch = NCH(n);
2967 int n_except = (nch - 3)/3;
2968 asdl_seq *body, *orelse = NULL, *finally = NULL;
2969
2970 REQ(n, try_stmt);
2971
2972 body = ast_for_suite(c, CHILD(n, 2));
2973 if (body == NULL)
2974 return NULL;
2975
2976 if (TYPE(CHILD(n, nch - 3)) == NAME) {
2977 if (strcmp(STR(CHILD(n, nch - 3)), "finally") == 0) {
2978 if (nch >= 9 && TYPE(CHILD(n, nch - 6)) == NAME) {
2979 /* we can assume it's an "else",
2980 because nch >= 9 for try-else-finally and
2981 it would otherwise have a type of except_clause */
2982 orelse = ast_for_suite(c, CHILD(n, nch - 4));
2983 if (orelse == NULL)
2984 return NULL;
2985 n_except--;
2986 }
2987
2988 finally = ast_for_suite(c, CHILD(n, nch - 1));
2989 if (finally == NULL)
2990 return NULL;
2991 n_except--;
2992 }
2993 else {
2994 /* we can assume it's an "else",
2995 otherwise it would have a type of except_clause */
2996 orelse = ast_for_suite(c, CHILD(n, nch - 1));
2997 if (orelse == NULL)
2998 return NULL;
2999 n_except--;
3000 }
3001 }
3002 else if (TYPE(CHILD(n, nch - 3)) != except_clause) {
3003 ast_error(n, "malformed 'try' statement");
3004 return NULL;
3005 }
3006
3007 if (n_except > 0) {
3008 int i;
3009 stmt_ty except_st;
3010 /* process except statements to create a try ... except */
3011 asdl_seq *handlers = asdl_seq_new(n_except, c->c_arena);
3012 if (handlers == NULL)
3013 return NULL;
3014
3015 for (i = 0; i < n_except; i++) {
3016 excepthandler_ty e = ast_for_except_clause(c, CHILD(n, 3 + i * 3),
3017 CHILD(n, 5 + i * 3));
3018 if (!e)
3019 return NULL;
3020 asdl_seq_SET(handlers, i, e);
3021 }
3022
3023 except_st = TryExcept(body, handlers, orelse, LINENO(n),
3024 n->n_col_offset, c->c_arena);
3025 if (!finally)
3026 return except_st;
3027
3028 /* if a 'finally' is present too, we nest the TryExcept within a
3029 TryFinally to emulate try ... except ... finally */
3030 body = asdl_seq_new(1, c->c_arena);
3031 if (body == NULL)
3032 return NULL;
3033 asdl_seq_SET(body, 0, except_st);
3034 }
3035
3036 /* must be a try ... finally (except clauses are in body, if any exist) */
3037 assert(finally != NULL);
3038 return TryFinally(body, finally, LINENO(n), n->n_col_offset, c->c_arena);
3039 }
3040
3041 /* with_item: test ['as' expr] */
3042 static stmt_ty
3043 ast_for_with_item(struct compiling *c, const node *n, asdl_seq *content)
3044 {
3045 expr_ty context_expr, optional_vars = NULL;
3046
3047 REQ(n, with_item);
3048 context_expr = ast_for_expr(c, CHILD(n, 0));
3049 if (!context_expr)
3050 return NULL;
3051 if (NCH(n) == 3) {
3052 optional_vars = ast_for_expr(c, CHILD(n, 2));
3053
3054 if (!optional_vars) {
3055 return NULL;
3056 }
3057 if (!set_context(c, optional_vars, Store, n)) {
3058 return NULL;
3059 }
3060 }
3061
3062 return With(context_expr, optional_vars, content, LINENO(n),
3063 n->n_col_offset, c->c_arena);
3064 }
3065
3066 /* with_stmt: 'with' with_item (',' with_item)* ':' suite */
3067 static stmt_ty
3068 ast_for_with_stmt(struct compiling *c, const node *n)
3069 {
3070 int i;
3071 stmt_ty ret;
3072 asdl_seq *inner;
3073
3074 REQ(n, with_stmt);
3075
3076 /* process the with items inside-out */
3077 i = NCH(n) - 1;
3078 /* the suite of the innermost with item is the suite of the with stmt */
3079 inner = ast_for_suite(c, CHILD(n, i));
3080 if (!inner)
3081 return NULL;
3082
3083 for (;;) {
3084 i -= 2;
3085 ret = ast_for_with_item(c, CHILD(n, i), inner);
3086 if (!ret)
3087 return NULL;
3088 /* was this the last item? */
3089 if (i == 1)
3090 break;
3091 /* if not, wrap the result so far in a new sequence */
3092 inner = asdl_seq_new(1, c->c_arena);
3093 if (!inner)
3094 return NULL;
3095 asdl_seq_SET(inner, 0, ret);
3096 }
3097
3098 return ret;
3099 }
3100
3101 static stmt_ty
3102 ast_for_classdef(struct compiling *c, const node *n, asdl_seq *decorator_seq)
3103 {
3104 /* classdef: 'class' NAME ['(' testlist ')'] ':' suite */
3105 PyObject *classname;
3106 asdl_seq *bases, *s;
3107
3108 REQ(n, classdef);
3109
3110 if (!forbidden_check(c, n, STR(CHILD(n, 1))))
3111 return NULL;
3112
3113 if (NCH(n) == 4) {
3114 s = ast_for_suite(c, CHILD(n, 3));
3115 if (!s)
3116 return NULL;
3117 classname = NEW_IDENTIFIER(CHILD(n, 1));
3118 if (!classname)
3119 return NULL;
3120 return ClassDef(classname, NULL, s, decorator_seq, LINENO(n),
3121 n->n_col_offset, c->c_arena);
3122 }
3123 /* check for empty base list */
3124 if (TYPE(CHILD(n,3)) == RPAR) {
3125 s = ast_for_suite(c, CHILD(n,5));
3126 if (!s)
3127 return NULL;
3128 classname = NEW_IDENTIFIER(CHILD(n, 1));
3129 if (!classname)
3130 return NULL;
3131 return ClassDef(classname, NULL, s, decorator_seq, LINENO(n),
3132 n->n_col_offset, c->c_arena);
3133 }
3134
3135 /* else handle the base class list */
3136 bases = ast_for_class_bases(c, CHILD(n, 3));
3137 if (!bases)
3138 return NULL;
3139
3140 s = ast_for_suite(c, CHILD(n, 6));
3141 if (!s)
3142 return NULL;
3143 classname = NEW_IDENTIFIER(CHILD(n, 1));
3144 if (!classname)
3145 return NULL;
3146 return ClassDef(classname, bases, s, decorator_seq,
3147 LINENO(n), n->n_col_offset, c->c_arena);
3148 }
3149
3150 static stmt_ty
3151 ast_for_stmt(struct compiling *c, const node *n)
3152 {
3153 if (TYPE(n) == stmt) {
3154 assert(NCH(n) == 1);
3155 n = CHILD(n, 0);
3156 }
3157 if (TYPE(n) == simple_stmt) {
3158 assert(num_stmts(n) == 1);
3159 n = CHILD(n, 0);
3160 }
3161 if (TYPE(n) == small_stmt) {
3162 n = CHILD(n, 0);
3163 /* small_stmt: expr_stmt | print_stmt | del_stmt | pass_stmt
3164 | flow_stmt | import_stmt | global_stmt | exec_stmt
3165 | assert_stmt
3166 */
3167 switch (TYPE(n)) {
3168 case expr_stmt:
3169 return ast_for_expr_stmt(c, n);
3170 case print_stmt:
3171 return ast_for_print_stmt(c, n);
3172 case del_stmt:
3173 return ast_for_del_stmt(c, n);
3174 case pass_stmt:
3175 return Pass(LINENO(n), n->n_col_offset, c->c_arena);
3176 case flow_stmt:
3177 return ast_for_flow_stmt(c, n);
3178 case import_stmt:
3179 return ast_for_import_stmt(c, n);
3180 case global_stmt:
3181 return ast_for_global_stmt(c, n);
3182 case exec_stmt:
3183 return ast_for_exec_stmt(c, n);
3184 case assert_stmt:
3185 return ast_for_assert_stmt(c, n);
3186 default:
3187 PyErr_Format(PyExc_SystemError,
3188 "unhandled small_stmt: TYPE=%d NCH=%d\n",
3189 TYPE(n), NCH(n));
3190 return NULL;
3191 }
3192 }
3193 else {
3194 /* compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt
3195 | funcdef | classdef | decorated
3196 */
3197 node *ch = CHILD(n, 0);
3198 REQ(n, compound_stmt);
3199 switch (TYPE(ch)) {
3200 case if_stmt:
3201 return ast_for_if_stmt(c, ch);
3202 case while_stmt:
3203 return ast_for_while_stmt(c, ch);
3204 case for_stmt:
3205 return ast_for_for_stmt(c, ch);
3206 case try_stmt:
3207 return ast_for_try_stmt(c, ch);
3208 case with_stmt:
3209 return ast_for_with_stmt(c, ch);
3210 case funcdef:
3211 return ast_for_funcdef(c, ch, NULL);
3212 case classdef:
3213 return ast_for_classdef(c, ch, NULL);
3214 case decorated:
3215 return ast_for_decorated(c, ch);
3216 default:
3217 PyErr_Format(PyExc_SystemError,
3218 "unhandled small_stmt: TYPE=%d NCH=%d\n",
3219 TYPE(n), NCH(n));
3220 return NULL;
3221 }
3222 }
3223 }
3224
3225 static PyObject *
3226 parsenumber(struct compiling *c, const char *s)
3227 {
3228 const char *end;
3229 long x;
3230 double dx;
3231 #ifndef WITHOUT_COMPLEX
3232 Py_complex complex;
3233 int imflag;
3234 #endif
3235
3236 assert(s != NULL);
3237 errno = 0;
3238 end = s + strlen(s) - 1;
3239 #ifndef WITHOUT_COMPLEX
3240 imflag = *end == 'j' || *end == 'J';
3241 #endif
3242 if (*end == 'l' || *end == 'L')
3243 return PyLong_FromString((char *)s, (char **)0, 0);
3244 x = PyOS_strtol((char *)s, (char **)&end, 0);
3245 if (*end == '\0') {
3246 if (errno != 0)
3247 return PyLong_FromString((char *)s, (char **)0, 0);
3248 return PyInt_FromLong(x);
3249 }
3250 /* XXX Huge floats may silently fail */
3251 #ifndef WITHOUT_COMPLEX
3252 if (imflag) {
3253 complex.real = 0.;
3254 complex.imag = PyOS_string_to_double(s, (char **)&end, NULL);
3255 if (complex.imag == -1.0 && PyErr_Occurred())
3256 return NULL;
3257 return PyComplex_FromCComplex(complex);
3258 }
3259 else
3260 #endif
3261 {
3262 dx = PyOS_string_to_double(s, NULL, NULL);
3263 if (dx == -1.0 && PyErr_Occurred())
3264 return NULL;
3265 return PyFloat_FromDouble(dx);
3266 }
3267 }
3268
3269 static PyObject *
3270 decode_utf8(struct compiling *c, const char **sPtr, const char *end, char* encoding)
3271 {
3272 #ifndef Py_USING_UNICODE
3273 Py_FatalError("decode_utf8 should not be called in this build.");
3274 return NULL;
3275 #else
3276 PyObject *u, *v;
3277 char *s, *t;
3278 t = s = (char *)*sPtr;
3279 /* while (s < end && *s != '\\') s++; */ /* inefficient for u".." */
3280 while (s < end && (*s & 0x80)) s++;
3281 *sPtr = s;
3282 u = PyUnicode_DecodeUTF8(t, s - t, NULL);
3283 if (u == NULL)
3284 return NULL;
3285 v = PyUnicode_AsEncodedString(u, encoding, NULL);
3286 Py_DECREF(u);
3287 return v;
3288 #endif
3289 }
3290
3291 #ifdef Py_USING_UNICODE
3292 static PyObject *
3293 decode_unicode(struct compiling *c, const char *s, size_t len, int rawmode, const char *encoding)
3294 {
3295 PyObject *v, *u;
3296 char *buf;
3297 char *p;
3298 const char *end;
3299 if (encoding == NULL) {
3300 buf = (char *)s;
3301 u = NULL;
3302 } else if (strcmp(encoding, "iso-8859-1") == 0) {
3303 buf = (char *)s;
3304 u = NULL;
3305 } else {
3306 /* check for integer overflow */
3307 if (len > PY_SIZE_MAX / 6)
3308 return NULL;
3309 /* "<C3><A4>" (2 bytes) may become "\U000000E4" (10 bytes), or 1:5
3310 "\รค" (3 bytes) may become "\u005c\U000000E4" (16 bytes), or ~1:6 */
3311 u = PyString_FromStringAndSize((char *)NULL, len * 6);
3312 if (u == NULL)
3313 return NULL;
3314 p = buf = PyString_AsString(u);
3315 end = s + len;
3316 while (s < end) {
3317 if (*s == '\\') {
3318 *p++ = *s++;
3319 if (*s & 0x80) {
3320 strcpy(p, "u005c");
3321 p += 5;
3322 }
3323 }
3324 if (*s & 0x80) { /* XXX inefficient */
3325 PyObject *w;
3326 char *r;
3327 Py_ssize_t rn, i;
3328 w = decode_utf8(c, &s, end, "utf-32-be");
3329 if (w == NULL) {
3330 Py_DECREF(u);
3331 return NULL;
3332 }
3333 r = PyString_AsString(w);
3334 rn = PyString_Size(w);
3335 assert(rn % 4 == 0);
3336 for (i = 0; i < rn; i += 4) {
3337 sprintf(p, "\\U%02x%02x%02x%02x",
3338 r[i + 0] & 0xFF,
3339 r[i + 1] & 0xFF,
3340 r[i + 2] & 0xFF,
3341 r[i + 3] & 0xFF);
3342 p += 10;
3343 }
3344 Py_DECREF(w);
3345 } else {
3346 *p++ = *s++;
3347 }
3348 }
3349 len = p - buf;
3350 s = buf;
3351 }
3352 if (rawmode)
3353 v = PyUnicode_DecodeRawUnicodeEscape(s, len, NULL);
3354 else
3355 v = PyUnicode_DecodeUnicodeEscape(s, len, NULL);
3356 Py_XDECREF(u);
3357 return v;
3358 }
3359 #endif
3360
3361 /* s is a Python string literal, including the bracketing quote characters,
3362 * and r &/or u prefixes (if any), and embedded escape sequences (if any).
3363 * parsestr parses it, and returns the decoded Python string object.
3364 */
3365 static PyObject *
3366 parsestr(struct compiling *c, const char *s)
3367 {
3368 size_t len;
3369 int quote = Py_CHARMASK(*s);
3370 int rawmode = 0;
3371 int need_encoding;
3372 int unicode = c->c_future_unicode;
3373
3374 if (isalpha(quote) || quote == '_') {
3375 if (quote == 'u' || quote == 'U') {
3376 quote = *++s;
3377 unicode = 1;
3378 }
3379 if (quote == 'b' || quote == 'B') {
3380 quote = *++s;
3381 unicode = 0;
3382 }
3383 if (quote == 'r' || quote == 'R') {
3384 quote = *++s;
3385 rawmode = 1;
3386 }
3387 }
3388 if (quote != '\'' && quote != '\"') {
3389 PyErr_BadInternalCall();
3390 return NULL;
3391 }
3392 s++;
3393 len = strlen(s);
3394 if (len > INT_MAX) {
3395 PyErr_SetString(PyExc_OverflowError,
3396 "string to parse is too long");
3397 return NULL;
3398 }
3399 if (s[--len] != quote) {
3400 PyErr_BadInternalCall();
3401 return NULL;
3402 }
3403 if (len >= 4 && s[0] == quote && s[1] == quote) {
3404 s += 2;
3405 len -= 2;
3406 if (s[--len] != quote || s[--len] != quote) {
3407 PyErr_BadInternalCall();
3408 return NULL;
3409 }
3410 }
3411 #ifdef Py_USING_UNICODE
3412 if (unicode || Py_UnicodeFlag) {
3413 return decode_unicode(c, s, len, rawmode, c->c_encoding);
3414 }
3415 #endif
3416 need_encoding = (c->c_encoding != NULL &&
3417 strcmp(c->c_encoding, "utf-8") != 0 &&
3418 strcmp(c->c_encoding, "iso-8859-1") != 0);
3419 if (rawmode || strchr(s, '\\') == NULL) {
3420 if (need_encoding) {
3421 #ifndef Py_USING_UNICODE
3422 /* This should not happen - we never see any other
3423 encoding. */
3424 Py_FatalError(
3425 "cannot deal with encodings in this build.");
3426 #else
3427 PyObject *v, *u = PyUnicode_DecodeUTF8(s, len, NULL);
3428 if (u == NULL)
3429 return NULL;
3430 v = PyUnicode_AsEncodedString(u, c->c_encoding, NULL);
3431 Py_DECREF(u);
3432 return v;
3433 #endif
3434 } else {
3435 return PyString_FromStringAndSize(s, len);
3436 }
3437 }
3438
3439 return PyString_DecodeEscape(s, len, NULL, unicode,
3440 need_encoding ? c->c_encoding : NULL);
3441 }
3442
3443 /* Build a Python string object out of a STRING atom. This takes care of
3444 * compile-time literal catenation, calling parsestr() on each piece, and
3445 * pasting the intermediate results together.
3446 */
3447 static PyObject *
3448 parsestrplus(struct compiling *c, const node *n)
3449 {
3450 PyObject *v;
3451 int i;
3452 REQ(CHILD(n, 0), STRING);
3453 if ((v = parsestr(c, STR(CHILD(n, 0)))) != NULL) {
3454 /* String literal concatenation */
3455 for (i = 1; i < NCH(n); i++) {
3456 PyObject *s;
3457 s = parsestr(c, STR(CHILD(n, i)));
3458 if (s == NULL)
3459 goto onError;
3460 if (PyString_Check(v) && PyString_Check(s)) {
3461 PyString_ConcatAndDel(&v, s);
3462 if (v == NULL)
3463 goto onError;
3464 }
3465 #ifdef Py_USING_UNICODE
3466 else {
3467 PyObject *temp = PyUnicode_Concat(v, s);
3468 Py_DECREF(s);
3469 Py_DECREF(v);
3470 v = temp;
3471 if (v == NULL)
3472 goto onError;
3473 }
3474 #endif
3475 }
3476 }
3477 return v;
3478
3479 onError:
3480 Py_XDECREF(v);
3481 return NULL;
3482 }
python git mirror