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