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