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