History

add hg and python

cinap_lenrek committed 15 years ago

Commit 4bb9e221 parent 987265c3706 files · +1228772 −-233Browse files

Showing the changes to sys/src/cmd/python/Python/ast.c (1 of 3706 files). Show all

Unified · Split

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