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().
7 #include "Python-ast.h"
18 /* Data structure used internally */
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 */
26 static asdl_seq
*seq_for_testlist(struct compiling
*, const node
*);
27 static expr_ty
ast_for_expr(struct compiling
*, const node
*);
28 static stmt_ty
ast_for_stmt(struct compiling
*, const node
*);
29 static asdl_seq
*ast_for_suite(struct compiling
*, const node
*);
30 static asdl_seq
*ast_for_exprlist(struct compiling
*, const node
*,
32 static expr_ty
ast_for_testlist(struct compiling
*, const node
*);
33 static stmt_ty
ast_for_classdef(struct compiling
*, const node
*, asdl_seq
*);
34 static expr_ty
ast_for_testlist_gexp(struct compiling
*, const node
*);
36 /* Note different signature for ast_for_call */
37 static expr_ty
ast_for_call(struct compiling
*, const node
*, expr_ty
);
39 static PyObject
*parsenumber(struct compiling
*, const char *);
40 static PyObject
*parsestr(struct compiling
*, const char *);
41 static PyObject
*parsestrplus(struct compiling
*, const node
*n
);
44 #define LINENO(n) ((n)->n_lineno)
48 new_identifier(const char* n
, PyArena
*arena
) {
49 PyObject
* id
= PyString_InternFromString(n
);
51 PyArena_AddPyObject(arena
, id
);
55 #define NEW_IDENTIFIER(n) new_identifier(STR(n), c->c_arena)
57 /* This routine provides an invalid object for the syntax error.
58 The outermost routine must unpack this error and create the
59 proper object. We do this so that we don't have to pass
60 the filename to everything function.
62 XXX Maybe we should just pass the filename...
66 ast_error(const node
*n
, const char *errstr
)
68 PyObject
*u
= Py_BuildValue("zi", errstr
, LINENO(n
));
71 PyErr_SetObject(PyExc_SyntaxError
, u
);
77 ast_error_finish(const char *filename
)
79 PyObject
*type
, *value
, *tback
, *errstr
, *loc
, *tmp
;
82 assert(PyErr_Occurred());
83 if (!PyErr_ExceptionMatches(PyExc_SyntaxError
))
86 PyErr_Fetch(&type
, &value
, &tback
);
87 errstr
= PyTuple_GetItem(value
, 0);
91 lineno
= PyInt_AsLong(PyTuple_GetItem(value
, 1));
98 loc
= PyErr_ProgramText(filename
, lineno
);
103 tmp
= Py_BuildValue("(zlOO)", filename
, lineno
, Py_None
, loc
);
109 value
= PyTuple_Pack(2, errstr
, tmp
);
114 PyErr_Restore(type
, value
, tback
);
118 ast_warn(struct compiling
*c
, const node
*n
, char *msg
)
120 if (PyErr_WarnExplicit(PyExc_SyntaxWarning
, msg
, c
->c_filename
, LINENO(n
),
122 /* if -Werr, change it to a SyntaxError */
123 if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_SyntaxWarning
))
131 forbidden_check(struct compiling
*c
, const node
*n
, const char *x
)
133 if (!strcmp(x
, "None"))
134 return ast_error(n
, "cannot assign to None");
135 if (!strcmp(x
, "__debug__"))
136 return ast_error(n
, "cannot assign to __debug__");
137 if (Py_Py3kWarningFlag
) {
138 if (!(strcmp(x
, "True") && strcmp(x
, "False")) &&
139 !ast_warn(c
, n
, "assignment to True or False is forbidden in 3.x"))
141 if (!strcmp(x
, "nonlocal") &&
142 !ast_warn(c
, n
, "nonlocal is a keyword in 3.x"))
148 /* num_stmts() returns number of contained statements.
150 Use this routine to determine how big a sequence is needed for
151 the statements in a parse tree. Its raison d'etre is this bit of
154 stmt: simple_stmt | compound_stmt
155 simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE
157 A simple_stmt can contain multiple small_stmt elements joined
158 by semicolons. If the arg is a simple_stmt, the number of
159 small_stmt elements is returned.
163 num_stmts(const node
*n
)
170 if (TYPE(CHILD(n
, 0)) == NEWLINE
)
173 return num_stmts(CHILD(n
, 0));
176 for (i
= 0; i
< NCH(n
); i
++) {
178 if (TYPE(ch
) == stmt
)
183 return num_stmts(CHILD(n
, 0));
187 return NCH(n
) / 2; /* Divide by 2 to remove count of semi-colons */
190 return num_stmts(CHILD(n
, 0));
193 for (i
= 2; i
< (NCH(n
) - 1); i
++)
194 l
+= num_stmts(CHILD(n
, i
));
200 sprintf(buf
, "Non-statement found: %d %d",
209 /* Transform the CST rooted at node * to the appropriate AST
213 PyAST_FromNode(const node
*n
, PyCompilerFlags
*flags
, const char *filename
,
217 asdl_seq
*stmts
= NULL
;
222 if (flags
&& flags
->cf_flags
& PyCF_SOURCE_IS_UTF8
) {
223 c
.c_encoding
= "utf-8";
224 if (TYPE(n
) == encoding_decl
) {
225 ast_error(n
, "encoding declaration in Unicode string");
228 } else if (TYPE(n
) == encoding_decl
) {
229 c
.c_encoding
= STR(n
);
234 c
.c_future_unicode
= flags
&& flags
->cf_flags
& CO_FUTURE_UNICODE_LITERALS
;
236 c
.c_filename
= filename
;
241 stmts
= asdl_seq_new(num_stmts(n
), arena
);
244 for (i
= 0; i
< NCH(n
) - 1; i
++) {
246 if (TYPE(ch
) == NEWLINE
)
251 s
= ast_for_stmt(&c
, ch
);
254 asdl_seq_SET(stmts
, k
++, s
);
258 REQ(ch
, simple_stmt
);
259 for (j
= 0; j
< num
; j
++) {
260 s
= ast_for_stmt(&c
, CHILD(ch
, j
* 2));
263 asdl_seq_SET(stmts
, k
++, s
);
267 return Module(stmts
, arena
);
269 expr_ty testlist_ast
;
271 /* XXX Why not gen_for here? */
272 testlist_ast
= ast_for_testlist(&c
, CHILD(n
, 0));
275 return Expression(testlist_ast
, arena
);
278 if (TYPE(CHILD(n
, 0)) == NEWLINE
) {
279 stmts
= asdl_seq_new(1, arena
);
282 asdl_seq_SET(stmts
, 0, Pass(n
->n_lineno
, n
->n_col_offset
,
284 if (!asdl_seq_GET(stmts
, 0))
286 return Interactive(stmts
, arena
);
291 stmts
= asdl_seq_new(num
, arena
);
295 s
= ast_for_stmt(&c
, n
);
298 asdl_seq_SET(stmts
, 0, s
);
301 /* Only a simple_stmt can contain multiple statements. */
303 for (i
= 0; i
< NCH(n
); i
+= 2) {
304 if (TYPE(CHILD(n
, i
)) == NEWLINE
)
306 s
= ast_for_stmt(&c
, CHILD(n
, i
));
309 asdl_seq_SET(stmts
, i
/ 2, s
);
313 return Interactive(stmts
, arena
);
316 PyErr_Format(PyExc_SystemError
,
317 "invalid node %d for PyAST_FromNode", TYPE(n
));
321 ast_error_finish(filename
);
325 /* Return the AST repr. of the operator represented as syntax (|, ^, etc.)
329 get_operator(const node
*n
)
355 return (operator_ty
)0;
359 /* Set the context ctx for expr_ty e, recursively traversing e.
361 Only sets context for expr kinds that "can appear in assignment context"
362 (according to ../Parser/Python.asdl). For other expr kinds, it sets
363 an appropriate syntax error and returns false.
367 set_context(struct compiling
*c
, expr_ty e
, expr_context_ty ctx
, const node
*n
)
370 /* If a particular expression type can't be used for assign / delete,
371 set expr_name to its name and an error message will be generated.
373 const char* expr_name
= NULL
;
375 /* The ast defines augmented store and load contexts, but the
376 implementation here doesn't actually use them. The code may be
377 a little more complex than necessary as a result. It also means
378 that expressions in an augmented assignment have a Store context.
379 Consider restructuring so that augmented assignment uses
382 assert(ctx
!= AugStore
&& ctx
!= AugLoad
);
386 if (ctx
== Store
&& !forbidden_check(c
, n
,
387 PyBytes_AS_STRING(e
->v
.Attribute
.attr
)))
389 e
->v
.Attribute
.ctx
= ctx
;
392 e
->v
.Subscript
.ctx
= ctx
;
395 if (ctx
== Store
&& !forbidden_check(c
, n
,
396 PyBytes_AS_STRING(e
->v
.Name
.id
)))
405 if (asdl_seq_LEN(e
->v
.Tuple
.elts
) == 0)
406 return ast_error(n
, "can't assign to ()");
407 e
->v
.Tuple
.ctx
= ctx
;
411 expr_name
= "lambda";
414 expr_name
= "function call";
419 expr_name
= "operator";
421 case GeneratorExp_kind
:
422 expr_name
= "generator expression";
425 expr_name
= "yield expression";
428 expr_name
= "list comprehension";
433 expr_name
= "literal";
436 expr_name
= "comparison";
442 expr_name
= "conditional expression";
445 PyErr_Format(PyExc_SystemError
,
446 "unexpected expression in assignment %d (line %d)",
450 /* Check for error string set by switch */
453 PyOS_snprintf(buf
, sizeof(buf
),
455 ctx
== Store
? "assign to" : "delete",
457 return ast_error(n
, buf
);
460 /* If the LHS is a list or tuple, we need to set the assignment
461 context for all the contained elements.
466 for (i
= 0; i
< asdl_seq_LEN(s
); i
++) {
467 if (!set_context(c
, (expr_ty
)asdl_seq_GET(s
, i
), ctx
, n
))
475 ast_for_augassign(struct compiling
*c
, const node
*n
)
485 if (STR(n
)[1] == '/')
502 if (STR(n
)[1] == '*')
507 PyErr_Format(PyExc_SystemError
, "invalid augassign: %s", STR(n
));
508 return (operator_ty
)0;
513 ast_for_comp_op(struct compiling
*c
, const node
*n
)
515 /* comp_op: '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is'
526 case EQEQUAL
: /* == */
535 if (strcmp(STR(n
), "in") == 0)
537 if (strcmp(STR(n
), "is") == 0)
540 PyErr_Format(PyExc_SystemError
, "invalid comp_op: %s",
545 else if (NCH(n
) == 2) {
546 /* handle "not in" and "is not" */
547 switch (TYPE(CHILD(n
, 0))) {
549 if (strcmp(STR(CHILD(n
, 1)), "in") == 0)
551 if (strcmp(STR(CHILD(n
, 0)), "is") == 0)
554 PyErr_Format(PyExc_SystemError
, "invalid comp_op: %s %s",
555 STR(CHILD(n
, 0)), STR(CHILD(n
, 1)));
559 PyErr_Format(PyExc_SystemError
, "invalid comp_op: has %d children",
565 seq_for_testlist(struct compiling
*c
, const node
*n
)
567 /* testlist: test (',' test)* [','] */
571 assert(TYPE(n
) == testlist
||
572 TYPE(n
) == listmaker
||
573 TYPE(n
) == testlist_gexp
||
574 TYPE(n
) == testlist_safe
||
575 TYPE(n
) == testlist1
);
577 seq
= asdl_seq_new((NCH(n
) + 1) / 2, c
->c_arena
);
581 for (i
= 0; i
< NCH(n
); i
+= 2) {
582 assert(TYPE(CHILD(n
, i
)) == test
|| TYPE(CHILD(n
, i
)) == old_test
);
584 expression
= ast_for_expr(c
, CHILD(n
, i
));
588 assert(i
/ 2 < seq
->size
);
589 asdl_seq_SET(seq
, i
/ 2, expression
);
595 compiler_complex_args(struct compiling
*c
, const node
*n
)
597 int i
, len
= (NCH(n
) + 1) / 2;
599 asdl_seq
*args
= asdl_seq_new(len
, c
->c_arena
);
603 /* fpdef: NAME | '(' fplist ')'
604 fplist: fpdef (',' fpdef)* [',']
607 for (i
= 0; i
< len
; i
++) {
609 const node
*fpdef_node
= CHILD(n
, 2*i
);
613 /* fpdef_node is either a NAME or an fplist */
614 child
= CHILD(fpdef_node
, 0);
615 if (TYPE(child
) == NAME
) {
616 if (!forbidden_check(c
, n
, STR(child
)))
618 arg_id
= NEW_IDENTIFIER(child
);
621 arg
= Name(arg_id
, Store
, LINENO(child
), child
->n_col_offset
,
625 assert(TYPE(fpdef_node
) == fpdef
);
626 /* fpdef_node[0] is not a name, so it must be '(', get CHILD[1] */
627 child
= CHILD(fpdef_node
, 1);
628 assert(TYPE(child
) == fplist
);
629 /* NCH == 1 means we have (x), we need to elide the extra parens */
630 if (NCH(child
) == 1) {
631 fpdef_node
= CHILD(child
, 0);
632 assert(TYPE(fpdef_node
) == fpdef
);
635 arg
= compiler_complex_args(c
, child
);
637 asdl_seq_SET(args
, i
, arg
);
640 result
= Tuple(args
, Store
, LINENO(n
), n
->n_col_offset
, c
->c_arena
);
641 if (!set_context(c
, result
, Store
, n
))
647 /* Create AST for argument list. */
650 ast_for_arguments(struct compiling
*c
, const node
*n
)
652 /* parameters: '(' [varargslist] ')'
653 varargslist: (fpdef ['=' test] ',')* ('*' NAME [',' '**' NAME]
654 | '**' NAME) | fpdef ['=' test] (',' fpdef ['=' test])* [',']
656 int i
, j
, k
, n_args
= 0, n_defaults
= 0, found_default
= 0;
657 asdl_seq
*args
, *defaults
;
658 identifier vararg
= NULL
, kwarg
= NULL
;
661 if (TYPE(n
) == parameters
) {
662 if (NCH(n
) == 2) /* () as argument list */
663 return arguments(NULL
, NULL
, NULL
, NULL
, c
->c_arena
);
668 /* first count the number of normal args & defaults */
669 for (i
= 0; i
< NCH(n
); i
++) {
671 if (TYPE(ch
) == fpdef
)
673 if (TYPE(ch
) == EQUAL
)
676 args
= (n_args
? asdl_seq_new(n_args
, c
->c_arena
) : NULL
);
678 return NULL
; /* Don't need to goto error; no objects allocated */
679 defaults
= (n_defaults
? asdl_seq_new(n_defaults
, c
->c_arena
) : NULL
);
680 if (!defaults
&& n_defaults
)
681 return NULL
; /* Don't need to goto error; no objects allocated */
683 /* fpdef: NAME | '(' fplist ')'
684 fplist: fpdef (',' fpdef)* [',']
687 j
= 0; /* index for defaults */
688 k
= 0; /* index for args */
694 /* XXX Need to worry about checking if TYPE(CHILD(n, i+1)) is
695 anything other than EQUAL or a comma? */
696 /* XXX Should NCH(n) check be made a separate check? */
697 if (i
+ 1 < NCH(n
) && TYPE(CHILD(n
, i
+ 1)) == EQUAL
) {
698 expr_ty expression
= ast_for_expr(c
, CHILD(n
, i
+ 2));
701 assert(defaults
!= NULL
);
702 asdl_seq_SET(defaults
, j
++, expression
);
706 else if (found_default
) {
708 "non-default argument follows default argument");
713 /* def foo((x)): is not complex, special case. */
715 /* We have complex arguments, setup for unpacking. */
716 if (Py_Py3kWarningFlag
&& !ast_warn(c
, ch
,
717 "tuple parameter unpacking has been removed in 3.x"))
719 asdl_seq_SET(args
, k
++, compiler_complex_args(c
, ch
));
720 if (!asdl_seq_GET(args
, k
-1))
723 /* def foo((x)): setup for checking NAME below. */
724 /* Loop because there can be many parens and tuple
725 unpacking mixed in. */
727 assert(TYPE(ch
) == fpdef
);
731 if (TYPE(CHILD(ch
, 0)) == NAME
) {
734 if (!forbidden_check(c
, n
, STR(CHILD(ch
, 0))))
736 id
= NEW_IDENTIFIER(CHILD(ch
, 0));
739 name
= Name(id
, Param
, LINENO(ch
), ch
->n_col_offset
,
743 asdl_seq_SET(args
, k
++, name
);
746 i
+= 2; /* the name and the comma */
749 if (!forbidden_check(c
, CHILD(n
, i
+1), STR(CHILD(n
, i
+1))))
751 vararg
= NEW_IDENTIFIER(CHILD(n
, i
+1));
757 if (!forbidden_check(c
, CHILD(n
, i
+1), STR(CHILD(n
, i
+1))))
759 kwarg
= NEW_IDENTIFIER(CHILD(n
, i
+1));
765 PyErr_Format(PyExc_SystemError
,
766 "unexpected node in varargslist: %d @ %d",
772 return arguments(args
, vararg
, kwarg
, defaults
, c
->c_arena
);
781 ast_for_dotted_name(struct compiling
*c
, const node
*n
)
785 int lineno
, col_offset
;
791 col_offset
= n
->n_col_offset
;
793 id
= NEW_IDENTIFIER(CHILD(n
, 0));
796 e
= Name(id
, Load
, lineno
, col_offset
, c
->c_arena
);
800 for (i
= 2; i
< NCH(n
); i
+=2) {
801 id
= NEW_IDENTIFIER(CHILD(n
, i
));
804 e
= Attribute(e
, id
, Load
, lineno
, col_offset
, c
->c_arena
);
813 ast_for_decorator(struct compiling
*c
, const node
*n
)
815 /* decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE */
820 REQ(CHILD(n
, 0), AT
);
821 REQ(RCHILD(n
, -1), NEWLINE
);
823 name_expr
= ast_for_dotted_name(c
, CHILD(n
, 1));
827 if (NCH(n
) == 3) { /* No arguments */
831 else if (NCH(n
) == 5) { /* Call with no arguments */
832 d
= Call(name_expr
, NULL
, NULL
, NULL
, NULL
, LINENO(n
),
833 n
->n_col_offset
, c
->c_arena
);
839 d
= ast_for_call(c
, CHILD(n
, 3), name_expr
);
849 ast_for_decorators(struct compiling
*c
, const node
*n
)
851 asdl_seq
* decorator_seq
;
856 decorator_seq
= asdl_seq_new(NCH(n
), c
->c_arena
);
860 for (i
= 0; i
< NCH(n
); i
++) {
861 d
= ast_for_decorator(c
, CHILD(n
, i
));
864 asdl_seq_SET(decorator_seq
, i
, d
);
866 return decorator_seq
;
870 ast_for_funcdef(struct compiling
*c
, const node
*n
, asdl_seq
*decorator_seq
)
872 /* funcdef: 'def' NAME parameters ':' suite */
880 name
= NEW_IDENTIFIER(CHILD(n
, name_i
));
883 else if (!forbidden_check(c
, CHILD(n
, name_i
), STR(CHILD(n
, name_i
))))
885 args
= ast_for_arguments(c
, CHILD(n
, name_i
+ 1));
888 body
= ast_for_suite(c
, CHILD(n
, name_i
+ 3));
892 return FunctionDef(name
, args
, body
, decorator_seq
, LINENO(n
),
893 n
->n_col_offset
, c
->c_arena
);
897 ast_for_decorated(struct compiling
*c
, const node
*n
)
899 /* decorated: decorators (classdef | funcdef) */
900 stmt_ty thing
= NULL
;
901 asdl_seq
*decorator_seq
= NULL
;
905 decorator_seq
= ast_for_decorators(c
, CHILD(n
, 0));
909 assert(TYPE(CHILD(n
, 1)) == funcdef
||
910 TYPE(CHILD(n
, 1)) == classdef
);
912 if (TYPE(CHILD(n
, 1)) == funcdef
) {
913 thing
= ast_for_funcdef(c
, CHILD(n
, 1), decorator_seq
);
914 } else if (TYPE(CHILD(n
, 1)) == classdef
) {
915 thing
= ast_for_classdef(c
, CHILD(n
, 1), decorator_seq
);
917 /* we count the decorators in when talking about the class' or
918 function's line number */
920 thing
->lineno
= LINENO(n
);
921 thing
->col_offset
= n
->n_col_offset
;
927 ast_for_lambdef(struct compiling
*c
, const node
*n
)
929 /* lambdef: 'lambda' [varargslist] ':' test */
934 args
= arguments(NULL
, NULL
, NULL
, NULL
, c
->c_arena
);
937 expression
= ast_for_expr(c
, CHILD(n
, 2));
942 args
= ast_for_arguments(c
, CHILD(n
, 1));
945 expression
= ast_for_expr(c
, CHILD(n
, 3));
950 return Lambda(args
, expression
, LINENO(n
), n
->n_col_offset
, c
->c_arena
);
954 ast_for_ifexpr(struct compiling
*c
, const node
*n
)
956 /* test: or_test 'if' or_test 'else' test */
957 expr_ty expression
, body
, orelse
;
960 body
= ast_for_expr(c
, CHILD(n
, 0));
963 expression
= ast_for_expr(c
, CHILD(n
, 2));
966 orelse
= ast_for_expr(c
, CHILD(n
, 4));
969 return IfExp(expression
, body
, orelse
, LINENO(n
), n
->n_col_offset
,
973 /* XXX(nnorwitz): the listcomp and genexpr code should be refactored
974 so there is only a single version. Possibly for loops can also re-use
978 /* Count the number of 'for' loop in a list comprehension.
980 Helper for ast_for_listcomp().
984 count_list_fors(struct compiling
*c
, const node
*n
)
987 node
*ch
= CHILD(n
, 1);
999 if (TYPE(ch
) == list_for
)
1000 goto count_list_for
;
1001 else if (TYPE(ch
) == list_if
) {
1004 goto count_list_iter
;
1010 /* Should never be reached */
1011 PyErr_SetString(PyExc_SystemError
, "logic error in count_list_fors");
1015 /* Count the number of 'if' statements in a list comprehension.
1017 Helper for ast_for_listcomp().
1021 count_list_ifs(struct compiling
*c
, const node
*n
)
1027 if (TYPE(CHILD(n
, 0)) == list_for
)
1035 goto count_list_iter
;
1039 ast_for_listcomp(struct compiling
*c
, const node
*n
)
1041 /* listmaker: test ( list_for | (',' test)* [','] )
1042 list_for: 'for' exprlist 'in' testlist_safe [list_iter]
1043 list_iter: list_for | list_if
1044 list_if: 'if' test [list_iter]
1045 testlist_safe: test [(',' test)+ [',']]
1048 asdl_seq
*listcomps
;
1055 elt
= ast_for_expr(c
, CHILD(n
, 0));
1059 n_fors
= count_list_fors(c
, n
);
1063 listcomps
= asdl_seq_new(n_fors
, c
->c_arena
);
1068 for (i
= 0; i
< n_fors
; i
++) {
1069 comprehension_ty lc
;
1076 for_ch
= CHILD(ch
, 1);
1077 t
= ast_for_exprlist(c
, for_ch
, Store
);
1080 expression
= ast_for_testlist(c
, CHILD(ch
, 3));
1084 /* Check the # of children rather than the length of t, since
1085 [x for x, in ... ] has 1 element in t, but still requires a Tuple.
1087 if (NCH(for_ch
) == 1)
1088 lc
= comprehension((expr_ty
)asdl_seq_GET(t
, 0), expression
, NULL
,
1091 lc
= comprehension(Tuple(t
, Store
, LINENO(ch
), ch
->n_col_offset
,
1093 expression
, NULL
, c
->c_arena
);
1100 expr_ty list_for_expr
;
1103 n_ifs
= count_list_ifs(c
, ch
);
1107 ifs
= asdl_seq_new(n_ifs
, c
->c_arena
);
1111 for (j
= 0; j
< n_ifs
; j
++) {
1116 list_for_expr
= ast_for_expr(c
, CHILD(ch
, 1));
1120 asdl_seq_SET(ifs
, j
, list_for_expr
);
1124 /* on exit, must guarantee that ch is a list_for */
1125 if (TYPE(ch
) == list_iter
)
1129 asdl_seq_SET(listcomps
, i
, lc
);
1132 return ListComp(elt
, listcomps
, LINENO(n
), n
->n_col_offset
, c
->c_arena
);
1135 /* Count the number of 'for' loops in a generator expression.
1137 Helper for ast_for_genexp().
1141 count_gen_fors(struct compiling
*c
, const node
*n
)
1144 node
*ch
= CHILD(n
, 1);
1156 if (TYPE(ch
) == gen_for
)
1158 else if (TYPE(ch
) == gen_if
) {
1161 goto count_gen_iter
;
1167 /* Should never be reached */
1168 PyErr_SetString(PyExc_SystemError
,
1169 "logic error in count_gen_fors");
1173 /* Count the number of 'if' statements in a generator expression.
1175 Helper for ast_for_genexp().
1179 count_gen_ifs(struct compiling
*c
, const node
*n
)
1185 if (TYPE(CHILD(n
, 0)) == gen_for
)
1196 /* TODO(jhylton): Combine with list comprehension code? */
1198 ast_for_genexp(struct compiling
*c
, const node
*n
)
1200 /* testlist_gexp: test ( gen_for | (',' test)* [','] )
1201 argument: [test '='] test [gen_for] # Really [keyword '='] test */
1207 assert(TYPE(n
) == (testlist_gexp
) || TYPE(n
) == (argument
));
1210 elt
= ast_for_expr(c
, CHILD(n
, 0));
1214 n_fors
= count_gen_fors(c
, n
);
1218 genexps
= asdl_seq_new(n_fors
, c
->c_arena
);
1223 for (i
= 0; i
< n_fors
; i
++) {
1224 comprehension_ty ge
;
1231 for_ch
= CHILD(ch
, 1);
1232 t
= ast_for_exprlist(c
, for_ch
, Store
);
1235 expression
= ast_for_expr(c
, CHILD(ch
, 3));
1239 /* Check the # of children rather than the length of t, since
1240 (x for x, in ...) has 1 element in t, but still requires a Tuple. */
1241 if (NCH(for_ch
) == 1)
1242 ge
= comprehension((expr_ty
)asdl_seq_GET(t
, 0), expression
,
1245 ge
= comprehension(Tuple(t
, Store
, LINENO(ch
), ch
->n_col_offset
,
1247 expression
, NULL
, c
->c_arena
);
1257 n_ifs
= count_gen_ifs(c
, ch
);
1261 ifs
= asdl_seq_new(n_ifs
, c
->c_arena
);
1265 for (j
= 0; j
< n_ifs
; j
++) {
1270 expression
= ast_for_expr(c
, CHILD(ch
, 1));
1273 asdl_seq_SET(ifs
, j
, expression
);
1277 /* on exit, must guarantee that ch is a gen_for */
1278 if (TYPE(ch
) == gen_iter
)
1282 asdl_seq_SET(genexps
, i
, ge
);
1285 return GeneratorExp(elt
, genexps
, LINENO(n
), n
->n_col_offset
, c
->c_arena
);
1289 ast_for_atom(struct compiling
*c
, const node
*n
)
1291 /* atom: '(' [yield_expr|testlist_gexp] ')' | '[' [listmaker] ']'
1292 | '{' [dictmaker] '}' | '`' testlist '`' | NAME | NUMBER | STRING+
1294 node
*ch
= CHILD(n
, 0);
1298 /* All names start in Load context, but may later be
1300 PyObject
*name
= NEW_IDENTIFIER(ch
);
1303 return Name(name
, Load
, LINENO(n
), n
->n_col_offset
, c
->c_arena
);
1306 PyObject
*str
= parsestrplus(c
, n
);
1308 #ifdef Py_USING_UNICODE
1309 if (PyErr_ExceptionMatches(PyExc_UnicodeError
)){
1310 PyObject
*type
, *value
, *tback
, *errstr
;
1311 PyErr_Fetch(&type
, &value
, &tback
);
1312 errstr
= PyObject_Str(value
);
1316 s
= PyString_AsString(errstr
);
1317 PyOS_snprintf(buf
, sizeof(buf
), "(unicode error) %s", s
);
1321 ast_error(n
, "(unicode error) unknown error");
1330 PyArena_AddPyObject(c
->c_arena
, str
);
1331 return Str(str
, LINENO(n
), n
->n_col_offset
, c
->c_arena
);
1334 PyObject
*pynum
= parsenumber(c
, STR(ch
));
1338 PyArena_AddPyObject(c
->c_arena
, pynum
);
1339 return Num(pynum
, LINENO(n
), n
->n_col_offset
, c
->c_arena
);
1341 case LPAR
: /* some parenthesized expressions */
1344 if (TYPE(ch
) == RPAR
)
1345 return Tuple(NULL
, Load
, LINENO(n
), n
->n_col_offset
, c
->c_arena
);
1347 if (TYPE(ch
) == yield_expr
)
1348 return ast_for_expr(c
, ch
);
1350 if ((NCH(ch
) > 1) && (TYPE(CHILD(ch
, 1)) == gen_for
))
1351 return ast_for_genexp(c
, ch
);
1353 return ast_for_testlist_gexp(c
, ch
);
1354 case LSQB
: /* list (or list comprehension) */
1357 if (TYPE(ch
) == RSQB
)
1358 return List(NULL
, Load
, LINENO(n
), n
->n_col_offset
, c
->c_arena
);
1361 if (NCH(ch
) == 1 || TYPE(CHILD(ch
, 1)) == COMMA
) {
1362 asdl_seq
*elts
= seq_for_testlist(c
, ch
);
1366 return List(elts
, Load
, LINENO(n
), n
->n_col_offset
, c
->c_arena
);
1369 return ast_for_listcomp(c
, ch
);
1371 /* dictmaker: test ':' test (',' test ':' test)* [','] */
1373 asdl_seq
*keys
, *values
;
1376 size
= (NCH(ch
) + 1) / 4; /* +1 in case no trailing comma */
1377 keys
= asdl_seq_new(size
, c
->c_arena
);
1381 values
= asdl_seq_new(size
, c
->c_arena
);
1385 for (i
= 0; i
< NCH(ch
); i
+= 4) {
1388 expression
= ast_for_expr(c
, CHILD(ch
, i
));
1392 asdl_seq_SET(keys
, i
/ 4, expression
);
1394 expression
= ast_for_expr(c
, CHILD(ch
, i
+ 2));
1398 asdl_seq_SET(values
, i
/ 4, expression
);
1400 return Dict(keys
, values
, LINENO(n
), n
->n_col_offset
, c
->c_arena
);
1402 case BACKQUOTE
: { /* repr */
1404 if (Py_Py3kWarningFlag
&&
1405 !ast_warn(c
, n
, "backquote not supported in 3.x; use repr()"))
1407 expression
= ast_for_testlist(c
, CHILD(n
, 1));
1411 return Repr(expression
, LINENO(n
), n
->n_col_offset
, c
->c_arena
);
1414 PyErr_Format(PyExc_SystemError
, "unhandled atom %d", TYPE(ch
));
1420 ast_for_slice(struct compiling
*c
, const node
*n
)
1423 expr_ty lower
= NULL
, upper
= NULL
, step
= NULL
;
1428 subscript: '.' '.' '.' | test | [test] ':' [test] [sliceop]
1432 if (TYPE(ch
) == DOT
)
1433 return Ellipsis(c
->c_arena
);
1435 if (NCH(n
) == 1 && TYPE(ch
) == test
) {
1436 /* 'step' variable hold no significance in terms of being used over
1438 step
= ast_for_expr(c
, ch
);
1442 return Index(step
, c
->c_arena
);
1445 if (TYPE(ch
) == test
) {
1446 lower
= ast_for_expr(c
, ch
);
1451 /* If there's an upper bound it's in the second or third position. */
1452 if (TYPE(ch
) == COLON
) {
1454 node
*n2
= CHILD(n
, 1);
1456 if (TYPE(n2
) == test
) {
1457 upper
= ast_for_expr(c
, n2
);
1462 } else if (NCH(n
) > 2) {
1463 node
*n2
= CHILD(n
, 2);
1465 if (TYPE(n2
) == test
) {
1466 upper
= ast_for_expr(c
, n2
);
1472 ch
= CHILD(n
, NCH(n
) - 1);
1473 if (TYPE(ch
) == sliceop
) {
1475 /* No expression, so step is None */
1477 step
= Name(new_identifier("None", c
->c_arena
), Load
,
1478 LINENO(ch
), ch
->n_col_offset
, c
->c_arena
);
1483 if (TYPE(ch
) == test
) {
1484 step
= ast_for_expr(c
, ch
);
1491 return Slice(lower
, upper
, step
, c
->c_arena
);
1495 ast_for_binop(struct compiling
*c
, const node
*n
)
1497 /* Must account for a sequence of expressions.
1498 How should A op B op C by represented?
1499 BinOp(BinOp(A, op, B), op, C).
1503 expr_ty expr1
, expr2
, result
;
1504 operator_ty newoperator
;
1506 expr1
= ast_for_expr(c
, CHILD(n
, 0));
1510 expr2
= ast_for_expr(c
, CHILD(n
, 2));
1514 newoperator
= get_operator(CHILD(n
, 1));
1518 result
= BinOp(expr1
, newoperator
, expr2
, LINENO(n
), n
->n_col_offset
,
1523 nops
= (NCH(n
) - 1) / 2;
1524 for (i
= 1; i
< nops
; i
++) {
1525 expr_ty tmp_result
, tmp
;
1526 const node
* next_oper
= CHILD(n
, i
* 2 + 1);
1528 newoperator
= get_operator(next_oper
);
1532 tmp
= ast_for_expr(c
, CHILD(n
, i
* 2 + 2));
1536 tmp_result
= BinOp(result
, newoperator
, tmp
,
1537 LINENO(next_oper
), next_oper
->n_col_offset
,
1541 result
= tmp_result
;
1547 ast_for_trailer(struct compiling
*c
, const node
*n
, expr_ty left_expr
)
1549 /* trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME
1550 subscriptlist: subscript (',' subscript)* [',']
1551 subscript: '.' '.' '.' | test | [test] ':' [test] [sliceop]
1554 if (TYPE(CHILD(n
, 0)) == LPAR
) {
1556 return Call(left_expr
, NULL
, NULL
, NULL
, NULL
, LINENO(n
),
1557 n
->n_col_offset
, c
->c_arena
);
1559 return ast_for_call(c
, CHILD(n
, 1), left_expr
);
1561 else if (TYPE(CHILD(n
, 0)) == DOT
) {
1562 PyObject
*attr_id
= NEW_IDENTIFIER(CHILD(n
, 1));
1565 return Attribute(left_expr
, attr_id
, Load
,
1566 LINENO(n
), n
->n_col_offset
, c
->c_arena
);
1569 REQ(CHILD(n
, 0), LSQB
);
1570 REQ(CHILD(n
, 2), RSQB
);
1573 slice_ty slc
= ast_for_slice(c
, CHILD(n
, 0));
1576 return Subscript(left_expr
, slc
, Load
, LINENO(n
), n
->n_col_offset
,
1580 /* The grammar is ambiguous here. The ambiguity is resolved
1581 by treating the sequence as a tuple literal if there are
1588 asdl_seq
*slices
, *elts
;
1589 slices
= asdl_seq_new((NCH(n
) + 1) / 2, c
->c_arena
);
1592 for (j
= 0; j
< NCH(n
); j
+= 2) {
1593 slc
= ast_for_slice(c
, CHILD(n
, j
));
1596 if (slc
->kind
!= Index_kind
)
1598 asdl_seq_SET(slices
, j
/ 2, slc
);
1601 return Subscript(left_expr
, ExtSlice(slices
, c
->c_arena
),
1602 Load
, LINENO(n
), n
->n_col_offset
, c
->c_arena
);
1604 /* extract Index values and put them in a Tuple */
1605 elts
= asdl_seq_new(asdl_seq_LEN(slices
), c
->c_arena
);
1608 for (j
= 0; j
< asdl_seq_LEN(slices
); ++j
) {
1609 slc
= (slice_ty
)asdl_seq_GET(slices
, j
);
1610 assert(slc
->kind
== Index_kind
&& slc
->v
.Index
.value
);
1611 asdl_seq_SET(elts
, j
, slc
->v
.Index
.value
);
1613 e
= Tuple(elts
, Load
, LINENO(n
), n
->n_col_offset
, c
->c_arena
);
1616 return Subscript(left_expr
, Index(e
, c
->c_arena
),
1617 Load
, LINENO(n
), n
->n_col_offset
, c
->c_arena
);
1623 ast_for_factor(struct compiling
*c
, const node
*n
)
1625 node
*pfactor
, *ppower
, *patom
, *pnum
;
1628 /* If the unary - operator is applied to a constant, don't generate
1629 a UNARY_NEGATIVE opcode. Just store the approriate value as a
1630 constant. The peephole optimizer already does something like
1631 this but it doesn't handle the case where the constant is
1632 (sys.maxint - 1). In that case, we want a PyIntObject, not a
1635 if (TYPE(CHILD(n
, 0)) == MINUS
&&
1637 TYPE((pfactor
= CHILD(n
, 1))) == factor
&&
1638 NCH(pfactor
) == 1 &&
1639 TYPE((ppower
= CHILD(pfactor
, 0))) == power
&&
1641 TYPE((patom
= CHILD(ppower
, 0))) == atom
&&
1642 TYPE((pnum
= CHILD(patom
, 0))) == NUMBER
) {
1643 char *s
= PyObject_MALLOC(strlen(STR(pnum
)) + 2);
1647 strcpy(s
+ 1, STR(pnum
));
1648 PyObject_FREE(STR(pnum
));
1650 return ast_for_atom(c
, patom
);
1653 expression
= ast_for_expr(c
, CHILD(n
, 1));
1657 switch (TYPE(CHILD(n
, 0))) {
1659 return UnaryOp(UAdd
, expression
, LINENO(n
), n
->n_col_offset
,
1662 return UnaryOp(USub
, expression
, LINENO(n
), n
->n_col_offset
,
1665 return UnaryOp(Invert
, expression
, LINENO(n
),
1666 n
->n_col_offset
, c
->c_arena
);
1668 PyErr_Format(PyExc_SystemError
, "unhandled factor: %d",
1674 ast_for_power(struct compiling
*c
, const node
*n
)
1676 /* power: atom trailer* ('**' factor)*
1681 e
= ast_for_atom(c
, CHILD(n
, 0));
1686 for (i
= 1; i
< NCH(n
); i
++) {
1687 node
*ch
= CHILD(n
, i
);
1688 if (TYPE(ch
) != trailer
)
1690 tmp
= ast_for_trailer(c
, ch
, e
);
1693 tmp
->lineno
= e
->lineno
;
1694 tmp
->col_offset
= e
->col_offset
;
1697 if (TYPE(CHILD(n
, NCH(n
) - 1)) == factor
) {
1698 expr_ty f
= ast_for_expr(c
, CHILD(n
, NCH(n
) - 1));
1701 tmp
= BinOp(e
, Pow
, f
, LINENO(n
), n
->n_col_offset
, c
->c_arena
);
1709 /* Do not name a variable 'expr'! Will cause a compile error.
1713 ast_for_expr(struct compiling
*c
, const node
*n
)
1715 /* handle the full range of simple expressions
1716 test: or_test ['if' or_test 'else' test] | lambdef
1717 or_test: and_test ('or' and_test)*
1718 and_test: not_test ('and' not_test)*
1719 not_test: 'not' not_test | comparison
1720 comparison: expr (comp_op expr)*
1721 expr: xor_expr ('|' xor_expr)*
1722 xor_expr: and_expr ('^' and_expr)*
1723 and_expr: shift_expr ('&' shift_expr)*
1724 shift_expr: arith_expr (('<<'|'>>') arith_expr)*
1725 arith_expr: term (('+'|'-') term)*
1726 term: factor (('*'|'/'|'%'|'//') factor)*
1727 factor: ('+'|'-'|'~') factor | power
1728 power: atom trailer* ('**' factor)*
1730 As well as modified versions that exist for backward compatibility,
1731 to explicitly allow:
1732 [ x for x in lambda: 0, lambda: 1 ]
1733 (which would be ambiguous without these extra rules)
1735 old_test: or_test | old_lambdef
1736 old_lambdef: 'lambda' [vararglist] ':' old_test
1747 if (TYPE(CHILD(n
, 0)) == lambdef
||
1748 TYPE(CHILD(n
, 0)) == old_lambdef
)
1749 return ast_for_lambdef(c
, CHILD(n
, 0));
1750 else if (NCH(n
) > 1)
1751 return ast_for_ifexpr(c
, n
);
1759 seq
= asdl_seq_new((NCH(n
) + 1) / 2, c
->c_arena
);
1762 for (i
= 0; i
< NCH(n
); i
+= 2) {
1763 expr_ty e
= ast_for_expr(c
, CHILD(n
, i
));
1766 asdl_seq_SET(seq
, i
/ 2, e
);
1768 if (!strcmp(STR(CHILD(n
, 1)), "and"))
1769 return BoolOp(And
, seq
, LINENO(n
), n
->n_col_offset
,
1771 assert(!strcmp(STR(CHILD(n
, 1)), "or"));
1772 return BoolOp(Or
, seq
, LINENO(n
), n
->n_col_offset
, c
->c_arena
);
1779 expr_ty expression
= ast_for_expr(c
, CHILD(n
, 1));
1783 return UnaryOp(Not
, expression
, LINENO(n
), n
->n_col_offset
,
1795 ops
= asdl_int_seq_new(NCH(n
) / 2, c
->c_arena
);
1798 cmps
= asdl_seq_new(NCH(n
) / 2, c
->c_arena
);
1802 for (i
= 1; i
< NCH(n
); i
+= 2) {
1803 cmpop_ty newoperator
;
1805 newoperator
= ast_for_comp_op(c
, CHILD(n
, i
));
1810 expression
= ast_for_expr(c
, CHILD(n
, i
+ 1));
1815 asdl_seq_SET(ops
, i
/ 2, newoperator
);
1816 asdl_seq_SET(cmps
, i
/ 2, expression
);
1818 expression
= ast_for_expr(c
, CHILD(n
, 0));
1823 return Compare(expression
, ops
, cmps
, LINENO(n
),
1824 n
->n_col_offset
, c
->c_arena
);
1828 /* The next five cases all handle BinOps. The main body of code
1829 is the same in each case, but the switch turned inside out to
1830 reuse the code for each type of operator.
1842 return ast_for_binop(c
, n
);
1846 exp
= ast_for_testlist(c
, CHILD(n
, 1));
1850 return Yield(exp
, LINENO(n
), n
->n_col_offset
, c
->c_arena
);
1857 return ast_for_factor(c
, n
);
1859 return ast_for_power(c
, n
);
1861 PyErr_Format(PyExc_SystemError
, "unhandled expr: %d", TYPE(n
));
1864 /* should never get here unless if error is set */
1869 ast_for_call(struct compiling
*c
, const node
*n
, expr_ty func
)
1872 arglist: (argument ',')* (argument [',']| '*' test [',' '**' test]
1874 argument: [test '='] test [gen_for] # Really [keyword '='] test
1877 int i
, nargs
, nkeywords
, ngens
;
1880 expr_ty vararg
= NULL
, kwarg
= NULL
;
1887 for (i
= 0; i
< NCH(n
); i
++) {
1888 node
*ch
= CHILD(n
, i
);
1889 if (TYPE(ch
) == argument
) {
1892 else if (TYPE(CHILD(ch
, 1)) == gen_for
)
1898 if (ngens
> 1 || (ngens
&& (nargs
|| nkeywords
))) {
1899 ast_error(n
, "Generator expression must be parenthesized "
1900 "if not sole argument");
1904 if (nargs
+ nkeywords
+ ngens
> 255) {
1905 ast_error(n
, "more than 255 arguments");
1909 args
= asdl_seq_new(nargs
+ ngens
, c
->c_arena
);
1912 keywords
= asdl_seq_new(nkeywords
, c
->c_arena
);
1917 for (i
= 0; i
< NCH(n
); i
++) {
1918 node
*ch
= CHILD(n
, i
);
1919 if (TYPE(ch
) == argument
) {
1923 ast_error(CHILD(ch
, 0),
1924 "non-keyword arg after keyword arg");
1928 ast_error(CHILD(ch
, 0),
1929 "only named arguments may follow *expression");
1932 e
= ast_for_expr(c
, CHILD(ch
, 0));
1935 asdl_seq_SET(args
, nargs
++, e
);
1937 else if (TYPE(CHILD(ch
, 1)) == gen_for
) {
1938 e
= ast_for_genexp(c
, ch
);
1941 asdl_seq_SET(args
, nargs
++, e
);
1949 /* CHILD(ch, 0) is test, but must be an identifier? */
1950 e
= ast_for_expr(c
, CHILD(ch
, 0));
1953 /* f(lambda x: x[0] = 3) ends up getting parsed with
1954 * LHS test = lambda x: x[0], and RHS test = 3.
1955 * SF bug 132313 points out that complaining about a keyword
1956 * then is very confusing.
1958 if (e
->kind
== Lambda_kind
) {
1959 ast_error(CHILD(ch
, 0),
1960 "lambda cannot contain assignment");
1962 } else if (e
->kind
!= Name_kind
) {
1963 ast_error(CHILD(ch
, 0), "keyword can't be an expression");
1967 if (!forbidden_check(c
, CHILD(ch
, 0), PyBytes_AS_STRING(key
)))
1969 for (k
= 0; k
< nkeywords
; k
++) {
1970 tmp
= PyString_AS_STRING(
1971 ((keyword_ty
)asdl_seq_GET(keywords
, k
))->arg
);
1972 if (!strcmp(tmp
, PyString_AS_STRING(key
))) {
1973 ast_error(CHILD(ch
, 0), "keyword argument repeated");
1977 e
= ast_for_expr(c
, CHILD(ch
, 2));
1980 kw
= keyword(key
, e
, c
->c_arena
);
1983 asdl_seq_SET(keywords
, nkeywords
++, kw
);
1986 else if (TYPE(ch
) == STAR
) {
1987 vararg
= ast_for_expr(c
, CHILD(n
, i
+1));
1992 else if (TYPE(ch
) == DOUBLESTAR
) {
1993 kwarg
= ast_for_expr(c
, CHILD(n
, i
+1));
2000 return Call(func
, args
, keywords
, vararg
, kwarg
, func
->lineno
,
2001 func
->col_offset
, c
->c_arena
);
2005 ast_for_testlist(struct compiling
*c
, const node
* n
)
2007 /* testlist_gexp: test (',' test)* [','] */
2008 /* testlist: test (',' test)* [','] */
2009 /* testlist_safe: test (',' test)+ [','] */
2010 /* testlist1: test (',' test)* */
2012 if (TYPE(n
) == testlist_gexp
) {
2014 assert(TYPE(CHILD(n
, 1)) != gen_for
);
2017 assert(TYPE(n
) == testlist
||
2018 TYPE(n
) == testlist_safe
||
2019 TYPE(n
) == testlist1
);
2022 return ast_for_expr(c
, CHILD(n
, 0));
2024 asdl_seq
*tmp
= seq_for_testlist(c
, n
);
2027 return Tuple(tmp
, Load
, LINENO(n
), n
->n_col_offset
, c
->c_arena
);
2032 ast_for_testlist_gexp(struct compiling
*c
, const node
* n
)
2034 /* testlist_gexp: test ( gen_for | (',' test)* [','] ) */
2035 /* argument: test [ gen_for ] */
2036 assert(TYPE(n
) == testlist_gexp
|| TYPE(n
) == argument
);
2037 if (NCH(n
) > 1 && TYPE(CHILD(n
, 1)) == gen_for
)
2038 return ast_for_genexp(c
, n
);
2039 return ast_for_testlist(c
, n
);
2042 /* like ast_for_testlist() but returns a sequence */
2044 ast_for_class_bases(struct compiling
*c
, const node
* n
)
2046 /* testlist: test (',' test)* [','] */
2051 asdl_seq
*bases
= asdl_seq_new(1, c
->c_arena
);
2054 base
= ast_for_expr(c
, CHILD(n
, 0));
2057 asdl_seq_SET(bases
, 0, base
);
2061 return seq_for_testlist(c
, n
);
2065 ast_for_expr_stmt(struct compiling
*c
, const node
*n
)
2068 /* expr_stmt: testlist (augassign (yield_expr|testlist)
2069 | ('=' (yield_expr|testlist))*)
2070 testlist: test (',' test)* [',']
2071 augassign: '+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '|=' | '^='
2072 | '<<=' | '>>=' | '**=' | '//='
2073 test: ... here starts the operator precendence dance
2077 expr_ty e
= ast_for_testlist(c
, CHILD(n
, 0));
2081 return Expr(e
, LINENO(n
), n
->n_col_offset
, c
->c_arena
);
2083 else if (TYPE(CHILD(n
, 1)) == augassign
) {
2084 expr_ty expr1
, expr2
;
2085 operator_ty newoperator
;
2086 node
*ch
= CHILD(n
, 0);
2088 expr1
= ast_for_testlist(c
, ch
);
2091 /* TODO(nas): Remove duplicated error checks (set_context does it) */
2092 switch (expr1
->kind
) {
2093 case GeneratorExp_kind
:
2094 ast_error(ch
, "augmented assignment to generator "
2095 "expression not possible");
2098 ast_error(ch
, "augmented assignment to yield "
2099 "expression not possible");
2102 const char *var_name
= PyBytes_AS_STRING(expr1
->v
.Name
.id
);
2103 if ((var_name
[0] == 'N' || var_name
[0] == 'T' || var_name
[0] == 'F') &&
2104 !forbidden_check(c
, ch
, var_name
))
2108 case Attribute_kind
:
2109 case Subscript_kind
:
2112 ast_error(ch
, "illegal expression for augmented "
2116 if(!set_context(c
, expr1
, Store
, ch
))
2120 if (TYPE(ch
) == testlist
)
2121 expr2
= ast_for_testlist(c
, ch
);
2123 expr2
= ast_for_expr(c
, ch
);
2127 newoperator
= ast_for_augassign(c
, CHILD(n
, 1));
2131 return AugAssign(expr1
, newoperator
, expr2
, LINENO(n
), n
->n_col_offset
,
2140 /* a normal assignment */
2141 REQ(CHILD(n
, 1), EQUAL
);
2142 targets
= asdl_seq_new(NCH(n
) / 2, c
->c_arena
);
2145 for (i
= 0; i
< NCH(n
) - 2; i
+= 2) {
2147 node
*ch
= CHILD(n
, i
);
2148 if (TYPE(ch
) == yield_expr
) {
2149 ast_error(ch
, "assignment to yield expression not possible");
2152 e
= ast_for_testlist(c
, ch
);
2154 /* set context to assign */
2158 if (!set_context(c
, e
, Store
, CHILD(n
, i
)))
2161 asdl_seq_SET(targets
, i
/ 2, e
);
2163 value
= CHILD(n
, NCH(n
) - 1);
2164 if (TYPE(value
) == testlist
)
2165 expression
= ast_for_testlist(c
, value
);
2167 expression
= ast_for_expr(c
, value
);
2170 return Assign(targets
, expression
, LINENO(n
), n
->n_col_offset
,
2176 ast_for_print_stmt(struct compiling
*c
, const node
*n
)
2178 /* print_stmt: 'print' ( [ test (',' test)* [','] ]
2179 | '>>' test [ (',' test)+ [','] ] )
2181 expr_ty dest
= NULL
, expression
;
2184 int i
, j
, start
= 1;
2187 if (NCH(n
) >= 2 && TYPE(CHILD(n
, 1)) == RIGHTSHIFT
) {
2188 dest
= ast_for_expr(c
, CHILD(n
, 2));
2193 seq
= asdl_seq_new((NCH(n
) + 1 - start
) / 2, c
->c_arena
);
2196 for (i
= start
, j
= 0; i
< NCH(n
); i
+= 2, ++j
) {
2197 expression
= ast_for_expr(c
, CHILD(n
, i
));
2200 asdl_seq_SET(seq
, j
, expression
);
2202 nl
= (TYPE(CHILD(n
, NCH(n
) - 1)) == COMMA
) ? false : true;
2203 return Print(dest
, seq
, nl
, LINENO(n
), n
->n_col_offset
, c
->c_arena
);
2207 ast_for_exprlist(struct compiling
*c
, const node
*n
, expr_context_ty context
)
2215 seq
= asdl_seq_new((NCH(n
) + 1) / 2, c
->c_arena
);
2218 for (i
= 0; i
< NCH(n
); i
+= 2) {
2219 e
= ast_for_expr(c
, CHILD(n
, i
));
2222 asdl_seq_SET(seq
, i
/ 2, e
);
2223 if (context
&& !set_context(c
, e
, context
, CHILD(n
, i
)))
2230 ast_for_del_stmt(struct compiling
*c
, const node
*n
)
2232 asdl_seq
*expr_list
;
2234 /* del_stmt: 'del' exprlist */
2237 expr_list
= ast_for_exprlist(c
, CHILD(n
, 1), Del
);
2240 return Delete(expr_list
, LINENO(n
), n
->n_col_offset
, c
->c_arena
);
2244 ast_for_flow_stmt(struct compiling
*c
, const node
*n
)
2247 flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt
2250 continue_stmt: 'continue'
2251 return_stmt: 'return' [testlist]
2252 yield_stmt: yield_expr
2253 yield_expr: 'yield' testlist
2254 raise_stmt: 'raise' [test [',' test [',' test]]]
2262 return Break(LINENO(n
), n
->n_col_offset
, c
->c_arena
);
2264 return Continue(LINENO(n
), n
->n_col_offset
, c
->c_arena
);
2265 case yield_stmt
: { /* will reduce to yield_expr */
2266 expr_ty exp
= ast_for_expr(c
, CHILD(ch
, 0));
2269 return Expr(exp
, LINENO(n
), n
->n_col_offset
, c
->c_arena
);
2273 return Return(NULL
, LINENO(n
), n
->n_col_offset
, c
->c_arena
);
2275 expr_ty expression
= ast_for_testlist(c
, CHILD(ch
, 1));
2278 return Return(expression
, LINENO(n
), n
->n_col_offset
,
2283 return Raise(NULL
, NULL
, NULL
, LINENO(n
), n
->n_col_offset
,
2285 else if (NCH(ch
) == 2) {
2286 expr_ty expression
= ast_for_expr(c
, CHILD(ch
, 1));
2289 return Raise(expression
, NULL
, NULL
, LINENO(n
),
2290 n
->n_col_offset
, c
->c_arena
);
2292 else if (NCH(ch
) == 4) {
2293 expr_ty expr1
, expr2
;
2295 expr1
= ast_for_expr(c
, CHILD(ch
, 1));
2298 expr2
= ast_for_expr(c
, CHILD(ch
, 3));
2302 return Raise(expr1
, expr2
, NULL
, LINENO(n
), n
->n_col_offset
,
2305 else if (NCH(ch
) == 6) {
2306 expr_ty expr1
, expr2
, expr3
;
2308 expr1
= ast_for_expr(c
, CHILD(ch
, 1));
2311 expr2
= ast_for_expr(c
, CHILD(ch
, 3));
2314 expr3
= ast_for_expr(c
, CHILD(ch
, 5));
2318 return Raise(expr1
, expr2
, expr3
, LINENO(n
), n
->n_col_offset
,
2322 PyErr_Format(PyExc_SystemError
,
2323 "unexpected flow_stmt: %d", TYPE(ch
));
2327 PyErr_SetString(PyExc_SystemError
, "unhandled flow statement");
2332 alias_for_import_name(struct compiling
*c
, const node
*n
)
2335 import_as_name: NAME ['as' NAME]
2336 dotted_as_name: dotted_name ['as' NAME]
2337 dotted_name: NAME ('.' NAME)*
2339 PyObject
*str
, *name
;
2343 case import_as_name
:
2346 str
= NEW_IDENTIFIER(CHILD(n
, 2));
2350 name
= NEW_IDENTIFIER(CHILD(n
, 0));
2353 return alias(name
, str
, c
->c_arena
);
2354 case dotted_as_name
:
2360 alias_ty a
= alias_for_import_name(c
, CHILD(n
, 0));
2364 a
->asname
= NEW_IDENTIFIER(CHILD(n
, 2));
2372 name
= NEW_IDENTIFIER(CHILD(n
, 0));
2375 return alias(name
, NULL
, c
->c_arena
);
2378 /* Create a string of the form "a.b.c" */
2384 for (i
= 0; i
< NCH(n
); i
+= 2)
2385 /* length of string plus one for the dot */
2386 len
+= strlen(STR(CHILD(n
, i
))) + 1;
2387 len
--; /* the last name doesn't have a dot */
2388 str
= PyString_FromStringAndSize(NULL
, len
);
2391 s
= PyString_AS_STRING(str
);
2394 for (i
= 0; i
< NCH(n
); i
+= 2) {
2395 char *sch
= STR(CHILD(n
, i
));
2396 strcpy(s
, STR(CHILD(n
, i
)));
2402 PyString_InternInPlace(&str
);
2403 PyArena_AddPyObject(c
->c_arena
, str
);
2404 return alias(str
, NULL
, c
->c_arena
);
2408 str
= PyString_InternFromString("*");
2409 PyArena_AddPyObject(c
->c_arena
, str
);
2410 return alias(str
, NULL
, c
->c_arena
);
2412 PyErr_Format(PyExc_SystemError
,
2413 "unexpected import name: %d", TYPE(n
));
2417 PyErr_SetString(PyExc_SystemError
, "unhandled import name condition");
2422 ast_for_import_stmt(struct compiling
*c
, const node
*n
)
2425 import_stmt: import_name | import_from
2426 import_name: 'import' dotted_as_names
2427 import_from: 'from' ('.'* dotted_name | '.') 'import'
2428 ('*' | '(' import_as_names ')' | import_as_names)
2435 REQ(n
, import_stmt
);
2437 col_offset
= n
->n_col_offset
;
2439 if (TYPE(n
) == import_name
) {
2441 REQ(n
, dotted_as_names
);
2442 aliases
= asdl_seq_new((NCH(n
) + 1) / 2, c
->c_arena
);
2445 for (i
= 0; i
< NCH(n
); i
+= 2) {
2446 alias_ty import_alias
= alias_for_import_name(c
, CHILD(n
, i
));
2449 asdl_seq_SET(aliases
, i
/ 2, import_alias
);
2451 return Import(aliases
, lineno
, col_offset
, c
->c_arena
);
2453 else if (TYPE(n
) == import_from
) {
2456 alias_ty mod
= NULL
;
2459 /* Count the number of dots (for relative imports) and check for the
2460 optional module name */
2461 for (idx
= 1; idx
< NCH(n
); idx
++) {
2462 if (TYPE(CHILD(n
, idx
)) == dotted_name
) {
2463 mod
= alias_for_import_name(c
, CHILD(n
, idx
));
2466 } else if (TYPE(CHILD(n
, idx
)) != DOT
) {
2471 idx
++; /* skip over the 'import' keyword */
2472 switch (TYPE(CHILD(n
, idx
))) {
2474 /* from ... import * */
2479 /* from ... import (x, y, z) */
2480 n
= CHILD(n
, idx
+ 1);
2481 n_children
= NCH(n
);
2483 case import_as_names
:
2484 /* from ... import x, y, z */
2486 n_children
= NCH(n
);
2487 if (n_children
% 2 == 0) {
2488 ast_error(n
, "trailing comma not allowed without"
2489 " surrounding parentheses");
2494 ast_error(n
, "Unexpected node-type in from-import");
2498 aliases
= asdl_seq_new((n_children
+ 1) / 2, c
->c_arena
);
2502 /* handle "from ... import *" special b/c there's no children */
2503 if (TYPE(n
) == STAR
) {
2504 alias_ty import_alias
= alias_for_import_name(c
, n
);
2507 asdl_seq_SET(aliases
, 0, import_alias
);
2510 for (i
= 0; i
< NCH(n
); i
+= 2) {
2511 alias_ty import_alias
= alias_for_import_name(c
, CHILD(n
, i
));
2514 asdl_seq_SET(aliases
, i
/ 2, import_alias
);
2518 modname
= mod
->name
;
2520 modname
= new_identifier("", c
->c_arena
);
2521 return ImportFrom(modname
, aliases
, ndots
, lineno
, col_offset
,
2524 PyErr_Format(PyExc_SystemError
,
2525 "unknown import statement: starts with command '%s'",
2531 ast_for_global_stmt(struct compiling
*c
, const node
*n
)
2533 /* global_stmt: 'global' NAME (',' NAME)* */
2538 REQ(n
, global_stmt
);
2539 s
= asdl_seq_new(NCH(n
) / 2, c
->c_arena
);
2542 for (i
= 1; i
< NCH(n
); i
+= 2) {
2543 name
= NEW_IDENTIFIER(CHILD(n
, i
));
2546 asdl_seq_SET(s
, i
/ 2, name
);
2548 return Global(s
, LINENO(n
), n
->n_col_offset
, c
->c_arena
);
2552 ast_for_exec_stmt(struct compiling
*c
, const node
*n
)
2554 expr_ty expr1
, globals
= NULL
, locals
= NULL
;
2555 int n_children
= NCH(n
);
2556 if (n_children
!= 2 && n_children
!= 4 && n_children
!= 6) {
2557 PyErr_Format(PyExc_SystemError
,
2558 "poorly formed 'exec' statement: %d parts to statement",
2563 /* exec_stmt: 'exec' expr ['in' test [',' test]] */
2565 expr1
= ast_for_expr(c
, CHILD(n
, 1));
2568 if (n_children
>= 4) {
2569 globals
= ast_for_expr(c
, CHILD(n
, 3));
2573 if (n_children
== 6) {
2574 locals
= ast_for_expr(c
, CHILD(n
, 5));
2579 return Exec(expr1
, globals
, locals
, LINENO(n
), n
->n_col_offset
,
2584 ast_for_assert_stmt(struct compiling
*c
, const node
*n
)
2586 /* assert_stmt: 'assert' test [',' test] */
2587 REQ(n
, assert_stmt
);
2589 expr_ty expression
= ast_for_expr(c
, CHILD(n
, 1));
2592 return Assert(expression
, NULL
, LINENO(n
), n
->n_col_offset
,
2595 else if (NCH(n
) == 4) {
2596 expr_ty expr1
, expr2
;
2598 expr1
= ast_for_expr(c
, CHILD(n
, 1));
2601 expr2
= ast_for_expr(c
, CHILD(n
, 3));
2605 return Assert(expr1
, expr2
, LINENO(n
), n
->n_col_offset
, c
->c_arena
);
2607 PyErr_Format(PyExc_SystemError
,
2608 "improper number of parts to 'assert' statement: %d",
2614 ast_for_suite(struct compiling
*c
, const node
*n
)
2616 /* suite: simple_stmt | NEWLINE INDENT stmt+ DEDENT */
2619 int i
, total
, num
, end
, pos
= 0;
2624 total
= num_stmts(n
);
2625 seq
= asdl_seq_new(total
, c
->c_arena
);
2628 if (TYPE(CHILD(n
, 0)) == simple_stmt
) {
2630 /* simple_stmt always ends with a NEWLINE,
2631 and may have a trailing SEMI
2634 if (TYPE(CHILD(n
, end
- 1)) == SEMI
)
2636 /* loop by 2 to skip semi-colons */
2637 for (i
= 0; i
< end
; i
+= 2) {
2639 s
= ast_for_stmt(c
, ch
);
2642 asdl_seq_SET(seq
, pos
++, s
);
2646 for (i
= 2; i
< (NCH(n
) - 1); i
++) {
2649 num
= num_stmts(ch
);
2651 /* small_stmt or compound_stmt with only one child */
2652 s
= ast_for_stmt(c
, ch
);
2655 asdl_seq_SET(seq
, pos
++, s
);
2660 REQ(ch
, simple_stmt
);
2661 for (j
= 0; j
< NCH(ch
); j
+= 2) {
2662 /* statement terminates with a semi-colon ';' */
2663 if (NCH(CHILD(ch
, j
)) == 0) {
2664 assert((j
+ 1) == NCH(ch
));
2667 s
= ast_for_stmt(c
, CHILD(ch
, j
));
2670 asdl_seq_SET(seq
, pos
++, s
);
2675 assert(pos
== seq
->size
);
2680 ast_for_if_stmt(struct compiling
*c
, const node
*n
)
2682 /* if_stmt: 'if' test ':' suite ('elif' test ':' suite)*
2691 asdl_seq
*suite_seq
;
2693 expression
= ast_for_expr(c
, CHILD(n
, 1));
2696 suite_seq
= ast_for_suite(c
, CHILD(n
, 3));
2700 return If(expression
, suite_seq
, NULL
, LINENO(n
), n
->n_col_offset
,
2704 s
= STR(CHILD(n
, 4));
2705 /* s[2], the third character in the string, will be
2711 asdl_seq
*seq1
, *seq2
;
2713 expression
= ast_for_expr(c
, CHILD(n
, 1));
2716 seq1
= ast_for_suite(c
, CHILD(n
, 3));
2719 seq2
= ast_for_suite(c
, CHILD(n
, 6));
2723 return If(expression
, seq1
, seq2
, LINENO(n
), n
->n_col_offset
,
2726 else if (s
[2] == 'i') {
2727 int i
, n_elif
, has_else
= 0;
2729 asdl_seq
*suite_seq
;
2730 asdl_seq
*orelse
= NULL
;
2731 n_elif
= NCH(n
) - 4;
2732 /* must reference the child n_elif+1 since 'else' token is third,
2733 not fourth, child from the end. */
2734 if (TYPE(CHILD(n
, (n_elif
+ 1))) == NAME
2735 && STR(CHILD(n
, (n_elif
+ 1)))[2] == 's') {
2742 asdl_seq
*suite_seq2
;
2744 orelse
= asdl_seq_new(1, c
->c_arena
);
2747 expression
= ast_for_expr(c
, CHILD(n
, NCH(n
) - 6));
2750 suite_seq
= ast_for_suite(c
, CHILD(n
, NCH(n
) - 4));
2753 suite_seq2
= ast_for_suite(c
, CHILD(n
, NCH(n
) - 1));
2757 asdl_seq_SET(orelse
, 0,
2758 If(expression
, suite_seq
, suite_seq2
,
2759 LINENO(CHILD(n
, NCH(n
) - 6)),
2760 CHILD(n
, NCH(n
) - 6)->n_col_offset
,
2762 /* the just-created orelse handled the last elif */
2766 for (i
= 0; i
< n_elif
; i
++) {
2767 int off
= 5 + (n_elif
- i
- 1) * 4;
2768 asdl_seq
*newobj
= asdl_seq_new(1, c
->c_arena
);
2771 expression
= ast_for_expr(c
, CHILD(n
, off
));
2774 suite_seq
= ast_for_suite(c
, CHILD(n
, off
+ 2));
2778 asdl_seq_SET(newobj
, 0,
2779 If(expression
, suite_seq
, orelse
,
2780 LINENO(CHILD(n
, off
)),
2781 CHILD(n
, off
)->n_col_offset
, c
->c_arena
));
2784 expression
= ast_for_expr(c
, CHILD(n
, 1));
2787 suite_seq
= ast_for_suite(c
, CHILD(n
, 3));
2790 return If(expression
, suite_seq
, orelse
,
2791 LINENO(n
), n
->n_col_offset
, c
->c_arena
);
2794 PyErr_Format(PyExc_SystemError
,
2795 "unexpected token in 'if' statement: %s", s
);
2800 ast_for_while_stmt(struct compiling
*c
, const node
*n
)
2802 /* while_stmt: 'while' test ':' suite ['else' ':' suite] */
2807 asdl_seq
*suite_seq
;
2809 expression
= ast_for_expr(c
, CHILD(n
, 1));
2812 suite_seq
= ast_for_suite(c
, CHILD(n
, 3));
2815 return While(expression
, suite_seq
, NULL
, LINENO(n
), n
->n_col_offset
,
2818 else if (NCH(n
) == 7) {
2820 asdl_seq
*seq1
, *seq2
;
2822 expression
= ast_for_expr(c
, CHILD(n
, 1));
2825 seq1
= ast_for_suite(c
, CHILD(n
, 3));
2828 seq2
= ast_for_suite(c
, CHILD(n
, 6));
2832 return While(expression
, seq1
, seq2
, LINENO(n
), n
->n_col_offset
,
2836 PyErr_Format(PyExc_SystemError
,
2837 "wrong number of tokens for 'while' statement: %d",
2843 ast_for_for_stmt(struct compiling
*c
, const node
*n
)
2845 asdl_seq
*_target
, *seq
= NULL
, *suite_seq
;
2848 const node
*node_target
;
2849 /* for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite] */
2853 seq
= ast_for_suite(c
, CHILD(n
, 8));
2858 node_target
= CHILD(n
, 1);
2859 _target
= ast_for_exprlist(c
, node_target
, Store
);
2862 /* Check the # of children rather than the length of _target, since
2863 for x, in ... has 1 element in _target, but still requires a Tuple. */
2864 if (NCH(node_target
) == 1)
2865 target
= (expr_ty
)asdl_seq_GET(_target
, 0);
2867 target
= Tuple(_target
, Store
, LINENO(n
), n
->n_col_offset
, c
->c_arena
);
2869 expression
= ast_for_testlist(c
, CHILD(n
, 3));
2872 suite_seq
= ast_for_suite(c
, CHILD(n
, 5));
2876 return For(target
, expression
, suite_seq
, seq
, LINENO(n
), n
->n_col_offset
,
2880 static excepthandler_ty
2881 ast_for_except_clause(struct compiling
*c
, const node
*exc
, node
*body
)
2883 /* except_clause: 'except' [test [(',' | 'as') test]] */
2884 REQ(exc
, except_clause
);
2887 if (NCH(exc
) == 1) {
2888 asdl_seq
*suite_seq
= ast_for_suite(c
, body
);
2892 return ExceptHandler(NULL
, NULL
, suite_seq
, LINENO(exc
),
2893 exc
->n_col_offset
, c
->c_arena
);
2895 else if (NCH(exc
) == 2) {
2897 asdl_seq
*suite_seq
;
2899 expression
= ast_for_expr(c
, CHILD(exc
, 1));
2902 suite_seq
= ast_for_suite(c
, body
);
2906 return ExceptHandler(expression
, NULL
, suite_seq
, LINENO(exc
),
2907 exc
->n_col_offset
, c
->c_arena
);
2909 else if (NCH(exc
) == 4) {
2910 asdl_seq
*suite_seq
;
2912 expr_ty e
= ast_for_expr(c
, CHILD(exc
, 3));
2915 if (!set_context(c
, e
, Store
, CHILD(exc
, 3)))
2917 expression
= ast_for_expr(c
, CHILD(exc
, 1));
2920 suite_seq
= ast_for_suite(c
, body
);
2924 return ExceptHandler(expression
, e
, suite_seq
, LINENO(exc
),
2925 exc
->n_col_offset
, c
->c_arena
);
2928 PyErr_Format(PyExc_SystemError
,
2929 "wrong number of children for 'except' clause: %d",
2935 ast_for_try_stmt(struct compiling
*c
, const node
*n
)
2937 const int nch
= NCH(n
);
2938 int n_except
= (nch
- 3)/3;
2939 asdl_seq
*body
, *orelse
= NULL
, *finally
= NULL
;
2943 body
= ast_for_suite(c
, CHILD(n
, 2));
2947 if (TYPE(CHILD(n
, nch
- 3)) == NAME
) {
2948 if (strcmp(STR(CHILD(n
, nch
- 3)), "finally") == 0) {
2949 if (nch
>= 9 && TYPE(CHILD(n
, nch
- 6)) == NAME
) {
2950 /* we can assume it's an "else",
2951 because nch >= 9 for try-else-finally and
2952 it would otherwise have a type of except_clause */
2953 orelse
= ast_for_suite(c
, CHILD(n
, nch
- 4));
2959 finally
= ast_for_suite(c
, CHILD(n
, nch
- 1));
2960 if (finally
== NULL
)
2965 /* we can assume it's an "else",
2966 otherwise it would have a type of except_clause */
2967 orelse
= ast_for_suite(c
, CHILD(n
, nch
- 1));
2973 else if (TYPE(CHILD(n
, nch
- 3)) != except_clause
) {
2974 ast_error(n
, "malformed 'try' statement");
2981 /* process except statements to create a try ... except */
2982 asdl_seq
*handlers
= asdl_seq_new(n_except
, c
->c_arena
);
2983 if (handlers
== NULL
)
2986 for (i
= 0; i
< n_except
; i
++) {
2987 excepthandler_ty e
= ast_for_except_clause(c
, CHILD(n
, 3 + i
* 3),
2988 CHILD(n
, 5 + i
* 3));
2991 asdl_seq_SET(handlers
, i
, e
);
2994 except_st
= TryExcept(body
, handlers
, orelse
, LINENO(n
),
2995 n
->n_col_offset
, c
->c_arena
);
2999 /* if a 'finally' is present too, we nest the TryExcept within a
3000 TryFinally to emulate try ... except ... finally */
3001 body
= asdl_seq_new(1, c
->c_arena
);
3004 asdl_seq_SET(body
, 0, except_st
);
3007 /* must be a try ... finally (except clauses are in body, if any exist) */
3008 assert(finally
!= NULL
);
3009 return TryFinally(body
, finally
, LINENO(n
), n
->n_col_offset
, c
->c_arena
);
3013 ast_for_with_var(struct compiling
*c
, const node
*n
)
3016 return ast_for_expr(c
, CHILD(n
, 1));
3019 /* with_stmt: 'with' test [ with_var ] ':' suite */
3021 ast_for_with_stmt(struct compiling
*c
, const node
*n
)
3023 expr_ty context_expr
, optional_vars
= NULL
;
3024 int suite_index
= 3; /* skip 'with', test, and ':' */
3025 asdl_seq
*suite_seq
;
3027 assert(TYPE(n
) == with_stmt
);
3028 context_expr
= ast_for_expr(c
, CHILD(n
, 1));
3031 if (TYPE(CHILD(n
, 2)) == with_var
) {
3032 optional_vars
= ast_for_with_var(c
, CHILD(n
, 2));
3034 if (!optional_vars
) {
3037 if (!set_context(c
, optional_vars
, Store
, n
)) {
3043 suite_seq
= ast_for_suite(c
, CHILD(n
, suite_index
));
3047 return With(context_expr
, optional_vars
, suite_seq
, LINENO(n
),
3048 n
->n_col_offset
, c
->c_arena
);
3052 ast_for_classdef(struct compiling
*c
, const node
*n
, asdl_seq
*decorator_seq
)
3054 /* classdef: 'class' NAME ['(' testlist ')'] ':' suite */
3055 PyObject
*classname
;
3056 asdl_seq
*bases
, *s
;
3060 if (!forbidden_check(c
, n
, STR(CHILD(n
, 1))))
3064 s
= ast_for_suite(c
, CHILD(n
, 3));
3067 classname
= NEW_IDENTIFIER(CHILD(n
, 1));
3070 return ClassDef(classname
, NULL
, s
, decorator_seq
, LINENO(n
),
3071 n
->n_col_offset
, c
->c_arena
);
3073 /* check for empty base list */
3074 if (TYPE(CHILD(n
,3)) == RPAR
) {
3075 s
= ast_for_suite(c
, CHILD(n
,5));
3078 classname
= NEW_IDENTIFIER(CHILD(n
, 1));
3081 return ClassDef(classname
, NULL
, s
, decorator_seq
, LINENO(n
),
3082 n
->n_col_offset
, c
->c_arena
);
3085 /* else handle the base class list */
3086 bases
= ast_for_class_bases(c
, CHILD(n
, 3));
3090 s
= ast_for_suite(c
, CHILD(n
, 6));
3093 classname
= NEW_IDENTIFIER(CHILD(n
, 1));
3096 return ClassDef(classname
, bases
, s
, decorator_seq
,
3097 LINENO(n
), n
->n_col_offset
, c
->c_arena
);
3101 ast_for_stmt(struct compiling
*c
, const node
*n
)
3103 if (TYPE(n
) == stmt
) {
3104 assert(NCH(n
) == 1);
3107 if (TYPE(n
) == simple_stmt
) {
3108 assert(num_stmts(n
) == 1);
3111 if (TYPE(n
) == small_stmt
) {
3114 /* small_stmt: expr_stmt | print_stmt | del_stmt | pass_stmt
3115 | flow_stmt | import_stmt | global_stmt | exec_stmt
3120 return ast_for_expr_stmt(c
, n
);
3122 return ast_for_print_stmt(c
, n
);
3124 return ast_for_del_stmt(c
, n
);
3126 return Pass(LINENO(n
), n
->n_col_offset
, c
->c_arena
);
3128 return ast_for_flow_stmt(c
, n
);
3130 return ast_for_import_stmt(c
, n
);
3132 return ast_for_global_stmt(c
, n
);
3134 return ast_for_exec_stmt(c
, n
);
3136 return ast_for_assert_stmt(c
, n
);
3138 PyErr_Format(PyExc_SystemError
,
3139 "unhandled small_stmt: TYPE=%d NCH=%d\n",
3145 /* compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt
3146 | funcdef | classdef | decorated
3148 node
*ch
= CHILD(n
, 0);
3149 REQ(n
, compound_stmt
);
3152 return ast_for_if_stmt(c
, ch
);
3154 return ast_for_while_stmt(c
, ch
);
3156 return ast_for_for_stmt(c
, ch
);
3158 return ast_for_try_stmt(c
, ch
);
3160 return ast_for_with_stmt(c
, ch
);
3162 return ast_for_funcdef(c
, ch
, NULL
);
3164 return ast_for_classdef(c
, ch
, NULL
);
3166 return ast_for_decorated(c
, ch
);
3168 PyErr_Format(PyExc_SystemError
,
3169 "unhandled small_stmt: TYPE=%d NCH=%d\n",
3177 parsenumber(struct compiling
*c
, const char *s
)
3182 #ifndef WITHOUT_COMPLEX
3189 end
= s
+ strlen(s
) - 1;
3190 #ifndef WITHOUT_COMPLEX
3191 imflag
= *end
== 'j' || *end
== 'J';
3193 if (*end
== 'l' || *end
== 'L')
3194 return PyLong_FromString((char *)s
, (char **)0, 0);
3195 x
= PyOS_strtol((char *)s
, (char **)&end
, 0);
3198 return PyLong_FromString((char *)s
, (char **)0, 0);
3199 return PyInt_FromLong(x
);
3201 /* XXX Huge floats may silently fail */
3202 #ifndef WITHOUT_COMPLEX
3205 PyFPE_START_PROTECT("atof", return 0)
3206 complex.imag
= PyOS_ascii_atof(s
);
3207 PyFPE_END_PROTECT(complex)
3208 return PyComplex_FromCComplex(complex);
3213 PyFPE_START_PROTECT("atof", return 0)
3214 dx
= PyOS_ascii_atof(s
);
3215 PyFPE_END_PROTECT(dx
)
3216 return PyFloat_FromDouble(dx
);
3221 decode_utf8(struct compiling
*c
, const char **sPtr
, const char *end
, char* encoding
)
3223 #ifndef Py_USING_UNICODE
3224 Py_FatalError("decode_utf8 should not be called in this build.");
3229 t
= s
= (char *)*sPtr
;
3230 /* while (s < end && *s != '\\') s++; */ /* inefficient for u".." */
3231 while (s
< end
&& (*s
& 0x80)) s
++;
3233 u
= PyUnicode_DecodeUTF8(t
, s
- t
, NULL
);
3236 v
= PyUnicode_AsEncodedString(u
, encoding
, NULL
);
3242 #ifdef Py_USING_UNICODE
3244 decode_unicode(struct compiling
*c
, const char *s
, size_t len
, int rawmode
, const char *encoding
)
3250 if (encoding
== NULL
) {
3253 } else if (strcmp(encoding
, "iso-8859-1") == 0) {
3257 /* check for integer overflow */
3258 if (len
> PY_SIZE_MAX
/ 4)
3260 /* "\XX" may become "\u005c\uHHLL" (12 bytes) */
3261 u
= PyString_FromStringAndSize((char *)NULL
, len
* 4);
3264 p
= buf
= PyString_AsString(u
);
3274 if (*s
& 0x80) { /* XXX inefficient */
3278 w
= decode_utf8(c
, &s
, end
, "utf-16-be");
3283 r
= PyString_AsString(w
);
3284 rn
= PyString_Size(w
);
3285 assert(rn
% 2 == 0);
3286 for (i
= 0; i
< rn
; i
+= 2) {
3287 sprintf(p
, "\\u%02x%02x",
3301 v
= PyUnicode_DecodeRawUnicodeEscape(s
, len
, NULL
);
3303 v
= PyUnicode_DecodeUnicodeEscape(s
, len
, NULL
);
3309 /* s is a Python string literal, including the bracketing quote characters,
3310 * and r &/or u prefixes (if any), and embedded escape sequences (if any).
3311 * parsestr parses it, and returns the decoded Python string object.
3314 parsestr(struct compiling
*c
, const char *s
)
3317 int quote
= Py_CHARMASK(*s
);
3320 int unicode
= c
->c_future_unicode
;
3322 if (isalpha(quote
) || quote
== '_') {
3323 if (quote
== 'u' || quote
== 'U') {
3327 if (quote
== 'b' || quote
== 'B') {
3331 if (quote
== 'r' || quote
== 'R') {
3336 if (quote
!= '\'' && quote
!= '\"') {
3337 PyErr_BadInternalCall();
3342 if (len
> INT_MAX
) {
3343 PyErr_SetString(PyExc_OverflowError
,
3344 "string to parse is too long");
3347 if (s
[--len
] != quote
) {
3348 PyErr_BadInternalCall();
3351 if (len
>= 4 && s
[0] == quote
&& s
[1] == quote
) {
3354 if (s
[--len
] != quote
|| s
[--len
] != quote
) {
3355 PyErr_BadInternalCall();
3359 #ifdef Py_USING_UNICODE
3360 if (unicode
|| Py_UnicodeFlag
) {
3361 return decode_unicode(c
, s
, len
, rawmode
, c
->c_encoding
);
3364 need_encoding
= (c
->c_encoding
!= NULL
&&
3365 strcmp(c
->c_encoding
, "utf-8") != 0 &&
3366 strcmp(c
->c_encoding
, "iso-8859-1") != 0);
3367 if (rawmode
|| strchr(s
, '\\') == NULL
) {
3368 if (need_encoding
) {
3369 #ifndef Py_USING_UNICODE
3370 /* This should not happen - we never see any other
3373 "cannot deal with encodings in this build.");
3375 PyObject
*v
, *u
= PyUnicode_DecodeUTF8(s
, len
, NULL
);
3378 v
= PyUnicode_AsEncodedString(u
, c
->c_encoding
, NULL
);
3383 return PyString_FromStringAndSize(s
, len
);
3387 return PyString_DecodeEscape(s
, len
, NULL
, unicode
,
3388 need_encoding
? c
->c_encoding
: NULL
);
3391 /* Build a Python string object out of a STRING atom. This takes care of
3392 * compile-time literal catenation, calling parsestr() on each piece, and
3393 * pasting the intermediate results together.
3396 parsestrplus(struct compiling
*c
, const node
*n
)
3400 REQ(CHILD(n
, 0), STRING
);
3401 if ((v
= parsestr(c
, STR(CHILD(n
, 0)))) != NULL
) {
3402 /* String literal concatenation */
3403 for (i
= 1; i
< NCH(n
); i
++) {
3405 s
= parsestr(c
, STR(CHILD(n
, i
)));
3408 if (PyString_Check(v
) && PyString_Check(s
)) {
3409 PyString_ConcatAndDel(&v
, s
);
3413 #ifdef Py_USING_UNICODE
3415 PyObject
*temp
= PyUnicode_Concat(v
, s
);