?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
- Issue #6624: yArg_ParseTuple with "s" format when parsing argument with
[python.git] / Python / ast.c
blob0644da830052cfaebafebf969f3c7e078644d19c
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 handle_fpdef:
697 /* XXX Need to worry about checking if TYPE(CHILD(n, i+1)) is
698 anything other than EQUAL or a comma? */
699 /* XXX Should NCH(n) check be made a separate check? */
700 if (i + 1 < NCH(n) && TYPE(CHILD(n, i + 1)) == EQUAL) {
701 expr_ty expression = ast_for_expr(c, CHILD(n, i + 2));
702 if (!expression)
703 goto error;
704 assert(defaults != NULL);
705 asdl_seq_SET(defaults, j++, expression);
706 i += 2;
707 found_default = 1;
708 }
709 else if (found_default) {
710 ast_error(n,
711 "non-default argument follows default argument");
712 goto error;
713 }
714 if (NCH(ch) == 3) {
715 ch = CHILD(ch, 1);
716 /* def foo((x)): is not complex, special case. */
717 if (NCH(ch) != 1) {
718 /* We have complex arguments, setup for unpacking. */
719 if (Py_Py3kWarningFlag && !ast_warn(c, ch,
720 "tuple parameter unpacking has been removed in 3.x"))
721 goto error;
722 asdl_seq_SET(args, k++, compiler_complex_args(c, ch));
723 if (!asdl_seq_GET(args, k-1))
724 goto error;
725 } else {
726 /* def foo((x)): setup for checking NAME below. */
727 /* Loop because there can be many parens and tuple
728 unpacking mixed in. */
729 ch = CHILD(ch, 0);
730 assert(TYPE(ch) == fpdef);
731 goto handle_fpdef;
732 }
733 }
734 if (TYPE(CHILD(ch, 0)) == NAME) {
735 PyObject *id;
736 expr_ty name;
737 if (!forbidden_check(c, n, STR(CHILD(ch, 0))))
738 goto error;
739 id = NEW_IDENTIFIER(CHILD(ch, 0));
740 if (!id)
741 goto error;
742 name = Name(id, Param, LINENO(ch), ch->n_col_offset,
743 c->c_arena);
744 if (!name)
745 goto error;
746 asdl_seq_SET(args, k++, name);
747
748 }
749 i += 2; /* the name and the comma */
750 break;
751 case STAR:
752 if (!forbidden_check(c, CHILD(n, i+1), STR(CHILD(n, i+1))))
753 goto error;
754 vararg = NEW_IDENTIFIER(CHILD(n, i+1));
755 if (!vararg)
756 goto error;
757 i += 3;
758 break;
759 case DOUBLESTAR:
760 if (!forbidden_check(c, CHILD(n, i+1), STR(CHILD(n, i+1))))
761 goto error;
762 kwarg = NEW_IDENTIFIER(CHILD(n, i+1));
763 if (!kwarg)
764 goto error;
765 i += 3;
766 break;
767 default:
768 PyErr_Format(PyExc_SystemError,
769 "unexpected node in varargslist: %d @ %d",
770 TYPE(ch), i);
771 goto error;
772 }
773 }
774
775 return arguments(args, vararg, kwarg, defaults, c->c_arena);
776
777 error:
778 Py_XDECREF(vararg);
779 Py_XDECREF(kwarg);
780 return NULL;
781 }
782
783 static expr_ty
784 ast_for_dotted_name(struct compiling *c, const node *n)
785 {
786 expr_ty e;
787 identifier id;
788 int lineno, col_offset;
789 int i;
790
791 REQ(n, dotted_name);
792
793 lineno = LINENO(n);
794 col_offset = n->n_col_offset;
795
796 id = NEW_IDENTIFIER(CHILD(n, 0));
797 if (!id)
798 return NULL;
799 e = Name(id, Load, lineno, col_offset, c->c_arena);
800 if (!e)
801 return NULL;
802
803 for (i = 2; i < NCH(n); i+=2) {
804 id = NEW_IDENTIFIER(CHILD(n, i));
805 if (!id)
806 return NULL;
807 e = Attribute(e, id, Load, lineno, col_offset, c->c_arena);
808 if (!e)
809 return NULL;
810 }
811
812 return e;
813 }
814
815 static expr_ty
816 ast_for_decorator(struct compiling *c, const node *n)
817 {
818 /* decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE */
819 expr_ty d = NULL;
820 expr_ty name_expr;
821
822 REQ(n, decorator);
823 REQ(CHILD(n, 0), AT);
824 REQ(RCHILD(n, -1), NEWLINE);
825
826 name_expr = ast_for_dotted_name(c, CHILD(n, 1));
827 if (!name_expr)
828 return NULL;
829
830 if (NCH(n) == 3) { /* No arguments */
831 d = name_expr;
832 name_expr = NULL;
833 }
834 else if (NCH(n) == 5) { /* Call with no arguments */
835 d = Call(name_expr, NULL, NULL, NULL, NULL, LINENO(n),
836 n->n_col_offset, c->c_arena);
837 if (!d)
838 return NULL;
839 name_expr = NULL;
840 }
841 else {
842 d = ast_for_call(c, CHILD(n, 3), name_expr);
843 if (!d)
844 return NULL;
845 name_expr = NULL;
846 }
847
848 return d;
849 }
850
851 static asdl_seq*
852 ast_for_decorators(struct compiling *c, const node *n)
853 {
854 asdl_seq* decorator_seq;
855 expr_ty d;
856 int i;
857
858 REQ(n, decorators);
859 decorator_seq = asdl_seq_new(NCH(n), c->c_arena);
860 if (!decorator_seq)
861 return NULL;
862
863 for (i = 0; i < NCH(n); i++) {
864 d = ast_for_decorator(c, CHILD(n, i));
865 if (!d)
866 return NULL;
867 asdl_seq_SET(decorator_seq, i, d);
868 }
869 return decorator_seq;
870 }
871
872 static stmt_ty
873 ast_for_funcdef(struct compiling *c, const node *n, asdl_seq *decorator_seq)
874 {
875 /* funcdef: 'def' NAME parameters ':' suite */
876 identifier name;
877 arguments_ty args;
878 asdl_seq *body;
879 int name_i = 1;
880
881 REQ(n, funcdef);
882
883 name = NEW_IDENTIFIER(CHILD(n, name_i));
884 if (!name)
885 return NULL;
886 else if (!forbidden_check(c, CHILD(n, name_i), STR(CHILD(n, name_i))))
887 return NULL;
888 args = ast_for_arguments(c, CHILD(n, name_i + 1));
889 if (!args)
890 return NULL;
891 body = ast_for_suite(c, CHILD(n, name_i + 3));
892 if (!body)
893 return NULL;
894
895 return FunctionDef(name, args, body, decorator_seq, LINENO(n),
896 n->n_col_offset, c->c_arena);
897 }
898
899 static stmt_ty
900 ast_for_decorated(struct compiling *c, const node *n)
901 {
902 /* decorated: decorators (classdef | funcdef) */
903 stmt_ty thing = NULL;
904 asdl_seq *decorator_seq = NULL;
905
906 REQ(n, decorated);
907
908 decorator_seq = ast_for_decorators(c, CHILD(n, 0));
909 if (!decorator_seq)
910 return NULL;
911
912 assert(TYPE(CHILD(n, 1)) == funcdef ||
913 TYPE(CHILD(n, 1)) == classdef);
914
915 if (TYPE(CHILD(n, 1)) == funcdef) {
916 thing = ast_for_funcdef(c, CHILD(n, 1), decorator_seq);
917 } else if (TYPE(CHILD(n, 1)) == classdef) {
918 thing = ast_for_classdef(c, CHILD(n, 1), decorator_seq);
919 }
920 /* we count the decorators in when talking about the class' or
921 function's line number */
922 if (thing) {
923 thing->lineno = LINENO(n);
924 thing->col_offset = n->n_col_offset;
925 }
926 return thing;
927 }
928
929 static expr_ty
930 ast_for_lambdef(struct compiling *c, const node *n)
931 {
932 /* lambdef: 'lambda' [varargslist] ':' test */
933 arguments_ty args;
934 expr_ty expression;
935
936 if (NCH(n) == 3) {
937 args = arguments(NULL, NULL, NULL, NULL, c->c_arena);
938 if (!args)
939 return NULL;
940 expression = ast_for_expr(c, CHILD(n, 2));
941 if (!expression)
942 return NULL;
943 }
944 else {
945 args = ast_for_arguments(c, CHILD(n, 1));
946 if (!args)
947 return NULL;
948 expression = ast_for_expr(c, CHILD(n, 3));
949 if (!expression)
950 return NULL;
951 }
952
953 return Lambda(args, expression, LINENO(n), n->n_col_offset, c->c_arena);
954 }
955
956 static expr_ty
957 ast_for_ifexpr(struct compiling *c, const node *n)
958 {
959 /* test: or_test 'if' or_test 'else' test */
960 expr_ty expression, body, orelse;
961
962 assert(NCH(n) == 5);
963 body = ast_for_expr(c, CHILD(n, 0));
964 if (!body)
965 return NULL;
966 expression = ast_for_expr(c, CHILD(n, 2));
967 if (!expression)
968 return NULL;
969 orelse = ast_for_expr(c, CHILD(n, 4));
970 if (!orelse)
971 return NULL;
972 return IfExp(expression, body, orelse, LINENO(n), n->n_col_offset,
973 c->c_arena);
974 }
975
976 /* XXX(nnorwitz): the listcomp and genexpr code should be refactored
977 so there is only a single version. Possibly for loops can also re-use
978 the code.
979 */
980
981 /* Count the number of 'for' loop in a list comprehension.
982
983 Helper for ast_for_listcomp().
984 */
985
986 static int
987 count_list_fors(struct compiling *c, const node *n)
988 {
989 int n_fors = 0;
990 node *ch = CHILD(n, 1);
991
992 count_list_for:
993 n_fors++;
994 REQ(ch, list_for);
995 if (NCH(ch) == 5)
996 ch = CHILD(ch, 4);
997 else
998 return n_fors;
999 count_list_iter:
1000 REQ(ch, list_iter);
1001 ch = CHILD(ch, 0);
1002 if (TYPE(ch) == list_for)
1003 goto count_list_for;
1004 else if (TYPE(ch) == list_if) {
1005 if (NCH(ch) == 3) {
1006 ch = CHILD(ch, 2);
1007 goto count_list_iter;
1008 }
1009 else
1010 return n_fors;
1011 }
1012
1013 /* Should never be reached */
1014 PyErr_SetString(PyExc_SystemError, "logic error in count_list_fors");
1015 return -1;
1016 }
1017
1018 /* Count the number of 'if' statements in a list comprehension.
1019
1020 Helper for ast_for_listcomp().
1021 */
1022
1023 static int
1024 count_list_ifs(struct compiling *c, const node *n)
1025 {
1026 int n_ifs = 0;
1027
1028 count_list_iter:
1029 REQ(n, list_iter);
1030 if (TYPE(CHILD(n, 0)) == list_for)
1031 return n_ifs;
1032 n = CHILD(n, 0);
1033 REQ(n, list_if);
1034 n_ifs++;
1035 if (NCH(n) == 2)
1036 return n_ifs;
1037 n = CHILD(n, 2);
1038 goto count_list_iter;
1039 }
1040
1041 static expr_ty
1042 ast_for_listcomp(struct compiling *c, const node *n)
1043 {
1044 /* listmaker: test ( list_for | (',' test)* [','] )
1045 list_for: 'for' exprlist 'in' testlist_safe [list_iter]
1046 list_iter: list_for | list_if
1047 list_if: 'if' test [list_iter]
1048 testlist_safe: test [(',' test)+ [',']]
1049 */
1050 expr_ty elt;
1051 asdl_seq *listcomps;
1052 int i, n_fors;
1053 node *ch;
1054
1055 REQ(n, listmaker);
1056 assert(NCH(n) > 1);
1057
1058 elt = ast_for_expr(c, CHILD(n, 0));
1059 if (!elt)
1060 return NULL;
1061
1062 n_fors = count_list_fors(c, n);
1063 if (n_fors == -1)
1064 return NULL;
1065
1066 listcomps = asdl_seq_new(n_fors, c->c_arena);
1067 if (!listcomps)
1068 return NULL;
1069
1070 ch = CHILD(n, 1);
1071 for (i = 0; i < n_fors; i++) {
1072 comprehension_ty lc;
1073 asdl_seq *t;
1074 expr_ty expression;
1075 node *for_ch;
1076
1077 REQ(ch, list_for);
1078
1079 for_ch = CHILD(ch, 1);
1080 t = ast_for_exprlist(c, for_ch, Store);
1081 if (!t)
1082 return NULL;
1083 expression = ast_for_testlist(c, CHILD(ch, 3));
1084 if (!expression)
1085 return NULL;
1086
1087 /* Check the # of children rather than the length of t, since
1088 [x for x, in ... ] has 1 element in t, but still requires a Tuple.
1089 */
1090 if (NCH(for_ch) == 1)
1091 lc = comprehension((expr_ty)asdl_seq_GET(t, 0), expression, NULL,
1092 c->c_arena);
1093 else
1094 lc = comprehension(Tuple(t, Store, LINENO(ch), ch->n_col_offset,
1095 c->c_arena),
1096 expression, NULL, c->c_arena);
1097 if (!lc)
1098 return NULL;
1099
1100 if (NCH(ch) == 5) {
1101 int j, n_ifs;
1102 asdl_seq *ifs;
1103 expr_ty list_for_expr;
1104
1105 ch = CHILD(ch, 4);
1106 n_ifs = count_list_ifs(c, ch);
1107 if (n_ifs == -1)
1108 return NULL;
1109
1110 ifs = asdl_seq_new(n_ifs, c->c_arena);
1111 if (!ifs)
1112 return NULL;
1113
1114 for (j = 0; j < n_ifs; j++) {
1115 REQ(ch, list_iter);
1116 ch = CHILD(ch, 0);
1117 REQ(ch, list_if);
1118
1119 list_for_expr = ast_for_expr(c, CHILD(ch, 1));
1120 if (!list_for_expr)
1121 return NULL;
1122
1123 asdl_seq_SET(ifs, j, list_for_expr);
1124 if (NCH(ch) == 3)
1125 ch = CHILD(ch, 2);
1126 }
1127 /* on exit, must guarantee that ch is a list_for */
1128 if (TYPE(ch) == list_iter)
1129 ch = CHILD(ch, 0);
1130 lc->ifs = ifs;
1131 }
1132 asdl_seq_SET(listcomps, i, lc);
1133 }
1134
1135 return ListComp(elt, listcomps, LINENO(n), n->n_col_offset, c->c_arena);
1136 }
1137
1138 /* Count the number of 'for' loops in a generator expression.
1139
1140 Helper for ast_for_genexp().
1141 */
1142
1143 static int
1144 count_gen_fors(struct compiling *c, const node *n)
1145 {
1146 int n_fors = 0;
1147 node *ch = CHILD(n, 1);
1148
1149 count_gen_for:
1150 n_fors++;
1151 REQ(ch, gen_for);
1152 if (NCH(ch) == 5)
1153 ch = CHILD(ch, 4);
1154 else
1155 return n_fors;
1156 count_gen_iter:
1157 REQ(ch, gen_iter);
1158 ch = CHILD(ch, 0);
1159 if (TYPE(ch) == gen_for)
1160 goto count_gen_for;
1161 else if (TYPE(ch) == gen_if) {
1162 if (NCH(ch) == 3) {
1163 ch = CHILD(ch, 2);
1164 goto count_gen_iter;
1165 }
1166 else
1167 return n_fors;
1168 }
1169
1170 /* Should never be reached */
1171 PyErr_SetString(PyExc_SystemError,
1172 "logic error in count_gen_fors");
1173 return -1;
1174 }
1175
1176 /* Count the number of 'if' statements in a generator expression.
1177
1178 Helper for ast_for_genexp().
1179 */
1180
1181 static int
1182 count_gen_ifs(struct compiling *c, const node *n)
1183 {
1184 int n_ifs = 0;
1185
1186 while (1) {
1187 REQ(n, gen_iter);
1188 if (TYPE(CHILD(n, 0)) == gen_for)
1189 return n_ifs;
1190 n = CHILD(n, 0);
1191 REQ(n, gen_if);
1192 n_ifs++;
1193 if (NCH(n) == 2)
1194 return n_ifs;
1195 n = CHILD(n, 2);
1196 }
1197 }
1198
1199 /* TODO(jhylton): Combine with list comprehension code? */
1200 static expr_ty
1201 ast_for_genexp(struct compiling *c, const node *n)
1202 {
1203 /* testlist_gexp: test ( gen_for | (',' test)* [','] )
1204 argument: [test '='] test [gen_for] # Really [keyword '='] test */
1205 expr_ty elt;
1206 asdl_seq *genexps;
1207 int i, n_fors;
1208 node *ch;
1209
1210 assert(TYPE(n) == (testlist_gexp) || TYPE(n) == (argument));
1211 assert(NCH(n) > 1);
1212
1213 elt = ast_for_expr(c, CHILD(n, 0));
1214 if (!elt)
1215 return NULL;
1216
1217 n_fors = count_gen_fors(c, n);
1218 if (n_fors == -1)
1219 return NULL;
1220
1221 genexps = asdl_seq_new(n_fors, c->c_arena);
1222 if (!genexps)
1223 return NULL;
1224
1225 ch = CHILD(n, 1);
1226 for (i = 0; i < n_fors; i++) {
1227 comprehension_ty ge;
1228 asdl_seq *t;
1229 expr_ty expression;
1230 node *for_ch;
1231
1232 REQ(ch, gen_for);
1233
1234 for_ch = CHILD(ch, 1);
1235 t = ast_for_exprlist(c, for_ch, Store);
1236 if (!t)
1237 return NULL;
1238 expression = ast_for_expr(c, CHILD(ch, 3));
1239 if (!expression)
1240 return NULL;
1241
1242 /* Check the # of children rather than the length of t, since
1243 (x for x, in ...) has 1 element in t, but still requires a Tuple. */
1244 if (NCH(for_ch) == 1)
1245 ge = comprehension((expr_ty)asdl_seq_GET(t, 0), expression,
1246 NULL, c->c_arena);
1247 else
1248 ge = comprehension(Tuple(t, Store, LINENO(ch), ch->n_col_offset,
1249 c->c_arena),
1250 expression, NULL, c->c_arena);
1251
1252 if (!ge)
1253 return NULL;
1254
1255 if (NCH(ch) == 5) {
1256 int j, n_ifs;
1257 asdl_seq *ifs;
1258
1259 ch = CHILD(ch, 4);
1260 n_ifs = count_gen_ifs(c, ch);
1261 if (n_ifs == -1)
1262 return NULL;
1263
1264 ifs = asdl_seq_new(n_ifs, c->c_arena);
1265 if (!ifs)
1266 return NULL;
1267
1268 for (j = 0; j < n_ifs; j++) {
1269 REQ(ch, gen_iter);
1270 ch = CHILD(ch, 0);
1271 REQ(ch, gen_if);
1272
1273 expression = ast_for_expr(c, CHILD(ch, 1));
1274 if (!expression)
1275 return NULL;
1276 asdl_seq_SET(ifs, j, expression);
1277 if (NCH(ch) == 3)
1278 ch = CHILD(ch, 2);
1279 }
1280 /* on exit, must guarantee that ch is a gen_for */
1281 if (TYPE(ch) == gen_iter)
1282 ch = CHILD(ch, 0);
1283 ge->ifs = ifs;
1284 }
1285 asdl_seq_SET(genexps, i, ge);
1286 }
1287
1288 return GeneratorExp(elt, genexps, LINENO(n), n->n_col_offset, c->c_arena);
1289 }
1290
1291 static expr_ty
1292 ast_for_atom(struct compiling *c, const node *n)
1293 {
1294 /* atom: '(' [yield_expr|testlist_gexp] ')' | '[' [listmaker] ']'
1295 | '{' [dictmaker] '}' | '`' testlist '`' | NAME | NUMBER | STRING+
1296 */
1297 node *ch = CHILD(n, 0);
1298
1299 switch (TYPE(ch)) {
1300 case NAME: {
1301 /* All names start in Load context, but may later be
1302 changed. */
1303 PyObject *name = NEW_IDENTIFIER(ch);
1304 if (!name)
1305 return NULL;
1306 return Name(name, Load, LINENO(n), n->n_col_offset, c->c_arena);
1307 }
1308 case STRING: {
1309 PyObject *str = parsestrplus(c, n);
1310 if (!str) {
1311 #ifdef Py_USING_UNICODE
1312 if (PyErr_ExceptionMatches(PyExc_UnicodeError)){
1313 PyObject *type, *value, *tback, *errstr;
1314 PyErr_Fetch(&type, &value, &tback);
1315 errstr = PyObject_Str(value);
1316 if (errstr) {
1317 char *s = "";
1318 char buf[128];
1319 s = PyString_AsString(errstr);
1320 PyOS_snprintf(buf, sizeof(buf), "(unicode error) %s", s);
1321 ast_error(n, buf);
1322 Py_DECREF(errstr);
1323 } else {
1324 ast_error(n, "(unicode error) unknown error");
1325 }
1326 Py_DECREF(type);
1327 Py_DECREF(value);
1328 Py_XDECREF(tback);
1329 }
1330 #endif
1331 return NULL;
1332 }
1333 PyArena_AddPyObject(c->c_arena, str);
1334 return Str(str, LINENO(n), n->n_col_offset, c->c_arena);
1335 }
1336 case NUMBER: {
1337 PyObject *pynum = parsenumber(c, STR(ch));
1338 if (!pynum)
1339 return NULL;
1340
1341 PyArena_AddPyObject(c->c_arena, pynum);
1342 return Num(pynum, LINENO(n), n->n_col_offset, c->c_arena);
1343 }
1344 case LPAR: /* some parenthesized expressions */
1345 ch = CHILD(n, 1);
1346
1347 if (TYPE(ch) == RPAR)
1348 return Tuple(NULL, Load, LINENO(n), n->n_col_offset, c->c_arena);
1349
1350 if (TYPE(ch) == yield_expr)
1351 return ast_for_expr(c, ch);
1352
1353 return ast_for_testlist_gexp(c, ch);
1354 case LSQB: /* list (or list comprehension) */
1355 ch = CHILD(n, 1);
1356
1357 if (TYPE(ch) == RSQB)
1358 return List(NULL, Load, LINENO(n), n->n_col_offset, c->c_arena);
1359
1360 REQ(ch, listmaker);
1361 if (NCH(ch) == 1 || TYPE(CHILD(ch, 1)) == COMMA) {
1362 asdl_seq *elts = seq_for_testlist(c, ch);
1363 if (!elts)
1364 return NULL;
1365
1366 return List(elts, Load, LINENO(n), n->n_col_offset, c->c_arena);
1367 }
1368 else
1369 return ast_for_listcomp(c, ch);
1370 case LBRACE: {
1371 /* dictmaker: test ':' test (',' test ':' test)* [','] */
1372 int i, size;
1373 asdl_seq *keys, *values;
1374
1375 ch = CHILD(n, 1);
1376 size = (NCH(ch) + 1) / 4; /* +1 in case no trailing comma */
1377 keys = asdl_seq_new(size, c->c_arena);
1378 if (!keys)
1379 return NULL;
1380
1381 values = asdl_seq_new(size, c->c_arena);
1382 if (!values)
1383 return NULL;
1384
1385 for (i = 0; i < NCH(ch); i += 4) {
1386 expr_ty expression;
1387
1388 expression = ast_for_expr(c, CHILD(ch, i));
1389 if (!expression)
1390 return NULL;
1391
1392 asdl_seq_SET(keys, i / 4, expression);
1393
1394 expression = ast_for_expr(c, CHILD(ch, i + 2));
1395 if (!expression)
1396 return NULL;
1397
1398 asdl_seq_SET(values, i / 4, expression);
1399 }
1400 return Dict(keys, values, LINENO(n), n->n_col_offset, c->c_arena);
1401 }
1402 case BACKQUOTE: { /* repr */
1403 expr_ty expression;
1404 if (Py_Py3kWarningFlag &&
1405 !ast_warn(c, n, "backquote not supported in 3.x; use repr()"))
1406 return NULL;
1407 expression = ast_for_testlist(c, CHILD(n, 1));
1408 if (!expression)
1409 return NULL;
1410
1411 return Repr(expression, LINENO(n), n->n_col_offset, c->c_arena);
1412 }
1413 default:
1414 PyErr_Format(PyExc_SystemError, "unhandled atom %d", TYPE(ch));
1415 return NULL;
1416 }
1417 }
1418
1419 static slice_ty
1420 ast_for_slice(struct compiling *c, const node *n)
1421 {
1422 node *ch;
1423 expr_ty lower = NULL, upper = NULL, step = NULL;
1424
1425 REQ(n, subscript);
1426
1427 /*
1428 subscript: '.' '.' '.' | test | [test] ':' [test] [sliceop]
1429 sliceop: ':' [test]
1430 */
1431 ch = CHILD(n, 0);
1432 if (TYPE(ch) == DOT)
1433 return Ellipsis(c->c_arena);
1434
1435 if (NCH(n) == 1 && TYPE(ch) == test) {
1436 /* 'step' variable hold no significance in terms of being used over
1437 other vars */
1438 step = ast_for_expr(c, ch);
1439 if (!step)
1440 return NULL;
1441
1442 return Index(step, c->c_arena);
1443 }
1444
1445 if (TYPE(ch) == test) {
1446 lower = ast_for_expr(c, ch);
1447 if (!lower)
1448 return NULL;
1449 }
1450
1451 /* If there's an upper bound it's in the second or third position. */
1452 if (TYPE(ch) == COLON) {
1453 if (NCH(n) > 1) {
1454 node *n2 = CHILD(n, 1);
1455
1456 if (TYPE(n2) == test) {
1457 upper = ast_for_expr(c, n2);
1458 if (!upper)
1459 return NULL;
1460 }
1461 }
1462 } else if (NCH(n) > 2) {
1463 node *n2 = CHILD(n, 2);
1464
1465 if (TYPE(n2) == test) {
1466 upper = ast_for_expr(c, n2);
1467 if (!upper)
1468 return NULL;
1469 }
1470 }
1471
1472 ch = CHILD(n, NCH(n) - 1);
1473 if (TYPE(ch) == sliceop) {
1474 if (NCH(ch) == 1) {
1475 /*
1476 This is an extended slice (ie "x[::]") with no expression in the
1477 step field. We set this literally to "None" in order to
1478 disambiguate it from x[:]. (The interpreter might have to call
1479 __getslice__ for x[:], but it must call __getitem__ for x[::].)
1480 */
1481 identifier none = new_identifier("None", c->c_arena);
1482 if (!none)
1483 return NULL;
1484 ch = CHILD(ch, 0);
1485 step = Name(none, Load, LINENO(ch), ch->n_col_offset, c->c_arena);
1486 if (!step)
1487 return NULL;
1488 } else {
1489 ch = CHILD(ch, 1);
1490 if (TYPE(ch) == test) {
1491 step = ast_for_expr(c, ch);
1492 if (!step)
1493 return NULL;
1494 }
1495 }
1496 }
1497
1498 return Slice(lower, upper, step, c->c_arena);
1499 }
1500
1501 static expr_ty
1502 ast_for_binop(struct compiling *c, const node *n)
1503 {
1504 /* Must account for a sequence of expressions.
1505 How should A op B op C by represented?
1506 BinOp(BinOp(A, op, B), op, C).
1507 */
1508
1509 int i, nops;
1510 expr_ty expr1, expr2, result;
1511 operator_ty newoperator;
1512
1513 expr1 = ast_for_expr(c, CHILD(n, 0));
1514 if (!expr1)
1515 return NULL;
1516
1517 expr2 = ast_for_expr(c, CHILD(n, 2));
1518 if (!expr2)
1519 return NULL;
1520
1521 newoperator = get_operator(CHILD(n, 1));
1522 if (!newoperator)
1523 return NULL;
1524
1525 result = BinOp(expr1, newoperator, expr2, LINENO(n), n->n_col_offset,
1526 c->c_arena);
1527 if (!result)
1528 return NULL;
1529
1530 nops = (NCH(n) - 1) / 2;
1531 for (i = 1; i < nops; i++) {
1532 expr_ty tmp_result, tmp;
1533 const node* next_oper = CHILD(n, i * 2 + 1);
1534
1535 newoperator = get_operator(next_oper);
1536 if (!newoperator)
1537 return NULL;
1538
1539 tmp = ast_for_expr(c, CHILD(n, i * 2 + 2));
1540 if (!tmp)
1541 return NULL;
1542
1543 tmp_result = BinOp(result, newoperator, tmp,
1544 LINENO(next_oper), next_oper->n_col_offset,
1545 c->c_arena);
1546 if (!tmp_result)
1547 return NULL;
1548 result = tmp_result;
1549 }
1550 return result;
1551 }
1552
1553 static expr_ty
1554 ast_for_trailer(struct compiling *c, const node *n, expr_ty left_expr)
1555 {
1556 /* trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME
1557 subscriptlist: subscript (',' subscript)* [',']
1558 subscript: '.' '.' '.' | test | [test] ':' [test] [sliceop]
1559 */
1560 REQ(n, trailer);
1561 if (TYPE(CHILD(n, 0)) == LPAR) {
1562 if (NCH(n) == 2)
1563 return Call(left_expr, NULL, NULL, NULL, NULL, LINENO(n),
1564 n->n_col_offset, c->c_arena);
1565 else
1566 return ast_for_call(c, CHILD(n, 1), left_expr);
1567 }
1568 else if (TYPE(CHILD(n, 0)) == DOT ) {
1569 PyObject *attr_id = NEW_IDENTIFIER(CHILD(n, 1));
1570 if (!attr_id)
1571 return NULL;
1572 return Attribute(left_expr, attr_id, Load,
1573 LINENO(n), n->n_col_offset, c->c_arena);
1574 }
1575 else {
1576 REQ(CHILD(n, 0), LSQB);
1577 REQ(CHILD(n, 2), RSQB);
1578 n = CHILD(n, 1);
1579 if (NCH(n) == 1) {
1580 slice_ty slc = ast_for_slice(c, CHILD(n, 0));
1581 if (!slc)
1582 return NULL;
1583 return Subscript(left_expr, slc, Load, LINENO(n), n->n_col_offset,
1584 c->c_arena);
1585 }
1586 else {
1587 /* The grammar is ambiguous here. The ambiguity is resolved
1588 by treating the sequence as a tuple literal if there are
1589 no slice features.
1590 */
1591 int j;
1592 slice_ty slc;
1593 expr_ty e;
1594 bool simple = true;
1595 asdl_seq *slices, *elts;
1596 slices = asdl_seq_new((NCH(n) + 1) / 2, c->c_arena);
1597 if (!slices)
1598 return NULL;
1599 for (j = 0; j < NCH(n); j += 2) {
1600 slc = ast_for_slice(c, CHILD(n, j));
1601 if (!slc)
1602 return NULL;
1603 if (slc->kind != Index_kind)
1604 simple = false;
1605 asdl_seq_SET(slices, j / 2, slc);
1606 }
1607 if (!simple) {
1608 return Subscript(left_expr, ExtSlice(slices, c->c_arena),
1609 Load, LINENO(n), n->n_col_offset, c->c_arena);
1610 }
1611 /* extract Index values and put them in a Tuple */
1612 elts = asdl_seq_new(asdl_seq_LEN(slices), c->c_arena);
1613 if (!elts)
1614 return NULL;
1615 for (j = 0; j < asdl_seq_LEN(slices); ++j) {
1616 slc = (slice_ty)asdl_seq_GET(slices, j);
1617 assert(slc->kind == Index_kind && slc->v.Index.value);
1618 asdl_seq_SET(elts, j, slc->v.Index.value);
1619 }
1620 e = Tuple(elts, Load, LINENO(n), n->n_col_offset, c->c_arena);
1621 if (!e)
1622 return NULL;
1623 return Subscript(left_expr, Index(e, c->c_arena),
1624 Load, LINENO(n), n->n_col_offset, c->c_arena);
1625 }
1626 }
1627 }
1628
1629 static expr_ty
1630 ast_for_factor(struct compiling *c, const node *n)
1631 {
1632 node *pfactor, *ppower, *patom, *pnum;
1633 expr_ty expression;
1634
1635 /* If the unary - operator is applied to a constant, don't generate
1636 a UNARY_NEGATIVE opcode. Just store the approriate value as a
1637 constant. The peephole optimizer already does something like
1638 this but it doesn't handle the case where the constant is
1639 (sys.maxint - 1). In that case, we want a PyIntObject, not a
1640 PyLongObject.
1641 */
1642 if (TYPE(CHILD(n, 0)) == MINUS &&
1643 NCH(n) == 2 &&
1644 TYPE((pfactor = CHILD(n, 1))) == factor &&
1645 NCH(pfactor) == 1 &&
1646 TYPE((ppower = CHILD(pfactor, 0))) == power &&
1647 NCH(ppower) == 1 &&
1648 TYPE((patom = CHILD(ppower, 0))) == atom &&
1649 TYPE((pnum = CHILD(patom, 0))) == NUMBER) {
1650 char *s = PyObject_MALLOC(strlen(STR(pnum)) + 2);
1651 if (s == NULL)
1652 return NULL;
1653 s[0] = '-';
1654 strcpy(s + 1, STR(pnum));
1655 PyObject_FREE(STR(pnum));
1656 STR(pnum) = s;
1657 return ast_for_atom(c, patom);
1658 }
1659
1660 expression = ast_for_expr(c, CHILD(n, 1));
1661 if (!expression)
1662 return NULL;
1663
1664 switch (TYPE(CHILD(n, 0))) {
1665 case PLUS:
1666 return UnaryOp(UAdd, expression, LINENO(n), n->n_col_offset,
1667 c->c_arena);
1668 case MINUS:
1669 return UnaryOp(USub, expression, LINENO(n), n->n_col_offset,
1670 c->c_arena);
1671 case TILDE:
1672 return UnaryOp(Invert, expression, LINENO(n),
1673 n->n_col_offset, c->c_arena);
1674 }
1675 PyErr_Format(PyExc_SystemError, "unhandled factor: %d",
1676 TYPE(CHILD(n, 0)));
1677 return NULL;
1678 }
1679
1680 static expr_ty
1681 ast_for_power(struct compiling *c, const node *n)
1682 {
1683 /* power: atom trailer* ('**' factor)*
1684 */
1685 int i;
1686 expr_ty e, tmp;
1687 REQ(n, power);
1688 e = ast_for_atom(c, CHILD(n, 0));
1689 if (!e)
1690 return NULL;
1691 if (NCH(n) == 1)
1692 return e;
1693 for (i = 1; i < NCH(n); i++) {
1694 node *ch = CHILD(n, i);
1695 if (TYPE(ch) != trailer)
1696 break;
1697 tmp = ast_for_trailer(c, ch, e);
1698 if (!tmp)
1699 return NULL;
1700 tmp->lineno = e->lineno;
1701 tmp->col_offset = e->col_offset;
1702 e = tmp;
1703 }
1704 if (TYPE(CHILD(n, NCH(n) - 1)) == factor) {
1705 expr_ty f = ast_for_expr(c, CHILD(n, NCH(n) - 1));
1706 if (!f)
1707 return NULL;
1708 tmp = BinOp(e, Pow, f, LINENO(n), n->n_col_offset, c->c_arena);
1709 if (!tmp)
1710 return NULL;
1711 e = tmp;
1712 }
1713 return e;
1714 }
1715
1716 /* Do not name a variable 'expr'! Will cause a compile error.
1717 */
1718
1719 static expr_ty
1720 ast_for_expr(struct compiling *c, const node *n)
1721 {
1722 /* handle the full range of simple expressions
1723 test: or_test ['if' or_test 'else' test] | lambdef
1724 or_test: and_test ('or' and_test)*
1725 and_test: not_test ('and' not_test)*
1726 not_test: 'not' not_test | comparison
1727 comparison: expr (comp_op expr)*
1728 expr: xor_expr ('|' xor_expr)*
1729 xor_expr: and_expr ('^' and_expr)*
1730 and_expr: shift_expr ('&' shift_expr)*
1731 shift_expr: arith_expr (('<<'|'>>') arith_expr)*
1732 arith_expr: term (('+'|'-') term)*
1733 term: factor (('*'|'/'|'%'|'//') factor)*
1734 factor: ('+'|'-'|'~') factor | power
1735 power: atom trailer* ('**' factor)*
1736
1737 As well as modified versions that exist for backward compatibility,
1738 to explicitly allow:
1739 [ x for x in lambda: 0, lambda: 1 ]
1740 (which would be ambiguous without these extra rules)
1741
1742 old_test: or_test | old_lambdef
1743 old_lambdef: 'lambda' [vararglist] ':' old_test
1744
1745 */
1746
1747 asdl_seq *seq;
1748 int i;
1749
1750 loop:
1751 switch (TYPE(n)) {
1752 case test:
1753 case old_test:
1754 if (TYPE(CHILD(n, 0)) == lambdef ||
1755 TYPE(CHILD(n, 0)) == old_lambdef)
1756 return ast_for_lambdef(c, CHILD(n, 0));
1757 else if (NCH(n) > 1)
1758 return ast_for_ifexpr(c, n);
1759 /* Fallthrough */
1760 case or_test:
1761 case and_test:
1762 if (NCH(n) == 1) {
1763 n = CHILD(n, 0);
1764 goto loop;
1765 }
1766 seq = asdl_seq_new((NCH(n) + 1) / 2, c->c_arena);
1767 if (!seq)
1768 return NULL;
1769 for (i = 0; i < NCH(n); i += 2) {
1770 expr_ty e = ast_for_expr(c, CHILD(n, i));
1771 if (!e)
1772 return NULL;
1773 asdl_seq_SET(seq, i / 2, e);
1774 }
1775 if (!strcmp(STR(CHILD(n, 1)), "and"))
1776 return BoolOp(And, seq, LINENO(n), n->n_col_offset,
1777 c->c_arena);
1778 assert(!strcmp(STR(CHILD(n, 1)), "or"));
1779 return BoolOp(Or, seq, LINENO(n), n->n_col_offset, c->c_arena);
1780 case not_test:
1781 if (NCH(n) == 1) {
1782 n = CHILD(n, 0);
1783 goto loop;
1784 }
1785 else {
1786 expr_ty expression = ast_for_expr(c, CHILD(n, 1));
1787 if (!expression)
1788 return NULL;
1789
1790 return UnaryOp(Not, expression, LINENO(n), n->n_col_offset,
1791 c->c_arena);
1792 }
1793 case comparison:
1794 if (NCH(n) == 1) {
1795 n = CHILD(n, 0);
1796 goto loop;
1797 }
1798 else {
1799 expr_ty expression;
1800 asdl_int_seq *ops;
1801 asdl_seq *cmps;
1802 ops = asdl_int_seq_new(NCH(n) / 2, c->c_arena);
1803 if (!ops)
1804 return NULL;
1805 cmps = asdl_seq_new(NCH(n) / 2, c->c_arena);
1806 if (!cmps) {
1807 return NULL;
1808 }
1809 for (i = 1; i < NCH(n); i += 2) {
1810 cmpop_ty newoperator;
1811
1812 newoperator = ast_for_comp_op(c, CHILD(n, i));
1813 if (!newoperator) {
1814 return NULL;
1815 }
1816
1817 expression = ast_for_expr(c, CHILD(n, i + 1));
1818 if (!expression) {
1819 return NULL;
1820 }
1821
1822 asdl_seq_SET(ops, i / 2, newoperator);
1823 asdl_seq_SET(cmps, i / 2, expression);
1824 }
1825 expression = ast_for_expr(c, CHILD(n, 0));
1826 if (!expression) {
1827 return NULL;
1828 }
1829
1830 return Compare(expression, ops, cmps, LINENO(n),
1831 n->n_col_offset, c->c_arena);
1832 }
1833 break;
1834
1835 /* The next five cases all handle BinOps. The main body of code
1836 is the same in each case, but the switch turned inside out to
1837 reuse the code for each type of operator.
1838 */
1839 case expr:
1840 case xor_expr:
1841 case and_expr:
1842 case shift_expr:
1843 case arith_expr:
1844 case term:
1845 if (NCH(n) == 1) {
1846 n = CHILD(n, 0);
1847 goto loop;
1848 }
1849 return ast_for_binop(c, n);
1850 case yield_expr: {
1851 expr_ty exp = NULL;
1852 if (NCH(n) == 2) {
1853 exp = ast_for_testlist(c, CHILD(n, 1));
1854 if (!exp)
1855 return NULL;
1856 }
1857 return Yield(exp, LINENO(n), n->n_col_offset, c->c_arena);
1858 }
1859 case factor:
1860 if (NCH(n) == 1) {
1861 n = CHILD(n, 0);
1862 goto loop;
1863 }
1864 return ast_for_factor(c, n);
1865 case power:
1866 return ast_for_power(c, n);
1867 default:
1868 PyErr_Format(PyExc_SystemError, "unhandled expr: %d", TYPE(n));
1869 return NULL;
1870 }
1871 /* should never get here unless if error is set */
1872 return NULL;
1873 }
1874
1875 static expr_ty
1876 ast_for_call(struct compiling *c, const node *n, expr_ty func)
1877 {
1878 /*
1879 arglist: (argument ',')* (argument [',']| '*' test [',' '**' test]
1880 | '**' test)
1881 argument: [test '='] test [gen_for] # Really [keyword '='] test
1882 */
1883
1884 int i, nargs, nkeywords, ngens;
1885 asdl_seq *args;
1886 asdl_seq *keywords;
1887 expr_ty vararg = NULL, kwarg = NULL;
1888
1889 REQ(n, arglist);
1890
1891 nargs = 0;
1892 nkeywords = 0;
1893 ngens = 0;
1894 for (i = 0; i < NCH(n); i++) {
1895 node *ch = CHILD(n, i);
1896 if (TYPE(ch) == argument) {
1897 if (NCH(ch) == 1)
1898 nargs++;
1899 else if (TYPE(CHILD(ch, 1)) == gen_for)
1900 ngens++;
1901 else
1902 nkeywords++;
1903 }
1904 }
1905 if (ngens > 1 || (ngens && (nargs || nkeywords))) {
1906 ast_error(n, "Generator expression must be parenthesized "
1907 "if not sole argument");
1908 return NULL;
1909 }
1910
1911 if (nargs + nkeywords + ngens > 255) {
1912 ast_error(n, "more than 255 arguments");
1913 return NULL;
1914 }
1915
1916 args = asdl_seq_new(nargs + ngens, c->c_arena);
1917 if (!args)
1918 return NULL;
1919 keywords = asdl_seq_new(nkeywords, c->c_arena);
1920 if (!keywords)
1921 return NULL;
1922 nargs = 0;
1923 nkeywords = 0;
1924 for (i = 0; i < NCH(n); i++) {
1925 node *ch = CHILD(n, i);
1926 if (TYPE(ch) == argument) {
1927 expr_ty e;
1928 if (NCH(ch) == 1) {
1929 if (nkeywords) {
1930 ast_error(CHILD(ch, 0),
1931 "non-keyword arg after keyword arg");
1932 return NULL;
1933 }
1934 if (vararg) {
1935 ast_error(CHILD(ch, 0),
1936 "only named arguments may follow *expression");
1937 return NULL;
1938 }
1939 e = ast_for_expr(c, CHILD(ch, 0));
1940 if (!e)
1941 return NULL;
1942 asdl_seq_SET(args, nargs++, e);
1943 }
1944 else if (TYPE(CHILD(ch, 1)) == gen_for) {
1945 e = ast_for_genexp(c, ch);
1946 if (!e)
1947 return NULL;
1948 asdl_seq_SET(args, nargs++, e);
1949 }
1950 else {
1951 keyword_ty kw;
1952 identifier key;
1953 int k;
1954 char *tmp;
1955
1956 /* CHILD(ch, 0) is test, but must be an identifier? */
1957 e = ast_for_expr(c, CHILD(ch, 0));
1958 if (!e)
1959 return NULL;
1960 /* f(lambda x: x[0] = 3) ends up getting parsed with
1961 * LHS test = lambda x: x[0], and RHS test = 3.
1962 * SF bug 132313 points out that complaining about a keyword
1963 * then is very confusing.
1964 */
1965 if (e->kind == Lambda_kind) {
1966 ast_error(CHILD(ch, 0),
1967 "lambda cannot contain assignment");
1968 return NULL;
1969 } else if (e->kind != Name_kind) {
1970 ast_error(CHILD(ch, 0), "keyword can't be an expression");
1971 return NULL;
1972 }
1973 key = e->v.Name.id;
1974 if (!forbidden_check(c, CHILD(ch, 0), PyBytes_AS_STRING(key)))
1975 return NULL;
1976 for (k = 0; k < nkeywords; k++) {
1977 tmp = PyString_AS_STRING(
1978 ((keyword_ty)asdl_seq_GET(keywords, k))->arg);
1979 if (!strcmp(tmp, PyString_AS_STRING(key))) {
1980 ast_error(CHILD(ch, 0), "keyword argument repeated");
1981 return NULL;
1982 }
1983 }
1984 e = ast_for_expr(c, CHILD(ch, 2));
1985 if (!e)
1986 return NULL;
1987 kw = keyword(key, e, c->c_arena);
1988 if (!kw)
1989 return NULL;
1990 asdl_seq_SET(keywords, nkeywords++, kw);
1991 }
1992 }
1993 else if (TYPE(ch) == STAR) {
1994 vararg = ast_for_expr(c, CHILD(n, i+1));
1995 if (!vararg)
1996 return NULL;
1997 i++;
1998 }
1999 else if (TYPE(ch) == DOUBLESTAR) {
2000 kwarg = ast_for_expr(c, CHILD(n, i+1));
2001 if (!kwarg)
2002 return NULL;
2003 i++;
2004 }
2005 }
2006
2007 return Call(func, args, keywords, vararg, kwarg, func->lineno,
2008 func->col_offset, c->c_arena);
2009 }
2010
2011 static expr_ty
2012 ast_for_testlist(struct compiling *c, const node* n)
2013 {
2014 /* testlist_gexp: test (',' test)* [','] */
2015 /* testlist: test (',' test)* [','] */
2016 /* testlist_safe: test (',' test)+ [','] */
2017 /* testlist1: test (',' test)* */
2018 assert(NCH(n) > 0);
2019 if (TYPE(n) == testlist_gexp) {
2020 if (NCH(n) > 1)
2021 assert(TYPE(CHILD(n, 1)) != gen_for);
2022 }
2023 else {
2024 assert(TYPE(n) == testlist ||
2025 TYPE(n) == testlist_safe ||
2026 TYPE(n) == testlist1);
2027 }
2028 if (NCH(n) == 1)
2029 return ast_for_expr(c, CHILD(n, 0));
2030 else {
2031 asdl_seq *tmp = seq_for_testlist(c, n);
2032 if (!tmp)
2033 return NULL;
2034 return Tuple(tmp, Load, LINENO(n), n->n_col_offset, c->c_arena);
2035 }
2036 }
2037
2038 static expr_ty
2039 ast_for_testlist_gexp(struct compiling *c, const node* n)
2040 {
2041 /* testlist_gexp: test ( gen_for | (',' test)* [','] ) */
2042 /* argument: test [ gen_for ] */
2043 assert(TYPE(n) == testlist_gexp || TYPE(n) == argument);
2044 if (NCH(n) > 1 && TYPE(CHILD(n, 1)) == gen_for)
2045 return ast_for_genexp(c, n);
2046 return ast_for_testlist(c, n);
2047 }
2048
2049 /* like ast_for_testlist() but returns a sequence */
2050 static asdl_seq*
2051 ast_for_class_bases(struct compiling *c, const node* n)
2052 {
2053 /* testlist: test (',' test)* [','] */
2054 assert(NCH(n) > 0);
2055 REQ(n, testlist);
2056 if (NCH(n) == 1) {
2057 expr_ty base;
2058 asdl_seq *bases = asdl_seq_new(1, c->c_arena);
2059 if (!bases)
2060 return NULL;
2061 base = ast_for_expr(c, CHILD(n, 0));
2062 if (!base)
2063 return NULL;
2064 asdl_seq_SET(bases, 0, base);
2065 return bases;
2066 }
2067
2068 return seq_for_testlist(c, n);
2069 }
2070
2071 static stmt_ty
2072 ast_for_expr_stmt(struct compiling *c, const node *n)
2073 {
2074 REQ(n, expr_stmt);
2075 /* expr_stmt: testlist (augassign (yield_expr|testlist)
2076 | ('=' (yield_expr|testlist))*)
2077 testlist: test (',' test)* [',']
2078 augassign: '+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '|=' | '^='
2079 | '<<=' | '>>=' | '**=' | '//='
2080 test: ... here starts the operator precendence dance
2081 */
2082
2083 if (NCH(n) == 1) {
2084 expr_ty e = ast_for_testlist(c, CHILD(n, 0));
2085 if (!e)
2086 return NULL;
2087
2088 return Expr(e, LINENO(n), n->n_col_offset, c->c_arena);
2089 }
2090 else if (TYPE(CHILD(n, 1)) == augassign) {
2091 expr_ty expr1, expr2;
2092 operator_ty newoperator;
2093 node *ch = CHILD(n, 0);
2094
2095 expr1 = ast_for_testlist(c, ch);
2096 if (!expr1)
2097 return NULL;
2098 if(!set_context(c, expr1, Store, ch))
2099 return NULL;
2100
2101 ch = CHILD(n, 2);
2102 if (TYPE(ch) == testlist)
2103 expr2 = ast_for_testlist(c, ch);
2104 else
2105 expr2 = ast_for_expr(c, ch);
2106 if (!expr2)
2107 return NULL;
2108
2109 newoperator = ast_for_augassign(c, CHILD(n, 1));
2110 if (!newoperator)
2111 return NULL;
2112
2113 return AugAssign(expr1, newoperator, expr2, LINENO(n), n->n_col_offset,
2114 c->c_arena);
2115 }
2116 else {
2117 int i;
2118 asdl_seq *targets;
2119 node *value;
2120 expr_ty expression;
2121
2122 /* a normal assignment */
2123 REQ(CHILD(n, 1), EQUAL);
2124 targets = asdl_seq_new(NCH(n) / 2, c->c_arena);
2125 if (!targets)
2126 return NULL;
2127 for (i = 0; i < NCH(n) - 2; i += 2) {
2128 expr_ty e;
2129 node *ch = CHILD(n, i);
2130 if (TYPE(ch) == yield_expr) {
2131 ast_error(ch, "assignment to yield expression not possible");
2132 return NULL;
2133 }
2134 e = ast_for_testlist(c, ch);
2135
2136 /* set context to assign */
2137 if (!e)
2138 return NULL;
2139
2140 if (!set_context(c, e, Store, CHILD(n, i)))
2141 return NULL;
2142
2143 asdl_seq_SET(targets, i / 2, e);
2144 }
2145 value = CHILD(n, NCH(n) - 1);
2146 if (TYPE(value) == testlist)
2147 expression = ast_for_testlist(c, value);
2148 else
2149 expression = ast_for_expr(c, value);
2150 if (!expression)
2151 return NULL;
2152 return Assign(targets, expression, LINENO(n), n->n_col_offset,
2153 c->c_arena);
2154 }
2155 }
2156
2157 static stmt_ty
2158 ast_for_print_stmt(struct compiling *c, const node *n)
2159 {
2160 /* print_stmt: 'print' ( [ test (',' test)* [','] ]
2161 | '>>' test [ (',' test)+ [','] ] )
2162 */
2163 expr_ty dest = NULL, expression;
2164 asdl_seq *seq = NULL;
2165 bool nl;
2166 int i, j, values_count, start = 1;
2167
2168 REQ(n, print_stmt);
2169 if (NCH(n) >= 2 && TYPE(CHILD(n, 1)) == RIGHTSHIFT) {
2170 dest = ast_for_expr(c, CHILD(n, 2));
2171 if (!dest)
2172 return NULL;
2173 start = 4;
2174 }
2175 values_count = (NCH(n) + 1 - start) / 2;
2176 if (values_count) {
2177 seq = asdl_seq_new(values_count, c->c_arena);
2178 if (!seq)
2179 return NULL;
2180 for (i = start, j = 0; i < NCH(n); i += 2, ++j) {
2181 expression = ast_for_expr(c, CHILD(n, i));
2182 if (!expression)
2183 return NULL;
2184 asdl_seq_SET(seq, j, expression);
2185 }
2186 }
2187 nl = (TYPE(CHILD(n, NCH(n) - 1)) == COMMA) ? false : true;
2188 return Print(dest, seq, nl, LINENO(n), n->n_col_offset, c->c_arena);
2189 }
2190
2191 static asdl_seq *
2192 ast_for_exprlist(struct compiling *c, const node *n, expr_context_ty context)
2193 {
2194 asdl_seq *seq;
2195 int i;
2196 expr_ty e;
2197
2198 REQ(n, exprlist);
2199
2200 seq = asdl_seq_new((NCH(n) + 1) / 2, c->c_arena);
2201 if (!seq)
2202 return NULL;
2203 for (i = 0; i < NCH(n); i += 2) {
2204 e = ast_for_expr(c, CHILD(n, i));
2205 if (!e)
2206 return NULL;
2207 asdl_seq_SET(seq, i / 2, e);
2208 if (context && !set_context(c, e, context, CHILD(n, i)))
2209 return NULL;
2210 }
2211 return seq;
2212 }
2213
2214 static stmt_ty
2215 ast_for_del_stmt(struct compiling *c, const node *n)
2216 {
2217 asdl_seq *expr_list;
2218
2219 /* del_stmt: 'del' exprlist */
2220 REQ(n, del_stmt);
2221
2222 expr_list = ast_for_exprlist(c, CHILD(n, 1), Del);
2223 if (!expr_list)
2224 return NULL;
2225 return Delete(expr_list, LINENO(n), n->n_col_offset, c->c_arena);
2226 }
2227
2228 static stmt_ty
2229 ast_for_flow_stmt(struct compiling *c, const node *n)
2230 {
2231 /*
2232 flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt
2233 | yield_stmt
2234 break_stmt: 'break'
2235 continue_stmt: 'continue'
2236 return_stmt: 'return' [testlist]
2237 yield_stmt: yield_expr
2238 yield_expr: 'yield' testlist
2239 raise_stmt: 'raise' [test [',' test [',' test]]]
2240 */
2241 node *ch;
2242
2243 REQ(n, flow_stmt);
2244 ch = CHILD(n, 0);
2245 switch (TYPE(ch)) {
2246 case break_stmt:
2247 return Break(LINENO(n), n->n_col_offset, c->c_arena);
2248 case continue_stmt:
2249 return Continue(LINENO(n), n->n_col_offset, c->c_arena);
2250 case yield_stmt: { /* will reduce to yield_expr */
2251 expr_ty exp = ast_for_expr(c, CHILD(ch, 0));
2252 if (!exp)
2253 return NULL;
2254 return Expr(exp, LINENO(n), n->n_col_offset, c->c_arena);
2255 }
2256 case return_stmt:
2257 if (NCH(ch) == 1)
2258 return Return(NULL, LINENO(n), n->n_col_offset, c->c_arena);
2259 else {
2260 expr_ty expression = ast_for_testlist(c, CHILD(ch, 1));
2261 if (!expression)
2262 return NULL;
2263 return Return(expression, LINENO(n), n->n_col_offset,
2264 c->c_arena);
2265 }
2266 case raise_stmt:
2267 if (NCH(ch) == 1)
2268 return Raise(NULL, NULL, NULL, LINENO(n), n->n_col_offset,
2269 c->c_arena);
2270 else if (NCH(ch) == 2) {
2271 expr_ty expression = ast_for_expr(c, CHILD(ch, 1));
2272 if (!expression)
2273 return NULL;
2274 return Raise(expression, NULL, NULL, LINENO(n),
2275 n->n_col_offset, c->c_arena);
2276 }
2277 else if (NCH(ch) == 4) {
2278 expr_ty expr1, expr2;
2279
2280 expr1 = ast_for_expr(c, CHILD(ch, 1));
2281 if (!expr1)
2282 return NULL;
2283 expr2 = ast_for_expr(c, CHILD(ch, 3));
2284 if (!expr2)
2285 return NULL;
2286
2287 return Raise(expr1, expr2, NULL, LINENO(n), n->n_col_offset,
2288 c->c_arena);
2289 }
2290 else if (NCH(ch) == 6) {
2291 expr_ty expr1, expr2, expr3;
2292
2293 expr1 = ast_for_expr(c, CHILD(ch, 1));
2294 if (!expr1)
2295 return NULL;
2296 expr2 = ast_for_expr(c, CHILD(ch, 3));
2297 if (!expr2)
2298 return NULL;
2299 expr3 = ast_for_expr(c, CHILD(ch, 5));
2300 if (!expr3)
2301 return NULL;
2302
2303 return Raise(expr1, expr2, expr3, LINENO(n), n->n_col_offset,
2304 c->c_arena);
2305 }
2306 default:
2307 PyErr_Format(PyExc_SystemError,
2308 "unexpected flow_stmt: %d", TYPE(ch));
2309 return NULL;
2310 }
2311
2312 PyErr_SetString(PyExc_SystemError, "unhandled flow statement");
2313 return NULL;
2314 }
2315
2316 static alias_ty
2317 alias_for_import_name(struct compiling *c, const node *n, int store)
2318 {
2319 /*
2320 import_as_name: NAME ['as' NAME]
2321 dotted_as_name: dotted_name ['as' NAME]
2322 dotted_name: NAME ('.' NAME)*
2323 */
2324 PyObject *str, *name;
2325
2326 loop:
2327 switch (TYPE(n)) {
2328 case import_as_name: {
2329 node *name_node = CHILD(n, 0);
2330 str = NULL;
2331 if (NCH(n) == 3) {
2332 node *str_node = CHILD(n, 2);
2333 if (store && !forbidden_check(c, str_node, STR(str_node)))
2334 return NULL;
2335 str = NEW_IDENTIFIER(str_node);
2336 if (!str)
2337 return NULL;
2338 }
2339 else {
2340 if (!forbidden_check(c, name_node, STR(name_node)))
2341 return NULL;
2342 }
2343 name = NEW_IDENTIFIER(name_node);
2344 if (!name)
2345 return NULL;
2346 return alias(name, str, c->c_arena);
2347 }
2348 case dotted_as_name:
2349 if (NCH(n) == 1) {
2350 n = CHILD(n, 0);
2351 goto loop;
2352 }
2353 else {
2354 node *asname_node = CHILD(n, 2);
2355 alias_ty a = alias_for_import_name(c, CHILD(n, 0), 0);
2356 if (!a)
2357 return NULL;
2358 assert(!a->asname);
2359 if (!forbidden_check(c, asname_node, STR(asname_node)))
2360 return NULL;
2361 a->asname = NEW_IDENTIFIER(asname_node);
2362 if (!a->asname)
2363 return NULL;
2364 return a;
2365 }
2366 break;
2367 case dotted_name:
2368 if (NCH(n) == 1) {
2369 node *name_node = CHILD(n, 0);
2370 if (store && !forbidden_check(c, name_node, STR(name_node)))
2371 return NULL;
2372 name = NEW_IDENTIFIER(name_node);
2373 if (!name)
2374 return NULL;
2375 return alias(name, NULL, c->c_arena);
2376 }
2377 else {
2378 /* Create a string of the form "a.b.c" */
2379 int i;
2380 size_t len;
2381 char *s;
2382
2383 len = 0;
2384 for (i = 0; i < NCH(n); i += 2)
2385 /* length of string plus one for the dot */
2386 len += strlen(STR(CHILD(n, i))) + 1;
2387 len--; /* the last name doesn't have a dot */
2388 str = PyString_FromStringAndSize(NULL, len);
2389 if (!str)
2390 return NULL;
2391 s = PyString_AS_STRING(str);
2392 if (!s)
2393 return NULL;
2394 for (i = 0; i < NCH(n); i += 2) {
2395 char *sch = STR(CHILD(n, i));
2396 strcpy(s, STR(CHILD(n, i)));
2397 s += strlen(sch);
2398 *s++ = '.';
2399 }
2400 --s;
2401 *s = '\0';
2402 PyString_InternInPlace(&str);
2403 PyArena_AddPyObject(c->c_arena, str);
2404 return alias(str, NULL, c->c_arena);
2405 }
2406 break;
2407 case STAR:
2408 str = PyString_InternFromString("*");
2409 PyArena_AddPyObject(c->c_arena, str);
2410 return alias(str, NULL, c->c_arena);
2411 default:
2412 PyErr_Format(PyExc_SystemError,
2413 "unexpected import name: %d", TYPE(n));
2414 return NULL;
2415 }
2416
2417 PyErr_SetString(PyExc_SystemError, "unhandled import name condition");
2418 return NULL;
2419 }
2420
2421 static stmt_ty
2422 ast_for_import_stmt(struct compiling *c, const node *n)
2423 {
2424 /*
2425 import_stmt: import_name | import_from
2426 import_name: 'import' dotted_as_names
2427 import_from: 'from' ('.'* dotted_name | '.') 'import'
2428 ('*' | '(' import_as_names ')' | import_as_names)
2429 */
2430 int lineno;
2431 int col_offset;
2432 int i;
2433 asdl_seq *aliases;
2434
2435 REQ(n, import_stmt);
2436 lineno = LINENO(n);
2437 col_offset = n->n_col_offset;
2438 n = CHILD(n, 0);
2439 if (TYPE(n) == import_name) {
2440 n = CHILD(n, 1);
2441 REQ(n, dotted_as_names);
2442 aliases = asdl_seq_new((NCH(n) + 1) / 2, c->c_arena);
2443 if (!aliases)
2444 return NULL;
2445 for (i = 0; i < NCH(n); i += 2) {
2446 alias_ty import_alias = alias_for_import_name(c, CHILD(n, i), 1);
2447 if (!import_alias)
2448 return NULL;
2449 asdl_seq_SET(aliases, i / 2, import_alias);
2450 }
2451 return Import(aliases, lineno, col_offset, c->c_arena);
2452 }
2453 else if (TYPE(n) == import_from) {
2454 int n_children;
2455 int idx, ndots = 0;
2456 alias_ty mod = NULL;
2457 identifier modname = NULL;
2458
2459 /* Count the number of dots (for relative imports) and check for the
2460 optional module name */
2461 for (idx = 1; idx < NCH(n); idx++) {
2462 if (TYPE(CHILD(n, idx)) == dotted_name) {
2463 mod = alias_for_import_name(c, CHILD(n, idx), 0);
2464 if (!mod)
2465 return NULL;
2466 idx++;
2467 break;
2468 } else if (TYPE(CHILD(n, idx)) != DOT) {
2469 break;
2470 }
2471 ndots++;
2472 }
2473 idx++; /* skip over the 'import' keyword */
2474 switch (TYPE(CHILD(n, idx))) {
2475 case STAR:
2476 /* from ... import * */
2477 n = CHILD(n, idx);
2478 n_children = 1;
2479 break;
2480 case LPAR:
2481 /* from ... import (x, y, z) */
2482 n = CHILD(n, idx + 1);
2483 n_children = NCH(n);
2484 break;
2485 case import_as_names:
2486 /* from ... import x, y, z */
2487 n = CHILD(n, idx);
2488 n_children = NCH(n);
2489 if (n_children % 2 == 0) {
2490 ast_error(n, "trailing comma not allowed without"
2491 " surrounding parentheses");
2492 return NULL;
2493 }
2494 break;
2495 default:
2496 ast_error(n, "Unexpected node-type in from-import");
2497 return NULL;
2498 }
2499
2500 aliases = asdl_seq_new((n_children + 1) / 2, c->c_arena);
2501 if (!aliases)
2502 return NULL;
2503
2504 /* handle "from ... import *" special b/c there's no children */
2505 if (TYPE(n) == STAR) {
2506 alias_ty import_alias = alias_for_import_name(c, n, 1);
2507 if (!import_alias)
2508 return NULL;
2509 asdl_seq_SET(aliases, 0, import_alias);
2510 }
2511 else {
2512 for (i = 0; i < NCH(n); i += 2) {
2513 alias_ty import_alias = alias_for_import_name(c, CHILD(n, i), 1);
2514 if (!import_alias)
2515 return NULL;
2516 asdl_seq_SET(aliases, i / 2, import_alias);
2517 }
2518 }
2519 if (mod != NULL)
2520 modname = mod->name;
2521 return ImportFrom(modname, aliases, ndots, lineno, col_offset,
2522 c->c_arena);
2523 }
2524 PyErr_Format(PyExc_SystemError,
2525 "unknown import statement: starts with command '%s'",
2526 STR(CHILD(n, 0)));
2527 return NULL;
2528 }
2529
2530 static stmt_ty
2531 ast_for_global_stmt(struct compiling *c, const node *n)
2532 {
2533 /* global_stmt: 'global' NAME (',' NAME)* */
2534 identifier name;
2535 asdl_seq *s;
2536 int i;
2537
2538 REQ(n, global_stmt);
2539 s = asdl_seq_new(NCH(n) / 2, c->c_arena);
2540 if (!s)
2541 return NULL;
2542 for (i = 1; i < NCH(n); i += 2) {
2543 name = NEW_IDENTIFIER(CHILD(n, i));
2544 if (!name)
2545 return NULL;
2546 asdl_seq_SET(s, i / 2, name);
2547 }
2548 return Global(s, LINENO(n), n->n_col_offset, c->c_arena);
2549 }
2550
2551 static stmt_ty
2552 ast_for_exec_stmt(struct compiling *c, const node *n)
2553 {
2554 expr_ty expr1, globals = NULL, locals = NULL;
2555 int n_children = NCH(n);
2556 if (n_children != 2 && n_children != 4 && n_children != 6) {
2557 PyErr_Format(PyExc_SystemError,
2558 "poorly formed 'exec' statement: %d parts to statement",
2559 n_children);
2560 return NULL;
2561 }
2562
2563 /* exec_stmt: 'exec' expr ['in' test [',' test]] */
2564 REQ(n, exec_stmt);
2565 expr1 = ast_for_expr(c, CHILD(n, 1));
2566 if (!expr1)
2567 return NULL;
2568 if (n_children >= 4) {
2569 globals = ast_for_expr(c, CHILD(n, 3));
2570 if (!globals)
2571 return NULL;
2572 }
2573 if (n_children == 6) {
2574 locals = ast_for_expr(c, CHILD(n, 5));
2575 if (!locals)
2576 return NULL;
2577 }
2578
2579 return Exec(expr1, globals, locals, LINENO(n), n->n_col_offset,
2580 c->c_arena);
2581 }
2582
2583 static stmt_ty
2584 ast_for_assert_stmt(struct compiling *c, const node *n)
2585 {
2586 /* assert_stmt: 'assert' test [',' test] */
2587 REQ(n, assert_stmt);
2588 if (NCH(n) == 2) {
2589 expr_ty expression = ast_for_expr(c, CHILD(n, 1));
2590 if (!expression)
2591 return NULL;
2592 return Assert(expression, NULL, LINENO(n), n->n_col_offset,
2593 c->c_arena);
2594 }
2595 else if (NCH(n) == 4) {
2596 expr_ty expr1, expr2;
2597
2598 expr1 = ast_for_expr(c, CHILD(n, 1));
2599 if (!expr1)
2600 return NULL;
2601 expr2 = ast_for_expr(c, CHILD(n, 3));
2602 if (!expr2)
2603 return NULL;
2604
2605 return Assert(expr1, expr2, LINENO(n), n->n_col_offset, c->c_arena);
2606 }
2607 PyErr_Format(PyExc_SystemError,
2608 "improper number of parts to 'assert' statement: %d",
2609 NCH(n));
2610 return NULL;
2611 }
2612
2613 static asdl_seq *
2614 ast_for_suite(struct compiling *c, const node *n)
2615 {
2616 /* suite: simple_stmt | NEWLINE INDENT stmt+ DEDENT */
2617 asdl_seq *seq;
2618 stmt_ty s;
2619 int i, total, num, end, pos = 0;
2620 node *ch;
2621
2622 REQ(n, suite);
2623
2624 total = num_stmts(n);
2625 seq = asdl_seq_new(total, c->c_arena);
2626 if (!seq)
2627 return NULL;
2628 if (TYPE(CHILD(n, 0)) == simple_stmt) {
2629 n = CHILD(n, 0);
2630 /* simple_stmt always ends with a NEWLINE,
2631 and may have a trailing SEMI
2632 */
2633 end = NCH(n) - 1;
2634 if (TYPE(CHILD(n, end - 1)) == SEMI)
2635 end--;
2636 /* loop by 2 to skip semi-colons */
2637 for (i = 0; i < end; i += 2) {
2638 ch = CHILD(n, i);
2639 s = ast_for_stmt(c, ch);
2640 if (!s)
2641 return NULL;
2642 asdl_seq_SET(seq, pos++, s);
2643 }
2644 }
2645 else {
2646 for (i = 2; i < (NCH(n) - 1); i++) {
2647 ch = CHILD(n, i);
2648 REQ(ch, stmt);
2649 num = num_stmts(ch);
2650 if (num == 1) {
2651 /* small_stmt or compound_stmt with only one child */
2652 s = ast_for_stmt(c, ch);
2653 if (!s)
2654 return NULL;
2655 asdl_seq_SET(seq, pos++, s);
2656 }
2657 else {
2658 int j;
2659 ch = CHILD(ch, 0);
2660 REQ(ch, simple_stmt);
2661 for (j = 0; j < NCH(ch); j += 2) {
2662 /* statement terminates with a semi-colon ';' */
2663 if (NCH(CHILD(ch, j)) == 0) {
2664 assert((j + 1) == NCH(ch));
2665 break;
2666 }
2667 s = ast_for_stmt(c, CHILD(ch, j));
2668 if (!s)
2669 return NULL;
2670 asdl_seq_SET(seq, pos++, s);
2671 }
2672 }
2673 }
2674 }
2675 assert(pos == seq->size);
2676 return seq;
2677 }
2678
2679 static stmt_ty
2680 ast_for_if_stmt(struct compiling *c, const node *n)
2681 {
2682 /* if_stmt: 'if' test ':' suite ('elif' test ':' suite)*
2683 ['else' ':' suite]
2684 */
2685 char *s;
2686
2687 REQ(n, if_stmt);
2688
2689 if (NCH(n) == 4) {
2690 expr_ty expression;
2691 asdl_seq *suite_seq;
2692
2693 expression = ast_for_expr(c, CHILD(n, 1));
2694 if (!expression)
2695 return NULL;
2696 suite_seq = ast_for_suite(c, CHILD(n, 3));
2697 if (!suite_seq)
2698 return NULL;
2699
2700 return If(expression, suite_seq, NULL, LINENO(n), n->n_col_offset,
2701 c->c_arena);
2702 }
2703
2704 s = STR(CHILD(n, 4));
2705 /* s[2], the third character in the string, will be
2706 's' for el_s_e, or
2707 'i' for el_i_f
2708 */
2709 if (s[2] == 's') {
2710 expr_ty expression;
2711 asdl_seq *seq1, *seq2;
2712
2713 expression = ast_for_expr(c, CHILD(n, 1));
2714 if (!expression)
2715 return NULL;
2716 seq1 = ast_for_suite(c, CHILD(n, 3));
2717 if (!seq1)
2718 return NULL;
2719 seq2 = ast_for_suite(c, CHILD(n, 6));
2720 if (!seq2)
2721 return NULL;
2722
2723 return If(expression, seq1, seq2, LINENO(n), n->n_col_offset,
2724 c->c_arena);
2725 }
2726 else if (s[2] == 'i') {
2727 int i, n_elif, has_else = 0;
2728 expr_ty expression;
2729 asdl_seq *suite_seq;
2730 asdl_seq *orelse = NULL;
2731 n_elif = NCH(n) - 4;
2732 /* must reference the child n_elif+1 since 'else' token is third,
2733 not fourth, child from the end. */
2734 if (TYPE(CHILD(n, (n_elif + 1))) == NAME
2735 && STR(CHILD(n, (n_elif + 1)))[2] == 's') {
2736 has_else = 1;
2737 n_elif -= 3;
2738 }
2739 n_elif /= 4;
2740
2741 if (has_else) {
2742 asdl_seq *suite_seq2;
2743
2744 orelse = asdl_seq_new(1, c->c_arena);
2745 if (!orelse)
2746 return NULL;
2747 expression = ast_for_expr(c, CHILD(n, NCH(n) - 6));
2748 if (!expression)
2749 return NULL;
2750 suite_seq = ast_for_suite(c, CHILD(n, NCH(n) - 4));
2751 if (!suite_seq)
2752 return NULL;
2753 suite_seq2 = ast_for_suite(c, CHILD(n, NCH(n) - 1));
2754 if (!suite_seq2)
2755 return NULL;
2756
2757 asdl_seq_SET(orelse, 0,
2758 If(expression, suite_seq, suite_seq2,
2759 LINENO(CHILD(n, NCH(n) - 6)),
2760 CHILD(n, NCH(n) - 6)->n_col_offset,
2761 c->c_arena));
2762 /* the just-created orelse handled the last elif */
2763 n_elif--;
2764 }
2765
2766 for (i = 0; i < n_elif; i++) {
2767 int off = 5 + (n_elif - i - 1) * 4;
2768 asdl_seq *newobj = asdl_seq_new(1, c->c_arena);
2769 if (!newobj)
2770 return NULL;
2771 expression = ast_for_expr(c, CHILD(n, off));
2772 if (!expression)
2773 return NULL;
2774 suite_seq = ast_for_suite(c, CHILD(n, off + 2));
2775 if (!suite_seq)
2776 return NULL;
2777
2778 asdl_seq_SET(newobj, 0,
2779 If(expression, suite_seq, orelse,
2780 LINENO(CHILD(n, off)),
2781 CHILD(n, off)->n_col_offset, c->c_arena));
2782 orelse = newobj;
2783 }
2784 expression = ast_for_expr(c, CHILD(n, 1));
2785 if (!expression)
2786 return NULL;
2787 suite_seq = ast_for_suite(c, CHILD(n, 3));
2788 if (!suite_seq)
2789 return NULL;
2790 return If(expression, suite_seq, orelse,
2791 LINENO(n), n->n_col_offset, c->c_arena);
2792 }
2793
2794 PyErr_Format(PyExc_SystemError,
2795 "unexpected token in 'if' statement: %s", s);
2796 return NULL;
2797 }
2798
2799 static stmt_ty
2800 ast_for_while_stmt(struct compiling *c, const node *n)
2801 {
2802 /* while_stmt: 'while' test ':' suite ['else' ':' suite] */
2803 REQ(n, while_stmt);
2804
2805 if (NCH(n) == 4) {
2806 expr_ty expression;
2807 asdl_seq *suite_seq;
2808
2809 expression = ast_for_expr(c, CHILD(n, 1));
2810 if (!expression)
2811 return NULL;
2812 suite_seq = ast_for_suite(c, CHILD(n, 3));
2813 if (!suite_seq)
2814 return NULL;
2815 return While(expression, suite_seq, NULL, LINENO(n), n->n_col_offset,
2816 c->c_arena);
2817 }
2818 else if (NCH(n) == 7) {
2819 expr_ty expression;
2820 asdl_seq *seq1, *seq2;
2821
2822 expression = ast_for_expr(c, CHILD(n, 1));
2823 if (!expression)
2824 return NULL;
2825 seq1 = ast_for_suite(c, CHILD(n, 3));
2826 if (!seq1)
2827 return NULL;
2828 seq2 = ast_for_suite(c, CHILD(n, 6));
2829 if (!seq2)
2830 return NULL;
2831
2832 return While(expression, seq1, seq2, LINENO(n), n->n_col_offset,
2833 c->c_arena);
2834 }
2835
2836 PyErr_Format(PyExc_SystemError,
2837 "wrong number of tokens for 'while' statement: %d",
2838 NCH(n));
2839 return NULL;
2840 }
2841
2842 static stmt_ty
2843 ast_for_for_stmt(struct compiling *c, const node *n)
2844 {
2845 asdl_seq *_target, *seq = NULL, *suite_seq;
2846 expr_ty expression;
2847 expr_ty target;
2848 const node *node_target;
2849 /* for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite] */
2850 REQ(n, for_stmt);
2851
2852 if (NCH(n) == 9) {
2853 seq = ast_for_suite(c, CHILD(n, 8));
2854 if (!seq)
2855 return NULL;
2856 }
2857
2858 node_target = CHILD(n, 1);
2859 _target = ast_for_exprlist(c, node_target, Store);
2860 if (!_target)
2861 return NULL;
2862 /* Check the # of children rather than the length of _target, since
2863 for x, in ... has 1 element in _target, but still requires a Tuple. */
2864 if (NCH(node_target) == 1)
2865 target = (expr_ty)asdl_seq_GET(_target, 0);
2866 else
2867 target = Tuple(_target, Store, LINENO(n), n->n_col_offset, c->c_arena);
2868
2869 expression = ast_for_testlist(c, CHILD(n, 3));
2870 if (!expression)
2871 return NULL;
2872 suite_seq = ast_for_suite(c, CHILD(n, 5));
2873 if (!suite_seq)
2874 return NULL;
2875
2876 return For(target, expression, suite_seq, seq, LINENO(n), n->n_col_offset,
2877 c->c_arena);
2878 }
2879
2880 static excepthandler_ty
2881 ast_for_except_clause(struct compiling *c, const node *exc, node *body)
2882 {
2883 /* except_clause: 'except' [test [(',' | 'as') test]] */
2884 REQ(exc, except_clause);
2885 REQ(body, suite);
2886
2887 if (NCH(exc) == 1) {
2888 asdl_seq *suite_seq = ast_for_suite(c, body);
2889 if (!suite_seq)
2890 return NULL;
2891
2892 return ExceptHandler(NULL, NULL, suite_seq, LINENO(exc),
2893 exc->n_col_offset, c->c_arena);
2894 }
2895 else if (NCH(exc) == 2) {
2896 expr_ty expression;
2897 asdl_seq *suite_seq;
2898
2899 expression = ast_for_expr(c, CHILD(exc, 1));
2900 if (!expression)
2901 return NULL;
2902 suite_seq = ast_for_suite(c, body);
2903 if (!suite_seq)
2904 return NULL;
2905
2906 return ExceptHandler(expression, NULL, suite_seq, LINENO(exc),
2907 exc->n_col_offset, c->c_arena);
2908 }
2909 else if (NCH(exc) == 4) {
2910 asdl_seq *suite_seq;
2911 expr_ty expression;
2912 expr_ty e = ast_for_expr(c, CHILD(exc, 3));
2913 if (!e)
2914 return NULL;
2915 if (!set_context(c, e, Store, CHILD(exc, 3)))
2916 return NULL;
2917 expression = ast_for_expr(c, CHILD(exc, 1));
2918 if (!expression)
2919 return NULL;
2920 suite_seq = ast_for_suite(c, body);
2921 if (!suite_seq)
2922 return NULL;
2923
2924 return ExceptHandler(expression, e, suite_seq, LINENO(exc),
2925 exc->n_col_offset, c->c_arena);
2926 }
2927
2928 PyErr_Format(PyExc_SystemError,
2929 "wrong number of children for 'except' clause: %d",
2930 NCH(exc));
2931 return NULL;
2932 }
2933
2934 static stmt_ty
2935 ast_for_try_stmt(struct compiling *c, const node *n)
2936 {
2937 const int nch = NCH(n);
2938 int n_except = (nch - 3)/3;
2939 asdl_seq *body, *orelse = NULL, *finally = NULL;
2940
2941 REQ(n, try_stmt);
2942
2943 body = ast_for_suite(c, CHILD(n, 2));
2944 if (body == NULL)
2945 return NULL;
2946
2947 if (TYPE(CHILD(n, nch - 3)) == NAME) {
2948 if (strcmp(STR(CHILD(n, nch - 3)), "finally") == 0) {
2949 if (nch >= 9 && TYPE(CHILD(n, nch - 6)) == NAME) {
2950 /* we can assume it's an "else",
2951 because nch >= 9 for try-else-finally and
2952 it would otherwise have a type of except_clause */
2953 orelse = ast_for_suite(c, CHILD(n, nch - 4));
2954 if (orelse == NULL)
2955 return NULL;
2956 n_except--;
2957 }
2958
2959 finally = ast_for_suite(c, CHILD(n, nch - 1));
2960 if (finally == NULL)
2961 return NULL;
2962 n_except--;
2963 }
2964 else {
2965 /* we can assume it's an "else",
2966 otherwise it would have a type of except_clause */
2967 orelse = ast_for_suite(c, CHILD(n, nch - 1));
2968 if (orelse == NULL)
2969 return NULL;
2970 n_except--;
2971 }
2972 }
2973 else if (TYPE(CHILD(n, nch - 3)) != except_clause) {
2974 ast_error(n, "malformed 'try' statement");
2975 return NULL;
2976 }
2977
2978 if (n_except > 0) {
2979 int i;
2980 stmt_ty except_st;
2981 /* process except statements to create a try ... except */
2982 asdl_seq *handlers = asdl_seq_new(n_except, c->c_arena);
2983 if (handlers == NULL)
2984 return NULL;
2985
2986 for (i = 0; i < n_except; i++) {
2987 excepthandler_ty e = ast_for_except_clause(c, CHILD(n, 3 + i * 3),
2988 CHILD(n, 5 + i * 3));
2989 if (!e)
2990 return NULL;
2991 asdl_seq_SET(handlers, i, e);
2992 }
2993
2994 except_st = TryExcept(body, handlers, orelse, LINENO(n),
2995 n->n_col_offset, c->c_arena);
2996 if (!finally)
2997 return except_st;
2998
2999 /* if a 'finally' is present too, we nest the TryExcept within a
3000 TryFinally to emulate try ... except ... finally */
3001 body = asdl_seq_new(1, c->c_arena);
3002 if (body == NULL)
3003 return NULL;
3004 asdl_seq_SET(body, 0, except_st);
3005 }
3006
3007 /* must be a try ... finally (except clauses are in body, if any exist) */
3008 assert(finally != NULL);
3009 return TryFinally(body, finally, LINENO(n), n->n_col_offset, c->c_arena);
3010 }
3011
3012 /* with_item: test ['as' expr] */
3013 static stmt_ty
3014 ast_for_with_item(struct compiling *c, const node *n, asdl_seq *content)
3015 {
3016 expr_ty context_expr, optional_vars = NULL;
3017
3018 REQ(n, with_item);
3019 context_expr = ast_for_expr(c, CHILD(n, 0));
3020 if (!context_expr)
3021 return NULL;
3022 if (NCH(n) == 3) {
3023 optional_vars = ast_for_expr(c, CHILD(n, 2));
3024
3025 if (!optional_vars) {
3026 return NULL;
3027 }
3028 if (!set_context(c, optional_vars, Store, n)) {
3029 return NULL;
3030 }
3031 }
3032
3033 return With(context_expr, optional_vars, content, LINENO(n),
3034 n->n_col_offset, c->c_arena);
3035 }
3036
3037 /* with_stmt: 'with' with_item (',' with_item)* ':' suite */
3038 static stmt_ty
3039 ast_for_with_stmt(struct compiling *c, const node *n)
3040 {
3041 int i;
3042 stmt_ty ret;
3043 asdl_seq *inner;
3044
3045 REQ(n, with_stmt);
3046
3047 /* process the with items inside-out */
3048 i = NCH(n) - 1;
3049 /* the suite of the innermost with item is the suite of the with stmt */
3050 inner = ast_for_suite(c, CHILD(n, i));
3051 if (!inner)
3052 return NULL;
3053
3054 for (;;) {
3055 i -= 2;
3056 ret = ast_for_with_item(c, CHILD(n, i), inner);
3057 if (!ret)
3058 return NULL;
3059 /* was this the last item? */
3060 if (i == 1)
3061 break;
3062 /* if not, wrap the result so far in a new sequence */
3063 inner = asdl_seq_new(1, c->c_arena);
3064 if (!inner)
3065 return NULL;
3066 asdl_seq_SET(inner, 0, ret);
3067 }
3068
3069 return ret;
3070 }
3071
3072 static stmt_ty
3073 ast_for_classdef(struct compiling *c, const node *n, asdl_seq *decorator_seq)
3074 {
3075 /* classdef: 'class' NAME ['(' testlist ')'] ':' suite */
3076 PyObject *classname;
3077 asdl_seq *bases, *s;
3078
3079 REQ(n, classdef);
3080
3081 if (!forbidden_check(c, n, STR(CHILD(n, 1))))
3082 return NULL;
3083
3084 if (NCH(n) == 4) {
3085 s = ast_for_suite(c, CHILD(n, 3));
3086 if (!s)
3087 return NULL;
3088 classname = NEW_IDENTIFIER(CHILD(n, 1));
3089 if (!classname)
3090 return NULL;
3091 return ClassDef(classname, NULL, s, decorator_seq, LINENO(n),
3092 n->n_col_offset, c->c_arena);
3093 }
3094 /* check for empty base list */
3095 if (TYPE(CHILD(n,3)) == RPAR) {
3096 s = ast_for_suite(c, CHILD(n,5));
3097 if (!s)
3098 return NULL;
3099 classname = NEW_IDENTIFIER(CHILD(n, 1));
3100 if (!classname)
3101 return NULL;
3102 return ClassDef(classname, NULL, s, decorator_seq, LINENO(n),
3103 n->n_col_offset, c->c_arena);
3104 }
3105
3106 /* else handle the base class list */
3107 bases = ast_for_class_bases(c, CHILD(n, 3));
3108 if (!bases)
3109 return NULL;
3110
3111 s = ast_for_suite(c, CHILD(n, 6));
3112 if (!s)
3113 return NULL;
3114 classname = NEW_IDENTIFIER(CHILD(n, 1));
3115 if (!classname)
3116 return NULL;
3117 return ClassDef(classname, bases, s, decorator_seq,
3118 LINENO(n), n->n_col_offset, c->c_arena);
3119 }
3120
3121 static stmt_ty
3122 ast_for_stmt(struct compiling *c, const node *n)
3123 {
3124 if (TYPE(n) == stmt) {
3125 assert(NCH(n) == 1);
3126 n = CHILD(n, 0);
3127 }
3128 if (TYPE(n) == simple_stmt) {
3129 assert(num_stmts(n) == 1);
3130 n = CHILD(n, 0);
3131 }
3132 if (TYPE(n) == small_stmt) {
3133 n = CHILD(n, 0);
3134 /* small_stmt: expr_stmt | print_stmt | del_stmt | pass_stmt
3135 | flow_stmt | import_stmt | global_stmt | exec_stmt
3136 | assert_stmt
3137 */
3138 switch (TYPE(n)) {
3139 case expr_stmt:
3140 return ast_for_expr_stmt(c, n);
3141 case print_stmt:
3142 return ast_for_print_stmt(c, n);
3143 case del_stmt:
3144 return ast_for_del_stmt(c, n);
3145 case pass_stmt:
3146 return Pass(LINENO(n), n->n_col_offset, c->c_arena);
3147 case flow_stmt:
3148 return ast_for_flow_stmt(c, n);
3149 case import_stmt:
3150 return ast_for_import_stmt(c, n);
3151 case global_stmt:
3152 return ast_for_global_stmt(c, n);
3153 case exec_stmt:
3154 return ast_for_exec_stmt(c, n);
3155 case assert_stmt:
3156 return ast_for_assert_stmt(c, n);
3157 default:
3158 PyErr_Format(PyExc_SystemError,
3159 "unhandled small_stmt: TYPE=%d NCH=%d\n",
3160 TYPE(n), NCH(n));
3161 return NULL;
3162 }
3163 }
3164 else {
3165 /* compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt
3166 | funcdef | classdef | decorated
3167 */
3168 node *ch = CHILD(n, 0);
3169 REQ(n, compound_stmt);
3170 switch (TYPE(ch)) {
3171 case if_stmt:
3172 return ast_for_if_stmt(c, ch);
3173 case while_stmt:
3174 return ast_for_while_stmt(c, ch);
3175 case for_stmt:
3176 return ast_for_for_stmt(c, ch);
3177 case try_stmt:
3178 return ast_for_try_stmt(c, ch);
3179 case with_stmt:
3180 return ast_for_with_stmt(c, ch);
3181 case funcdef:
3182 return ast_for_funcdef(c, ch, NULL);
3183 case classdef:
3184 return ast_for_classdef(c, ch, NULL);
3185 case decorated:
3186 return ast_for_decorated(c, ch);
3187 default:
3188 PyErr_Format(PyExc_SystemError,
3189 "unhandled small_stmt: TYPE=%d NCH=%d\n",
3190 TYPE(n), NCH(n));
3191 return NULL;
3192 }
3193 }
3194 }
3195
3196 static PyObject *
3197 parsenumber(struct compiling *c, const char *s)
3198 {
3199 const char *end;
3200 long x;
3201 double dx;
3202 #ifndef WITHOUT_COMPLEX
3203 Py_complex complex;
3204 int imflag;
3205 #endif
3206
3207 assert(s != NULL);
3208 errno = 0;
3209 end = s + strlen(s) - 1;
3210 #ifndef WITHOUT_COMPLEX
3211 imflag = *end == 'j' || *end == 'J';
3212 #endif
3213 if (*end == 'l' || *end == 'L')
3214 return PyLong_FromString((char *)s, (char **)0, 0);
3215 x = PyOS_strtol((char *)s, (char **)&end, 0);
3216 if (*end == '\0') {
3217 if (errno != 0)
3218 return PyLong_FromString((char *)s, (char **)0, 0);
3219 return PyInt_FromLong(x);
3220 }
3221 /* XXX Huge floats may silently fail */
3222 #ifndef WITHOUT_COMPLEX
3223 if (imflag) {
3224 complex.real = 0.;
3225 PyFPE_START_PROTECT("atof", return 0)
3226 complex.imag = PyOS_ascii_atof(s);
3227 PyFPE_END_PROTECT(complex)
3228 return PyComplex_FromCComplex(complex);
3229 }
3230 else
3231 #endif
3232 {
3233 PyFPE_START_PROTECT("atof", return 0)
3234 dx = PyOS_ascii_atof(s);
3235 PyFPE_END_PROTECT(dx)
3236 return PyFloat_FromDouble(dx);
3237 }
3238 }
3239
3240 static PyObject *
3241 decode_utf8(struct compiling *c, const char **sPtr, const char *end, char* encoding)
3242 {
3243 #ifndef Py_USING_UNICODE
3244 Py_FatalError("decode_utf8 should not be called in this build.");
3245 return NULL;
3246 #else
3247 PyObject *u, *v;
3248 char *s, *t;
3249 t = s = (char *)*sPtr;
3250 /* while (s < end && *s != '\\') s++; */ /* inefficient for u".." */
3251 while (s < end && (*s & 0x80)) s++;
3252 *sPtr = s;
3253 u = PyUnicode_DecodeUTF8(t, s - t, NULL);
3254 if (u == NULL)
3255 return NULL;
3256 v = PyUnicode_AsEncodedString(u, encoding, NULL);
3257 Py_DECREF(u);
3258 return v;
3259 #endif
3260 }
3261
3262 #ifdef Py_USING_UNICODE
3263 static PyObject *
3264 decode_unicode(struct compiling *c, const char *s, size_t len, int rawmode, const char *encoding)
3265 {
3266 PyObject *v, *u;
3267 char *buf;
3268 char *p;
3269 const char *end;
3270 if (encoding == NULL) {
3271 buf = (char *)s;
3272 u = NULL;
3273 } else if (strcmp(encoding, "iso-8859-1") == 0) {
3274 buf = (char *)s;
3275 u = NULL;
3276 } else {
3277 /* check for integer overflow */
3278 if (len > PY_SIZE_MAX / 4)
3279 return NULL;
3280 /* "\XX" may become "\u005c\uHHLL" (12 bytes) */
3281 u = PyString_FromStringAndSize((char *)NULL, len * 4);
3282 if (u == NULL)
3283 return NULL;
3284 p = buf = PyString_AsString(u);
3285 end = s + len;
3286 while (s < end) {
3287 if (*s == '\\') {
3288 *p++ = *s++;
3289 if (*s & 0x80) {
3290 strcpy(p, "u005c");
3291 p += 5;
3292 }
3293 }
3294 if (*s & 0x80) { /* XXX inefficient */
3295 PyObject *w;
3296 char *r;
3297 Py_ssize_t rn, i;
3298 w = decode_utf8(c, &s, end, "utf-16-be");
3299 if (w == NULL) {
3300 Py_DECREF(u);
3301 return NULL;
3302 }
3303 r = PyString_AsString(w);
3304 rn = PyString_Size(w);
3305 assert(rn % 2 == 0);
3306 for (i = 0; i < rn; i += 2) {
3307 sprintf(p, "\\u%02x%02x",
3308 r[i + 0] & 0xFF,
3309 r[i + 1] & 0xFF);
3310 p += 6;
3311 }
3312 Py_DECREF(w);
3313 } else {
3314 *p++ = *s++;
3315 }
3316 }
3317 len = p - buf;
3318 s = buf;
3319 }
3320 if (rawmode)
3321 v = PyUnicode_DecodeRawUnicodeEscape(s, len, NULL);
3322 else
3323 v = PyUnicode_DecodeUnicodeEscape(s, len, NULL);
3324 Py_XDECREF(u);
3325 return v;
3326 }
3327 #endif
3328
3329 /* s is a Python string literal, including the bracketing quote characters,
3330 * and r &/or u prefixes (if any), and embedded escape sequences (if any).
3331 * parsestr parses it, and returns the decoded Python string object.
3332 */
3333 static PyObject *
3334 parsestr(struct compiling *c, const char *s)
3335 {
3336 size_t len;
3337 int quote = Py_CHARMASK(*s);
3338 int rawmode = 0;
3339 int need_encoding;
3340 int unicode = c->c_future_unicode;
3341
3342 if (isalpha(quote) || quote == '_') {
3343 if (quote == 'u' || quote == 'U') {
3344 quote = *++s;
3345 unicode = 1;
3346 }
3347 if (quote == 'b' || quote == 'B') {
3348 quote = *++s;
3349 unicode = 0;
3350 }
3351 if (quote == 'r' || quote == 'R') {
3352 quote = *++s;
3353 rawmode = 1;
3354 }
3355 }
3356 if (quote != '\'' && quote != '\"') {
3357 PyErr_BadInternalCall();
3358 return NULL;
3359 }
3360 s++;
3361 len = strlen(s);
3362 if (len > INT_MAX) {
3363 PyErr_SetString(PyExc_OverflowError,
3364 "string to parse is too long");
3365 return NULL;
3366 }
3367 if (s[--len] != quote) {
3368 PyErr_BadInternalCall();
3369 return NULL;
3370 }
3371 if (len >= 4 && s[0] == quote && s[1] == quote) {
3372 s += 2;
3373 len -= 2;
3374 if (s[--len] != quote || s[--len] != quote) {
3375 PyErr_BadInternalCall();
3376 return NULL;
3377 }
3378 }
3379 #ifdef Py_USING_UNICODE
3380 if (unicode || Py_UnicodeFlag) {
3381 return decode_unicode(c, s, len, rawmode, c->c_encoding);
3382 }
3383 #endif
3384 need_encoding = (c->c_encoding != NULL &&
3385 strcmp(c->c_encoding, "utf-8") != 0 &&
3386 strcmp(c->c_encoding, "iso-8859-1") != 0);
3387 if (rawmode || strchr(s, '\\') == NULL) {
3388 if (need_encoding) {
3389 #ifndef Py_USING_UNICODE
3390 /* This should not happen - we never see any other
3391 encoding. */
3392 Py_FatalError(
3393 "cannot deal with encodings in this build.");
3394 #else
3395 PyObject *v, *u = PyUnicode_DecodeUTF8(s, len, NULL);
3396 if (u == NULL)
3397 return NULL;
3398 v = PyUnicode_AsEncodedString(u, c->c_encoding, NULL);
3399 Py_DECREF(u);
3400 return v;
3401 #endif
3402 } else {
3403 return PyString_FromStringAndSize(s, len);
3404 }
3405 }
3406
3407 return PyString_DecodeEscape(s, len, NULL, unicode,
3408 need_encoding ? c->c_encoding : NULL);
3409 }
3410
3411 /* Build a Python string object out of a STRING atom. This takes care of
3412 * compile-time literal catenation, calling parsestr() on each piece, and
3413 * pasting the intermediate results together.
3414 */
3415 static PyObject *
3416 parsestrplus(struct compiling *c, const node *n)
3417 {
3418 PyObject *v;
3419 int i;
3420 REQ(CHILD(n, 0), STRING);
3421 if ((v = parsestr(c, STR(CHILD(n, 0)))) != NULL) {
3422 /* String literal concatenation */
3423 for (i = 1; i < NCH(n); i++) {
3424 PyObject *s;
3425 s = parsestr(c, STR(CHILD(n, i)));
3426 if (s == NULL)
3427 goto onError;
3428 if (PyString_Check(v) && PyString_Check(s)) {
3429 PyString_ConcatAndDel(&v, s);
3430 if (v == NULL)
3431 goto onError;
3432 }
3433 #ifdef Py_USING_UNICODE
3434 else {
3435 PyObject *temp = PyUnicode_Concat(v, s);
3436 Py_DECREF(s);
3437 Py_DECREF(v);
3438 v = temp;
3439 if (v == NULL)
3440 goto onError;
3441 }
3442 #endif
3443 }
3444 }
3445 return v;
3446
3447 onError:
3448 Py_XDECREF(v);
3449 return NULL;
3450 }
python git mirror