?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Issue #2183: Simplify and optimize bytecode for list comprehensions.
[python.git] / Python / compile.c
blob756a903340827f26a10abf0df29224a279159bea
1 /*
2 * This file compiles an abstract syntax tree (AST) into Python bytecode.
3 *
4 * The primary entry point is PyAST_Compile(), which returns a
5 * PyCodeObject. The compiler makes several passes to build the code
6 * object:
7 * 1. Checks for future statements. See future.c
8 * 2. Builds a symbol table. See symtable.c.
9 * 3. Generate code for basic blocks. See compiler_mod() in this file.
10 * 4. Assemble the basic blocks into final code. See assemble() in
11 * this file.
12 * 5. Optimize the byte code (peephole optimizations). See peephole.c
13 *
14 * Note that compiler_mod() suggests module, but the module ast type
15 * (mod_ty) has cases for expressions and interactive statements.
16 *
17 * CAUTION: The VISIT_* macros abort the current function when they
18 * encounter a problem. So don't invoke them when there is memory
19 * which needs to be released. Code blocks are OK, as the compiler
20 * structure takes care of releasing those. Use the arena to manage
21 * objects.
22 */
23
24 #include "Python.h"
25
26 #include "Python-ast.h"
27 #include "node.h"
28 #include "pyarena.h"
29 #include "ast.h"
30 #include "code.h"
31 #include "compile.h"
32 #include "symtable.h"
33 #include "opcode.h"
34
35 int Py_OptimizeFlag = 0;
36
37 #define DEFAULT_BLOCK_SIZE 16
38 #define DEFAULT_BLOCKS 8
39 #define DEFAULT_CODE_SIZE 128
40 #define DEFAULT_LNOTAB_SIZE 16
41
42 struct instr {
43 unsigned i_jabs : 1;
44 unsigned i_jrel : 1;
45 unsigned i_hasarg : 1;
46 unsigned char i_opcode;
47 int i_oparg;
48 struct basicblock_ *i_target; /* target block (if jump instruction) */
49 int i_lineno;
50 };
51
52 typedef struct basicblock_ {
53 /* Each basicblock in a compilation unit is linked via b_list in the
54 reverse order that the block are allocated. b_list points to the next
55 block, not to be confused with b_next, which is next by control flow. */
56 struct basicblock_ *b_list;
57 /* number of instructions used */
58 int b_iused;
59 /* length of instruction array (b_instr) */
60 int b_ialloc;
61 /* pointer to an array of instructions, initially NULL */
62 struct instr *b_instr;
63 /* If b_next is non-NULL, it is a pointer to the next
64 block reached by normal control flow. */
65 struct basicblock_ *b_next;
66 /* b_seen is used to perform a DFS of basicblocks. */
67 unsigned b_seen : 1;
68 /* b_return is true if a RETURN_VALUE opcode is inserted. */
69 unsigned b_return : 1;
70 /* depth of stack upon entry of block, computed by stackdepth() */
71 int b_startdepth;
72 /* instruction offset for block, computed by assemble_jump_offsets() */
73 int b_offset;
74 } basicblock;
75
76 /* fblockinfo tracks the current frame block.
77
78 A frame block is used to handle loops, try/except, and try/finally.
79 It's called a frame block to distinguish it from a basic block in the
80 compiler IR.
81 */
82
83 enum fblocktype { LOOP, EXCEPT, FINALLY_TRY, FINALLY_END };
84
85 struct fblockinfo {
86 enum fblocktype fb_type;
87 basicblock *fb_block;
88 };
89
90 /* The following items change on entry and exit of code blocks.
91 They must be saved and restored when returning to a block.
92 */
93 struct compiler_unit {
94 PySTEntryObject *u_ste;
95
96 PyObject *u_name;
97 /* The following fields are dicts that map objects to
98 the index of them in co_XXX. The index is used as
99 the argument for opcodes that refer to those collections.
100 */
101 PyObject *u_consts; /* all constants */
102 PyObject *u_names; /* all names */
103 PyObject *u_varnames; /* local variables */
104 PyObject *u_cellvars; /* cell variables */
105 PyObject *u_freevars; /* free variables */
106
107 PyObject *u_private; /* for private name mangling */
108
109 int u_argcount; /* number of arguments for block */
110 /* Pointer to the most recently allocated block. By following b_list
111 members, you can reach all early allocated blocks. */
112 basicblock *u_blocks;
113 basicblock *u_curblock; /* pointer to current block */
114 int u_tmpname; /* temporary variables for list comps */
115
116 int u_nfblocks;
117 struct fblockinfo u_fblock[CO_MAXBLOCKS];
118
119 int u_firstlineno; /* the first lineno of the block */
120 int u_lineno; /* the lineno for the current stmt */
121 bool u_lineno_set; /* boolean to indicate whether instr
122 has been generated with current lineno */
123 };
124
125 /* This struct captures the global state of a compilation.
126
127 The u pointer points to the current compilation unit, while units
128 for enclosing blocks are stored in c_stack. The u and c_stack are
129 managed by compiler_enter_scope() and compiler_exit_scope().
130 */
131
132 struct compiler {
133 const char *c_filename;
134 struct symtable *c_st;
135 PyFutureFeatures *c_future; /* pointer to module's __future__ */
136 PyCompilerFlags *c_flags;
137
138 int c_interactive; /* true if in interactive mode */
139 int c_nestlevel;
140
141 struct compiler_unit *u; /* compiler state for current block */
142 PyObject *c_stack; /* Python list holding compiler_unit ptrs */
143 char *c_encoding; /* source encoding (a borrowed reference) */
144 PyArena *c_arena; /* pointer to memory allocation arena */
145 };
146
147 static int compiler_enter_scope(struct compiler *, identifier, void *, int);
148 static void compiler_free(struct compiler *);
149 static basicblock *compiler_new_block(struct compiler *);
150 static int compiler_next_instr(struct compiler *, basicblock *);
151 static int compiler_addop(struct compiler *, int);
152 static int compiler_addop_o(struct compiler *, int, PyObject *, PyObject *);
153 static int compiler_addop_i(struct compiler *, int, int);
154 static int compiler_addop_j(struct compiler *, int, basicblock *, int);
155 static basicblock *compiler_use_new_block(struct compiler *);
156 static int compiler_error(struct compiler *, const char *);
157 static int compiler_nameop(struct compiler *, identifier, expr_context_ty);
158
159 static PyCodeObject *compiler_mod(struct compiler *, mod_ty);
160 static int compiler_visit_stmt(struct compiler *, stmt_ty);
161 static int compiler_visit_keyword(struct compiler *, keyword_ty);
162 static int compiler_visit_expr(struct compiler *, expr_ty);
163 static int compiler_augassign(struct compiler *, stmt_ty);
164 static int compiler_visit_slice(struct compiler *, slice_ty,
165 expr_context_ty);
166
167 static int compiler_push_fblock(struct compiler *, enum fblocktype,
168 basicblock *);
169 static void compiler_pop_fblock(struct compiler *, enum fblocktype,
170 basicblock *);
171 /* Returns true if there is a loop on the fblock stack. */
172 static int compiler_in_loop(struct compiler *);
173
174 static int inplace_binop(struct compiler *, operator_ty);
175 static int expr_constant(expr_ty e);
176
177 static int compiler_with(struct compiler *, stmt_ty);
178
179 static PyCodeObject *assemble(struct compiler *, int addNone);
180 static PyObject *__doc__;
181
182 PyObject *
183 _Py_Mangle(PyObject *privateobj, PyObject *ident)
184 {
185 /* Name mangling: __private becomes _classname__private.
186 This is independent from how the name is used. */
187 const char *p, *name = PyString_AsString(ident);
188 char *buffer;
189 size_t nlen, plen;
190 if (privateobj == NULL || !PyString_Check(privateobj) ||
191 name == NULL || name[0] != '_' || name[1] != '_') {
192 Py_INCREF(ident);
193 return ident;
194 }
195 p = PyString_AsString(privateobj);
196 nlen = strlen(name);
197 /* Don't mangle __id__ or names with dots.
198
199 The only time a name with a dot can occur is when
200 we are compiling an import statement that has a
201 package name.
202
203 TODO(jhylton): Decide whether we want to support
204 mangling of the module name, e.g. __M.X.
205 */
206 if ((name[nlen-1] == '_' && name[nlen-2] == '_')
207 || strchr(name, '.')) {
208 Py_INCREF(ident);
209 return ident; /* Don't mangle __whatever__ */
210 }
211 /* Strip leading underscores from class name */
212 while (*p == '_')
213 p++;
214 if (*p == '\0') {
215 Py_INCREF(ident);
216 return ident; /* Don't mangle if class is just underscores */
217 }
218 plen = strlen(p);
219
220 assert(1 <= PY_SSIZE_T_MAX - nlen);
221 assert(1 + nlen <= PY_SSIZE_T_MAX - plen);
222
223 ident = PyString_FromStringAndSize(NULL, 1 + nlen + plen);
224 if (!ident)
225 return 0;
226 /* ident = "_" + p[:plen] + name # i.e. 1+plen+nlen bytes */
227 buffer = PyString_AS_STRING(ident);
228 buffer[0] = '_';
229 strncpy(buffer+1, p, plen);
230 strcpy(buffer+1+plen, name);
231 return ident;
232 }
233
234 static int
235 compiler_init(struct compiler *c)
236 {
237 memset(c, 0, sizeof(struct compiler));
238
239 c->c_stack = PyList_New(0);
240 if (!c->c_stack)
241 return 0;
242
243 return 1;
244 }
245
246 PyCodeObject *
247 PyAST_Compile(mod_ty mod, const char *filename, PyCompilerFlags *flags,
248 PyArena *arena)
249 {
250 struct compiler c;
251 PyCodeObject *co = NULL;
252 PyCompilerFlags local_flags;
253 int merged;
254
255 if (!__doc__) {
256 __doc__ = PyString_InternFromString("__doc__");
257 if (!__doc__)
258 return NULL;
259 }
260
261 if (!compiler_init(&c))
262 return NULL;
263 c.c_filename = filename;
264 c.c_arena = arena;
265 c.c_future = PyFuture_FromAST(mod, filename);
266 if (c.c_future == NULL)
267 goto finally;
268 if (!flags) {
269 local_flags.cf_flags = 0;
270 flags = &local_flags;
271 }
272 merged = c.c_future->ff_features | flags->cf_flags;
273 c.c_future->ff_features = merged;
274 flags->cf_flags = merged;
275 c.c_flags = flags;
276 c.c_nestlevel = 0;
277
278 c.c_st = PySymtable_Build(mod, filename, c.c_future);
279 if (c.c_st == NULL) {
280 if (!PyErr_Occurred())
281 PyErr_SetString(PyExc_SystemError, "no symtable");
282 goto finally;
283 }
284
285 /* XXX initialize to NULL for now, need to handle */
286 c.c_encoding = NULL;
287
288 co = compiler_mod(&c, mod);
289
290 finally:
291 compiler_free(&c);
292 assert(co || PyErr_Occurred());
293 return co;
294 }
295
296 PyCodeObject *
297 PyNode_Compile(struct _node *n, const char *filename)
298 {
299 PyCodeObject *co = NULL;
300 mod_ty mod;
301 PyArena *arena = PyArena_New();
302 if (!arena)
303 return NULL;
304 mod = PyAST_FromNode(n, NULL, filename, arena);
305 if (mod)
306 co = PyAST_Compile(mod, filename, NULL, arena);
307 PyArena_Free(arena);
308 return co;
309 }
310
311 static void
312 compiler_free(struct compiler *c)
313 {
314 if (c->c_st)
315 PySymtable_Free(c->c_st);
316 if (c->c_future)
317 PyObject_Free(c->c_future);
318 Py_DECREF(c->c_stack);
319 }
320
321 static PyObject *
322 list2dict(PyObject *list)
323 {
324 Py_ssize_t i, n;
325 PyObject *v, *k;
326 PyObject *dict = PyDict_New();
327 if (!dict) return NULL;
328
329 n = PyList_Size(list);
330 for (i = 0; i < n; i++) {
331 v = PyInt_FromLong(i);
332 if (!v) {
333 Py_DECREF(dict);
334 return NULL;
335 }
336 k = PyList_GET_ITEM(list, i);
337 k = PyTuple_Pack(2, k, k->ob_type);
338 if (k == NULL || PyDict_SetItem(dict, k, v) < 0) {
339 Py_XDECREF(k);
340 Py_DECREF(v);
341 Py_DECREF(dict);
342 return NULL;
343 }
344 Py_DECREF(k);
345 Py_DECREF(v);
346 }
347 return dict;
348 }
349
350 /* Return new dict containing names from src that match scope(s).
351
352 src is a symbol table dictionary. If the scope of a name matches
353 either scope_type or flag is set, insert it into the new dict. The
354 values are integers, starting at offset and increasing by one for
355 each key.
356 */
357
358 static PyObject *
359 dictbytype(PyObject *src, int scope_type, int flag, int offset)
360 {
361 Py_ssize_t pos = 0, i = offset, scope;
362 PyObject *k, *v, *dest = PyDict_New();
363
364 assert(offset >= 0);
365 if (dest == NULL)
366 return NULL;
367
368 while (PyDict_Next(src, &pos, &k, &v)) {
369 /* XXX this should probably be a macro in symtable.h */
370 assert(PyInt_Check(v));
371 scope = (PyInt_AS_LONG(v) >> SCOPE_OFF) & SCOPE_MASK;
372
373 if (scope == scope_type || PyInt_AS_LONG(v) & flag) {
374 PyObject *tuple, *item = PyInt_FromLong(i);
375 if (item == NULL) {
376 Py_DECREF(dest);
377 return NULL;
378 }
379 i++;
380 tuple = PyTuple_Pack(2, k, k->ob_type);
381 if (!tuple || PyDict_SetItem(dest, tuple, item) < 0) {
382 Py_DECREF(item);
383 Py_DECREF(dest);
384 Py_XDECREF(tuple);
385 return NULL;
386 }
387 Py_DECREF(item);
388 Py_DECREF(tuple);
389 }
390 }
391 return dest;
392 }
393
394 static void
395 compiler_unit_check(struct compiler_unit *u)
396 {
397 basicblock *block;
398 for (block = u->u_blocks; block != NULL; block = block->b_list) {
399 assert((void *)block != (void *)0xcbcbcbcb);
400 assert((void *)block != (void *)0xfbfbfbfb);
401 assert((void *)block != (void *)0xdbdbdbdb);
402 if (block->b_instr != NULL) {
403 assert(block->b_ialloc > 0);
404 assert(block->b_iused > 0);
405 assert(block->b_ialloc >= block->b_iused);
406 }
407 else {
408 assert (block->b_iused == 0);
409 assert (block->b_ialloc == 0);
410 }
411 }
412 }
413
414 static void
415 compiler_unit_free(struct compiler_unit *u)
416 {
417 basicblock *b, *next;
418
419 compiler_unit_check(u);
420 b = u->u_blocks;
421 while (b != NULL) {
422 if (b->b_instr)
423 PyObject_Free((void *)b->b_instr);
424 next = b->b_list;
425 PyObject_Free((void *)b);
426 b = next;
427 }
428 Py_CLEAR(u->u_ste);
429 Py_CLEAR(u->u_name);
430 Py_CLEAR(u->u_consts);
431 Py_CLEAR(u->u_names);
432 Py_CLEAR(u->u_varnames);
433 Py_CLEAR(u->u_freevars);
434 Py_CLEAR(u->u_cellvars);
435 Py_CLEAR(u->u_private);
436 PyObject_Free(u);
437 }
438
439 static int
440 compiler_enter_scope(struct compiler *c, identifier name, void *key,
441 int lineno)
442 {
443 struct compiler_unit *u;
444
445 u = (struct compiler_unit *)PyObject_Malloc(sizeof(
446 struct compiler_unit));
447 if (!u) {
448 PyErr_NoMemory();
449 return 0;
450 }
451 memset(u, 0, sizeof(struct compiler_unit));
452 u->u_argcount = 0;
453 u->u_ste = PySymtable_Lookup(c->c_st, key);
454 if (!u->u_ste) {
455 compiler_unit_free(u);
456 return 0;
457 }
458 Py_INCREF(name);
459 u->u_name = name;
460 u->u_varnames = list2dict(u->u_ste->ste_varnames);
461 u->u_cellvars = dictbytype(u->u_ste->ste_symbols, CELL, 0, 0);
462 if (!u->u_varnames || !u->u_cellvars) {
463 compiler_unit_free(u);
464 return 0;
465 }
466
467 u->u_freevars = dictbytype(u->u_ste->ste_symbols, FREE, DEF_FREE_CLASS,
468 PyDict_Size(u->u_cellvars));
469 if (!u->u_freevars) {
470 compiler_unit_free(u);
471 return 0;
472 }
473
474 u->u_blocks = NULL;
475 u->u_tmpname = 0;
476 u->u_nfblocks = 0;
477 u->u_firstlineno = lineno;
478 u->u_lineno = 0;
479 u->u_lineno_set = false;
480 u->u_consts = PyDict_New();
481 if (!u->u_consts) {
482 compiler_unit_free(u);
483 return 0;
484 }
485 u->u_names = PyDict_New();
486 if (!u->u_names) {
487 compiler_unit_free(u);
488 return 0;
489 }
490
491 u->u_private = NULL;
492
493 /* Push the old compiler_unit on the stack. */
494 if (c->u) {
495 PyObject *wrapper = PyCObject_FromVoidPtr(c->u, NULL);
496 if (!wrapper || PyList_Append(c->c_stack, wrapper) < 0) {
497 Py_XDECREF(wrapper);
498 compiler_unit_free(u);
499 return 0;
500 }
501 Py_DECREF(wrapper);
502 u->u_private = c->u->u_private;
503 Py_XINCREF(u->u_private);
504 }
505 c->u = u;
506
507 c->c_nestlevel++;
508 if (compiler_use_new_block(c) == NULL)
509 return 0;
510
511 return 1;
512 }
513
514 static void
515 compiler_exit_scope(struct compiler *c)
516 {
517 int n;
518 PyObject *wrapper;
519
520 c->c_nestlevel--;
521 compiler_unit_free(c->u);
522 /* Restore c->u to the parent unit. */
523 n = PyList_GET_SIZE(c->c_stack) - 1;
524 if (n >= 0) {
525 wrapper = PyList_GET_ITEM(c->c_stack, n);
526 c->u = (struct compiler_unit *)PyCObject_AsVoidPtr(wrapper);
527 assert(c->u);
528 /* we are deleting from a list so this really shouldn't fail */
529 if (PySequence_DelItem(c->c_stack, n) < 0)
530 Py_FatalError("compiler_exit_scope()");
531 compiler_unit_check(c->u);
532 }
533 else
534 c->u = NULL;
535
536 }
537
538 /* Allocate a new "anonymous" local variable.
539 Used by list comprehensions and with statements.
540 */
541
542 static PyObject *
543 compiler_new_tmpname(struct compiler *c)
544 {
545 char tmpname[256];
546 PyOS_snprintf(tmpname, sizeof(tmpname), "_[%d]", ++c->u->u_tmpname);
547 return PyString_FromString(tmpname);
548 }
549
550 /* Allocate a new block and return a pointer to it.
551 Returns NULL on error.
552 */
553
554 static basicblock *
555 compiler_new_block(struct compiler *c)
556 {
557 basicblock *b;
558 struct compiler_unit *u;
559
560 u = c->u;
561 b = (basicblock *)PyObject_Malloc(sizeof(basicblock));
562 if (b == NULL) {
563 PyErr_NoMemory();
564 return NULL;
565 }
566 memset((void *)b, 0, sizeof(basicblock));
567 /* Extend the singly linked list of blocks with new block. */
568 b->b_list = u->u_blocks;
569 u->u_blocks = b;
570 return b;
571 }
572
573 static basicblock *
574 compiler_use_new_block(struct compiler *c)
575 {
576 basicblock *block = compiler_new_block(c);
577 if (block == NULL)
578 return NULL;
579 c->u->u_curblock = block;
580 return block;
581 }
582
583 static basicblock *
584 compiler_next_block(struct compiler *c)
585 {
586 basicblock *block = compiler_new_block(c);
587 if (block == NULL)
588 return NULL;
589 c->u->u_curblock->b_next = block;
590 c->u->u_curblock = block;
591 return block;
592 }
593
594 static basicblock *
595 compiler_use_next_block(struct compiler *c, basicblock *block)
596 {
597 assert(block != NULL);
598 c->u->u_curblock->b_next = block;
599 c->u->u_curblock = block;
600 return block;
601 }
602
603 /* Returns the offset of the next instruction in the current block's
604 b_instr array. Resizes the b_instr as necessary.
605 Returns -1 on failure.
606 */
607
608 static int
609 compiler_next_instr(struct compiler *c, basicblock *b)
610 {
611 assert(b != NULL);
612 if (b->b_instr == NULL) {
613 b->b_instr = (struct instr *)PyObject_Malloc(
614 sizeof(struct instr) * DEFAULT_BLOCK_SIZE);
615 if (b->b_instr == NULL) {
616 PyErr_NoMemory();
617 return -1;
618 }
619 b->b_ialloc = DEFAULT_BLOCK_SIZE;
620 memset((char *)b->b_instr, 0,
621 sizeof(struct instr) * DEFAULT_BLOCK_SIZE);
622 }
623 else if (b->b_iused == b->b_ialloc) {
624 struct instr *tmp;
625 size_t oldsize, newsize;
626 oldsize = b->b_ialloc * sizeof(struct instr);
627 newsize = oldsize << 1;
628
629 if (oldsize > (PY_SIZE_MAX >> 1)) {
630 PyErr_NoMemory();
631 return -1;
632 }
633
634 if (newsize == 0) {
635 PyErr_NoMemory();
636 return -1;
637 }
638 b->b_ialloc <<= 1;
639 tmp = (struct instr *)PyObject_Realloc(
640 (void *)b->b_instr, newsize);
641 if (tmp == NULL) {
642 PyErr_NoMemory();
643 return -1;
644 }
645 b->b_instr = tmp;
646 memset((char *)b->b_instr + oldsize, 0, newsize - oldsize);
647 }
648 return b->b_iused++;
649 }
650
651 /* Set the i_lineno member of the instruction at offset off if the
652 line number for the current expression/statement has not
653 already been set. If it has been set, the call has no effect.
654
655 The line number is reset in the following cases:
656 - when entering a new scope
657 - on each statement
658 - on each expression that start a new line
659 - before the "except" clause
660 - before the "for" and "while" expressions
661 */
662
663 static void
664 compiler_set_lineno(struct compiler *c, int off)
665 {
666 basicblock *b;
667 if (c->u->u_lineno_set)
668 return;
669 c->u->u_lineno_set = true;
670 b = c->u->u_curblock;
671 b->b_instr[off].i_lineno = c->u->u_lineno;
672 }
673
674 static int
675 opcode_stack_effect(int opcode, int oparg)
676 {
677 switch (opcode) {
678 case POP_TOP:
679 return -1;
680 case ROT_TWO:
681 case ROT_THREE:
682 return 0;
683 case DUP_TOP:
684 return 1;
685 case ROT_FOUR:
686 return 0;
687
688 case UNARY_POSITIVE:
689 case UNARY_NEGATIVE:
690 case UNARY_NOT:
691 case UNARY_CONVERT:
692 case UNARY_INVERT:
693 return 0;
694
695 case LIST_APPEND:
696 return -1;
697
698 case BINARY_POWER:
699 case BINARY_MULTIPLY:
700 case BINARY_DIVIDE:
701 case BINARY_MODULO:
702 case BINARY_ADD:
703 case BINARY_SUBTRACT:
704 case BINARY_SUBSCR:
705 case BINARY_FLOOR_DIVIDE:
706 case BINARY_TRUE_DIVIDE:
707 return -1;
708 case INPLACE_FLOOR_DIVIDE:
709 case INPLACE_TRUE_DIVIDE:
710 return -1;
711
712 case SLICE+0:
713 return 1;
714 case SLICE+1:
715 return 0;
716 case SLICE+2:
717 return 0;
718 case SLICE+3:
719 return -1;
720
721 case STORE_SLICE+0:
722 return -2;
723 case STORE_SLICE+1:
724 return -3;
725 case STORE_SLICE+2:
726 return -3;
727 case STORE_SLICE+3:
728 return -4;
729
730 case DELETE_SLICE+0:
731 return -1;
732 case DELETE_SLICE+1:
733 return -2;
734 case DELETE_SLICE+2:
735 return -2;
736 case DELETE_SLICE+3:
737 return -3;
738
739 case INPLACE_ADD:
740 case INPLACE_SUBTRACT:
741 case INPLACE_MULTIPLY:
742 case INPLACE_DIVIDE:
743 case INPLACE_MODULO:
744 return -1;
745 case STORE_SUBSCR:
746 return -3;
747 case STORE_MAP:
748 return -2;
749 case DELETE_SUBSCR:
750 return -2;
751
752 case BINARY_LSHIFT:
753 case BINARY_RSHIFT:
754 case BINARY_AND:
755 case BINARY_XOR:
756 case BINARY_OR:
757 return -1;
758 case INPLACE_POWER:
759 return -1;
760 case GET_ITER:
761 return 0;
762
763 case PRINT_EXPR:
764 return -1;
765 case PRINT_ITEM:
766 return -1;
767 case PRINT_NEWLINE:
768 return 0;
769 case PRINT_ITEM_TO:
770 return -2;
771 case PRINT_NEWLINE_TO:
772 return -1;
773 case INPLACE_LSHIFT:
774 case INPLACE_RSHIFT:
775 case INPLACE_AND:
776 case INPLACE_XOR:
777 case INPLACE_OR:
778 return -1;
779 case BREAK_LOOP:
780 return 0;
781 case WITH_CLEANUP:
782 return -1; /* XXX Sometimes more */
783 case LOAD_LOCALS:
784 return 1;
785 case RETURN_VALUE:
786 return -1;
787 case IMPORT_STAR:
788 return -1;
789 case EXEC_STMT:
790 return -3;
791 case YIELD_VALUE:
792 return 0;
793
794 case POP_BLOCK:
795 return 0;
796 case END_FINALLY:
797 return -1; /* or -2 or -3 if exception occurred */
798 case BUILD_CLASS:
799 return -2;
800
801 case STORE_NAME:
802 return -1;
803 case DELETE_NAME:
804 return 0;
805 case UNPACK_SEQUENCE:
806 return oparg-1;
807 case FOR_ITER:
808 return 1;
809
810 case STORE_ATTR:
811 return -2;
812 case DELETE_ATTR:
813 return -1;
814 case STORE_GLOBAL:
815 return -1;
816 case DELETE_GLOBAL:
817 return 0;
818 case DUP_TOPX:
819 return oparg;
820 case LOAD_CONST:
821 return 1;
822 case LOAD_NAME:
823 return 1;
824 case BUILD_TUPLE:
825 case BUILD_LIST:
826 return 1-oparg;
827 case BUILD_MAP:
828 return 1;
829 case LOAD_ATTR:
830 return 0;
831 case COMPARE_OP:
832 return -1;
833 case IMPORT_NAME:
834 return 0;
835 case IMPORT_FROM:
836 return 1;
837
838 case JUMP_FORWARD:
839 case JUMP_IF_FALSE:
840 case JUMP_IF_TRUE:
841 case JUMP_ABSOLUTE:
842 return 0;
843
844 case LOAD_GLOBAL:
845 return 1;
846
847 case CONTINUE_LOOP:
848 return 0;
849 case SETUP_LOOP:
850 return 0;
851 case SETUP_EXCEPT:
852 case SETUP_FINALLY:
853 return 3; /* actually pushed by an exception */
854
855 case LOAD_FAST:
856 return 1;
857 case STORE_FAST:
858 return -1;
859 case DELETE_FAST:
860 return 0;
861
862 case RAISE_VARARGS:
863 return -oparg;
864 #define NARGS(o) (((o) % 256) + 2*((o) / 256))
865 case CALL_FUNCTION:
866 return -NARGS(oparg);
867 case CALL_FUNCTION_VAR:
868 case CALL_FUNCTION_KW:
869 return -NARGS(oparg)-1;
870 case CALL_FUNCTION_VAR_KW:
871 return -NARGS(oparg)-2;
872 #undef NARGS
873 case MAKE_FUNCTION:
874 return -oparg;
875 case BUILD_SLICE:
876 if (oparg == 3)
877 return -2;
878 else
879 return -1;
880
881 case MAKE_CLOSURE:
882 return -oparg;
883 case LOAD_CLOSURE:
884 return 1;
885 case LOAD_DEREF:
886 return 1;
887 case STORE_DEREF:
888 return -1;
889 default:
890 fprintf(stderr, "opcode = %d\n", opcode);
891 Py_FatalError("opcode_stack_effect()");
892
893 }
894 return 0; /* not reachable */
895 }
896
897 /* Add an opcode with no argument.
898 Returns 0 on failure, 1 on success.
899 */
900
901 static int
902 compiler_addop(struct compiler *c, int opcode)
903 {
904 basicblock *b;
905 struct instr *i;
906 int off;
907 off = compiler_next_instr(c, c->u->u_curblock);
908 if (off < 0)
909 return 0;
910 b = c->u->u_curblock;
911 i = &b->b_instr[off];
912 i->i_opcode = opcode;
913 i->i_hasarg = 0;
914 if (opcode == RETURN_VALUE)
915 b->b_return = 1;
916 compiler_set_lineno(c, off);
917 return 1;
918 }
919
920 static int
921 compiler_add_o(struct compiler *c, PyObject *dict, PyObject *o)
922 {
923 PyObject *t, *v;
924 Py_ssize_t arg;
925 unsigned char *p, *q;
926 Py_complex z;
927 double d;
928 int real_part_zero, imag_part_zero;
929
930 /* necessary to make sure types aren't coerced (e.g., int and long) */
931 /* _and_ to distinguish 0.0 from -0.0 e.g. on IEEE platforms */
932 if (PyFloat_Check(o)) {
933 d = PyFloat_AS_DOUBLE(o);
934 p = (unsigned char*) &d;
935 /* all we need is to make the tuple different in either the 0.0
936 * or -0.0 case from all others, just to avoid the "coercion".
937 */
938 if (*p==0 && p[sizeof(double)-1]==0)
939 t = PyTuple_Pack(3, o, o->ob_type, Py_None);
940 else
941 t = PyTuple_Pack(2, o, o->ob_type);
942 }
943 else if (PyComplex_Check(o)) {
944 /* complex case is even messier: we need to make complex(x,
945 0.) different from complex(x, -0.) and complex(0., y)
946 different from complex(-0., y), for any x and y. In
947 particular, all four complex zeros should be
948 distinguished.*/
949 z = PyComplex_AsCComplex(o);
950 p = (unsigned char*) &(z.real);
951 q = (unsigned char*) &(z.imag);
952 /* all that matters here is that on IEEE platforms
953 real_part_zero will be true if z.real == 0., and false if
954 z.real == -0. In fact, real_part_zero will also be true
955 for some other rarely occurring nonzero floats, but this
956 doesn't matter. Similar comments apply to
957 imag_part_zero. */
958 real_part_zero = *p==0 && p[sizeof(double)-1]==0;
959 imag_part_zero = *q==0 && q[sizeof(double)-1]==0;
960 if (real_part_zero && imag_part_zero) {
961 t = PyTuple_Pack(4, o, o->ob_type, Py_True, Py_True);
962 }
963 else if (real_part_zero && !imag_part_zero) {
964 t = PyTuple_Pack(4, o, o->ob_type, Py_True, Py_False);
965 }
966 else if (!real_part_zero && imag_part_zero) {
967 t = PyTuple_Pack(4, o, o->ob_type, Py_False, Py_True);
968 }
969 else {
970 t = PyTuple_Pack(2, o, o->ob_type);
971 }
972 }
973 else {
974 t = PyTuple_Pack(2, o, o->ob_type);
975 }
976 if (t == NULL)
977 return -1;
978
979 v = PyDict_GetItem(dict, t);
980 if (!v) {
981 arg = PyDict_Size(dict);
982 v = PyInt_FromLong(arg);
983 if (!v) {
984 Py_DECREF(t);
985 return -1;
986 }
987 if (PyDict_SetItem(dict, t, v) < 0) {
988 Py_DECREF(t);
989 Py_DECREF(v);
990 return -1;
991 }
992 Py_DECREF(v);
993 }
994 else
995 arg = PyInt_AsLong(v);
996 Py_DECREF(t);
997 return arg;
998 }
999
1000 static int
1001 compiler_addop_o(struct compiler *c, int opcode, PyObject *dict,
1002 PyObject *o)
1003 {
1004 int arg = compiler_add_o(c, dict, o);
1005 if (arg < 0)
1006 return 0;
1007 return compiler_addop_i(c, opcode, arg);
1008 }
1009
1010 static int
1011 compiler_addop_name(struct compiler *c, int opcode, PyObject *dict,
1012 PyObject *o)
1013 {
1014 int arg;
1015 PyObject *mangled = _Py_Mangle(c->u->u_private, o);
1016 if (!mangled)
1017 return 0;
1018 arg = compiler_add_o(c, dict, mangled);
1019 Py_DECREF(mangled);
1020 if (arg < 0)
1021 return 0;
1022 return compiler_addop_i(c, opcode, arg);
1023 }
1024
1025 /* Add an opcode with an integer argument.
1026 Returns 0 on failure, 1 on success.
1027 */
1028
1029 static int
1030 compiler_addop_i(struct compiler *c, int opcode, int oparg)
1031 {
1032 struct instr *i;
1033 int off;
1034 off = compiler_next_instr(c, c->u->u_curblock);
1035 if (off < 0)
1036 return 0;
1037 i = &c->u->u_curblock->b_instr[off];
1038 i->i_opcode = opcode;
1039 i->i_oparg = oparg;
1040 i->i_hasarg = 1;
1041 compiler_set_lineno(c, off);
1042 return 1;
1043 }
1044
1045 static int
1046 compiler_addop_j(struct compiler *c, int opcode, basicblock *b, int absolute)
1047 {
1048 struct instr *i;
1049 int off;
1050
1051 assert(b != NULL);
1052 off = compiler_next_instr(c, c->u->u_curblock);
1053 if (off < 0)
1054 return 0;
1055 i = &c->u->u_curblock->b_instr[off];
1056 i->i_opcode = opcode;
1057 i->i_target = b;
1058 i->i_hasarg = 1;
1059 if (absolute)
1060 i->i_jabs = 1;
1061 else
1062 i->i_jrel = 1;
1063 compiler_set_lineno(c, off);
1064 return 1;
1065 }
1066
1067 /* The distinction between NEW_BLOCK and NEXT_BLOCK is subtle. (I'd
1068 like to find better names.) NEW_BLOCK() creates a new block and sets
1069 it as the current block. NEXT_BLOCK() also creates an implicit jump
1070 from the current block to the new block.
1071 */
1072
1073 /* The returns inside these macros make it impossible to decref objects
1074 created in the local function. Local objects should use the arena.
1075 */
1076
1077
1078 #define NEW_BLOCK(C) { \
1079 if (compiler_use_new_block((C)) == NULL) \
1080 return 0; \
1081 }
1082
1083 #define NEXT_BLOCK(C) { \
1084 if (compiler_next_block((C)) == NULL) \
1085 return 0; \
1086 }
1087
1088 #define ADDOP(C, OP) { \
1089 if (!compiler_addop((C), (OP))) \
1090 return 0; \
1091 }
1092
1093 #define ADDOP_IN_SCOPE(C, OP) { \
1094 if (!compiler_addop((C), (OP))) { \
1095 compiler_exit_scope(c); \
1096 return 0; \
1097 } \
1098 }
1099
1100 #define ADDOP_O(C, OP, O, TYPE) { \
1101 if (!compiler_addop_o((C), (OP), (C)->u->u_ ## TYPE, (O))) \
1102 return 0; \
1103 }
1104
1105 #define ADDOP_NAME(C, OP, O, TYPE) { \
1106 if (!compiler_addop_name((C), (OP), (C)->u->u_ ## TYPE, (O))) \
1107 return 0; \
1108 }
1109
1110 #define ADDOP_I(C, OP, O) { \
1111 if (!compiler_addop_i((C), (OP), (O))) \
1112 return 0; \
1113 }
1114
1115 #define ADDOP_JABS(C, OP, O) { \
1116 if (!compiler_addop_j((C), (OP), (O), 1)) \
1117 return 0; \
1118 }
1119
1120 #define ADDOP_JREL(C, OP, O) { \
1121 if (!compiler_addop_j((C), (OP), (O), 0)) \
1122 return 0; \
1123 }
1124
1125 /* VISIT and VISIT_SEQ takes an ASDL type as their second argument. They use
1126 the ASDL name to synthesize the name of the C type and the visit function.
1127 */
1128
1129 #define VISIT(C, TYPE, V) {\
1130 if (!compiler_visit_ ## TYPE((C), (V))) \
1131 return 0; \
1132 }
1133
1134 #define VISIT_IN_SCOPE(C, TYPE, V) {\
1135 if (!compiler_visit_ ## TYPE((C), (V))) { \
1136 compiler_exit_scope(c); \
1137 return 0; \
1138 } \
1139 }
1140
1141 #define VISIT_SLICE(C, V, CTX) {\
1142 if (!compiler_visit_slice((C), (V), (CTX))) \
1143 return 0; \
1144 }
1145
1146 #define VISIT_SEQ(C, TYPE, SEQ) { \
1147 int _i; \
1148 asdl_seq *seq = (SEQ); /* avoid variable capture */ \
1149 for (_i = 0; _i < asdl_seq_LEN(seq); _i++) { \
1150 TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, _i); \
1151 if (!compiler_visit_ ## TYPE((C), elt)) \
1152 return 0; \
1153 } \
1154 }
1155
1156 #define VISIT_SEQ_IN_SCOPE(C, TYPE, SEQ) { \
1157 int _i; \
1158 asdl_seq *seq = (SEQ); /* avoid variable capture */ \
1159 for (_i = 0; _i < asdl_seq_LEN(seq); _i++) { \
1160 TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, _i); \
1161 if (!compiler_visit_ ## TYPE((C), elt)) { \
1162 compiler_exit_scope(c); \
1163 return 0; \
1164 } \
1165 } \
1166 }
1167
1168 static int
1169 compiler_isdocstring(stmt_ty s)
1170 {
1171 if (s->kind != Expr_kind)
1172 return 0;
1173 return s->v.Expr.value->kind == Str_kind;
1174 }
1175
1176 /* Compile a sequence of statements, checking for a docstring. */
1177
1178 static int
1179 compiler_body(struct compiler *c, asdl_seq *stmts)
1180 {
1181 int i = 0;
1182 stmt_ty st;
1183
1184 if (!asdl_seq_LEN(stmts))
1185 return 1;
1186 st = (stmt_ty)asdl_seq_GET(stmts, 0);
1187 if (compiler_isdocstring(st) && Py_OptimizeFlag < 2) {
1188 /* don't generate docstrings if -OO */
1189 i = 1;
1190 VISIT(c, expr, st->v.Expr.value);
1191 if (!compiler_nameop(c, __doc__, Store))
1192 return 0;
1193 }
1194 for (; i < asdl_seq_LEN(stmts); i++)
1195 VISIT(c, stmt, (stmt_ty)asdl_seq_GET(stmts, i));
1196 return 1;
1197 }
1198
1199 static PyCodeObject *
1200 compiler_mod(struct compiler *c, mod_ty mod)
1201 {
1202 PyCodeObject *co;
1203 int addNone = 1;
1204 static PyObject *module;
1205 if (!module) {
1206 module = PyString_InternFromString("<module>");
1207 if (!module)
1208 return NULL;
1209 }
1210 /* Use 0 for firstlineno initially, will fixup in assemble(). */
1211 if (!compiler_enter_scope(c, module, mod, 0))
1212 return NULL;
1213 switch (mod->kind) {
1214 case Module_kind:
1215 if (!compiler_body(c, mod->v.Module.body)) {
1216 compiler_exit_scope(c);
1217 return 0;
1218 }
1219 break;
1220 case Interactive_kind:
1221 c->c_interactive = 1;
1222 VISIT_SEQ_IN_SCOPE(c, stmt,
1223 mod->v.Interactive.body);
1224 break;
1225 case Expression_kind:
1226 VISIT_IN_SCOPE(c, expr, mod->v.Expression.body);
1227 addNone = 0;
1228 break;
1229 case Suite_kind:
1230 PyErr_SetString(PyExc_SystemError,
1231 "suite should not be possible");
1232 return 0;
1233 default:
1234 PyErr_Format(PyExc_SystemError,
1235 "module kind %d should not be possible",
1236 mod->kind);
1237 return 0;
1238 }
1239 co = assemble(c, addNone);
1240 compiler_exit_scope(c);
1241 return co;
1242 }
1243
1244 /* The test for LOCAL must come before the test for FREE in order to
1245 handle classes where name is both local and free. The local var is
1246 a method and the free var is a free var referenced within a method.
1247 */
1248
1249 static int
1250 get_ref_type(struct compiler *c, PyObject *name)
1251 {
1252 int scope = PyST_GetScope(c->u->u_ste, name);
1253 if (scope == 0) {
1254 char buf[350];
1255 PyOS_snprintf(buf, sizeof(buf),
1256 "unknown scope for %.100s in %.100s(%s) in %s\n"
1257 "symbols: %s\nlocals: %s\nglobals: %s\n",
1258 PyString_AS_STRING(name),
1259 PyString_AS_STRING(c->u->u_name),
1260 PyObject_REPR(c->u->u_ste->ste_id),
1261 c->c_filename,
1262 PyObject_REPR(c->u->u_ste->ste_symbols),
1263 PyObject_REPR(c->u->u_varnames),
1264 PyObject_REPR(c->u->u_names)
1265 );
1266 Py_FatalError(buf);
1267 }
1268
1269 return scope;
1270 }
1271
1272 static int
1273 compiler_lookup_arg(PyObject *dict, PyObject *name)
1274 {
1275 PyObject *k, *v;
1276 k = PyTuple_Pack(2, name, name->ob_type);
1277 if (k == NULL)
1278 return -1;
1279 v = PyDict_GetItem(dict, k);
1280 Py_DECREF(k);
1281 if (v == NULL)
1282 return -1;
1283 return PyInt_AS_LONG(v);
1284 }
1285
1286 static int
1287 compiler_make_closure(struct compiler *c, PyCodeObject *co, int args)
1288 {
1289 int i, free = PyCode_GetNumFree(co);
1290 if (free == 0) {
1291 ADDOP_O(c, LOAD_CONST, (PyObject*)co, consts);
1292 ADDOP_I(c, MAKE_FUNCTION, args);
1293 return 1;
1294 }
1295 for (i = 0; i < free; ++i) {
1296 /* Bypass com_addop_varname because it will generate
1297 LOAD_DEREF but LOAD_CLOSURE is needed.
1298 */
1299 PyObject *name = PyTuple_GET_ITEM(co->co_freevars, i);
1300 int arg, reftype;
1301
1302 /* Special case: If a class contains a method with a
1303 free variable that has the same name as a method,
1304 the name will be considered free *and* local in the
1305 class. It should be handled by the closure, as
1306 well as by the normal name loookup logic.
1307 */
1308 reftype = get_ref_type(c, name);
1309 if (reftype == CELL)
1310 arg = compiler_lookup_arg(c->u->u_cellvars, name);
1311 else /* (reftype == FREE) */
1312 arg = compiler_lookup_arg(c->u->u_freevars, name);
1313 if (arg == -1) {
1314 printf("lookup %s in %s %d %d\n"
1315 "freevars of %s: %s\n",
1316 PyObject_REPR(name),
1317 PyString_AS_STRING(c->u->u_name),
1318 reftype, arg,
1319 PyString_AS_STRING(co->co_name),
1320 PyObject_REPR(co->co_freevars));
1321 Py_FatalError("compiler_make_closure()");
1322 }
1323 ADDOP_I(c, LOAD_CLOSURE, arg);
1324 }
1325 ADDOP_I(c, BUILD_TUPLE, free);
1326 ADDOP_O(c, LOAD_CONST, (PyObject*)co, consts);
1327 ADDOP_I(c, MAKE_CLOSURE, args);
1328 return 1;
1329 }
1330
1331 static int
1332 compiler_decorators(struct compiler *c, asdl_seq* decos)
1333 {
1334 int i;
1335
1336 if (!decos)
1337 return 1;
1338
1339 for (i = 0; i < asdl_seq_LEN(decos); i++) {
1340 VISIT(c, expr, (expr_ty)asdl_seq_GET(decos, i));
1341 }
1342 return 1;
1343 }
1344
1345 static int
1346 compiler_arguments(struct compiler *c, arguments_ty args)
1347 {
1348 int i;
1349 int n = asdl_seq_LEN(args->args);
1350 /* Correctly handle nested argument lists */
1351 for (i = 0; i < n; i++) {
1352 expr_ty arg = (expr_ty)asdl_seq_GET(args->args, i);
1353 if (arg->kind == Tuple_kind) {
1354 PyObject *id = PyString_FromFormat(".%d", i);
1355 if (id == NULL) {
1356 return 0;
1357 }
1358 if (!compiler_nameop(c, id, Load)) {
1359 Py_DECREF(id);
1360 return 0;
1361 }
1362 Py_DECREF(id);
1363 VISIT(c, expr, arg);
1364 }
1365 }
1366 return 1;
1367 }
1368
1369 static int
1370 compiler_function(struct compiler *c, stmt_ty s)
1371 {
1372 PyCodeObject *co;
1373 PyObject *first_const = Py_None;
1374 arguments_ty args = s->v.FunctionDef.args;
1375 asdl_seq* decos = s->v.FunctionDef.decorator_list;
1376 stmt_ty st;
1377 int i, n, docstring;
1378
1379 assert(s->kind == FunctionDef_kind);
1380
1381 if (!compiler_decorators(c, decos))
1382 return 0;
1383 if (args->defaults)
1384 VISIT_SEQ(c, expr, args->defaults);
1385 if (!compiler_enter_scope(c, s->v.FunctionDef.name, (void *)s,
1386 s->lineno))
1387 return 0;
1388
1389 st = (stmt_ty)asdl_seq_GET(s->v.FunctionDef.body, 0);
1390 docstring = compiler_isdocstring(st);
1391 if (docstring && Py_OptimizeFlag < 2)
1392 first_const = st->v.Expr.value->v.Str.s;
1393 if (compiler_add_o(c, c->u->u_consts, first_const) < 0) {
1394 compiler_exit_scope(c);
1395 return 0;
1396 }
1397
1398 /* unpack nested arguments */
1399 compiler_arguments(c, args);
1400
1401 c->u->u_argcount = asdl_seq_LEN(args->args);
1402 n = asdl_seq_LEN(s->v.FunctionDef.body);
1403 /* if there was a docstring, we need to skip the first statement */
1404 for (i = docstring; i < n; i++) {
1405 st = (stmt_ty)asdl_seq_GET(s->v.FunctionDef.body, i);
1406 VISIT_IN_SCOPE(c, stmt, st);
1407 }
1408 co = assemble(c, 1);
1409 compiler_exit_scope(c);
1410 if (co == NULL)
1411 return 0;
1412
1413 compiler_make_closure(c, co, asdl_seq_LEN(args->defaults));
1414 Py_DECREF(co);
1415
1416 for (i = 0; i < asdl_seq_LEN(decos); i++) {
1417 ADDOP_I(c, CALL_FUNCTION, 1);
1418 }
1419
1420 return compiler_nameop(c, s->v.FunctionDef.name, Store);
1421 }
1422
1423 static int
1424 compiler_class(struct compiler *c, stmt_ty s)
1425 {
1426 int n, i;
1427 PyCodeObject *co;
1428 PyObject *str;
1429 asdl_seq* decos = s->v.ClassDef.decorator_list;
1430
1431 if (!compiler_decorators(c, decos))
1432 return 0;
1433
1434 /* push class name on stack, needed by BUILD_CLASS */
1435 ADDOP_O(c, LOAD_CONST, s->v.ClassDef.name, consts);
1436 /* push the tuple of base classes on the stack */
1437 n = asdl_seq_LEN(s->v.ClassDef.bases);
1438 if (n > 0)
1439 VISIT_SEQ(c, expr, s->v.ClassDef.bases);
1440 ADDOP_I(c, BUILD_TUPLE, n);
1441 if (!compiler_enter_scope(c, s->v.ClassDef.name, (void *)s,
1442 s->lineno))
1443 return 0;
1444 Py_XDECREF(c->u->u_private);
1445 c->u->u_private = s->v.ClassDef.name;
1446 Py_INCREF(c->u->u_private);
1447 str = PyString_InternFromString("__name__");
1448 if (!str || !compiler_nameop(c, str, Load)) {
1449 Py_XDECREF(str);
1450 compiler_exit_scope(c);
1451 return 0;
1452 }
1453
1454 Py_DECREF(str);
1455 str = PyString_InternFromString("__module__");
1456 if (!str || !compiler_nameop(c, str, Store)) {
1457 Py_XDECREF(str);
1458 compiler_exit_scope(c);
1459 return 0;
1460 }
1461 Py_DECREF(str);
1462
1463 if (!compiler_body(c, s->v.ClassDef.body)) {
1464 compiler_exit_scope(c);
1465 return 0;
1466 }
1467
1468 ADDOP_IN_SCOPE(c, LOAD_LOCALS);
1469 ADDOP_IN_SCOPE(c, RETURN_VALUE);
1470 co = assemble(c, 1);
1471 compiler_exit_scope(c);
1472 if (co == NULL)
1473 return 0;
1474
1475 compiler_make_closure(c, co, 0);
1476 Py_DECREF(co);
1477
1478 ADDOP_I(c, CALL_FUNCTION, 0);
1479 ADDOP(c, BUILD_CLASS);
1480 /* apply decorators */
1481 for (i = 0; i < asdl_seq_LEN(decos); i++) {
1482 ADDOP_I(c, CALL_FUNCTION, 1);
1483 }
1484 if (!compiler_nameop(c, s->v.ClassDef.name, Store))
1485 return 0;
1486 return 1;
1487 }
1488
1489 static int
1490 compiler_ifexp(struct compiler *c, expr_ty e)
1491 {
1492 basicblock *end, *next;
1493
1494 assert(e->kind == IfExp_kind);
1495 end = compiler_new_block(c);
1496 if (end == NULL)
1497 return 0;
1498 next = compiler_new_block(c);
1499 if (next == NULL)
1500 return 0;
1501 VISIT(c, expr, e->v.IfExp.test);
1502 ADDOP_JREL(c, JUMP_IF_FALSE, next);
1503 ADDOP(c, POP_TOP);
1504 VISIT(c, expr, e->v.IfExp.body);
1505 ADDOP_JREL(c, JUMP_FORWARD, end);
1506 compiler_use_next_block(c, next);
1507 ADDOP(c, POP_TOP);
1508 VISIT(c, expr, e->v.IfExp.orelse);
1509 compiler_use_next_block(c, end);
1510 return 1;
1511 }
1512
1513 static int
1514 compiler_lambda(struct compiler *c, expr_ty e)
1515 {
1516 PyCodeObject *co;
1517 static identifier name;
1518 arguments_ty args = e->v.Lambda.args;
1519 assert(e->kind == Lambda_kind);
1520
1521 if (!name) {
1522 name = PyString_InternFromString("<lambda>");
1523 if (!name)
1524 return 0;
1525 }
1526
1527 if (args->defaults)
1528 VISIT_SEQ(c, expr, args->defaults);
1529 if (!compiler_enter_scope(c, name, (void *)e, e->lineno))
1530 return 0;
1531
1532 /* unpack nested arguments */
1533 compiler_arguments(c, args);
1534
1535 c->u->u_argcount = asdl_seq_LEN(args->args);
1536 VISIT_IN_SCOPE(c, expr, e->v.Lambda.body);
1537 ADDOP_IN_SCOPE(c, RETURN_VALUE);
1538 co = assemble(c, 1);
1539 compiler_exit_scope(c);
1540 if (co == NULL)
1541 return 0;
1542
1543 compiler_make_closure(c, co, asdl_seq_LEN(args->defaults));
1544 Py_DECREF(co);
1545
1546 return 1;
1547 }
1548
1549 static int
1550 compiler_print(struct compiler *c, stmt_ty s)
1551 {
1552 int i, n;
1553 bool dest;
1554
1555 assert(s->kind == Print_kind);
1556 n = asdl_seq_LEN(s->v.Print.values);
1557 dest = false;
1558 if (s->v.Print.dest) {
1559 VISIT(c, expr, s->v.Print.dest);
1560 dest = true;
1561 }
1562 for (i = 0; i < n; i++) {
1563 expr_ty e = (expr_ty)asdl_seq_GET(s->v.Print.values, i);
1564 if (dest) {
1565 ADDOP(c, DUP_TOP);
1566 VISIT(c, expr, e);
1567 ADDOP(c, ROT_TWO);
1568 ADDOP(c, PRINT_ITEM_TO);
1569 }
1570 else {
1571 VISIT(c, expr, e);
1572 ADDOP(c, PRINT_ITEM);
1573 }
1574 }
1575 if (s->v.Print.nl) {
1576 if (dest)
1577 ADDOP(c, PRINT_NEWLINE_TO)
1578 else
1579 ADDOP(c, PRINT_NEWLINE)
1580 }
1581 else if (dest)
1582 ADDOP(c, POP_TOP);
1583 return 1;
1584 }
1585
1586 static int
1587 compiler_if(struct compiler *c, stmt_ty s)
1588 {
1589 basicblock *end, *next;
1590 int constant;
1591 assert(s->kind == If_kind);
1592 end = compiler_new_block(c);
1593 if (end == NULL)
1594 return 0;
1595 next = compiler_new_block(c);
1596 if (next == NULL)
1597 return 0;
1598
1599 constant = expr_constant(s->v.If.test);
1600 /* constant = 0: "if 0"
1601 * constant = 1: "if 1", "if 2", ...
1602 * constant = -1: rest */
1603 if (constant == 0) {
1604 if (s->v.If.orelse)
1605 VISIT_SEQ(c, stmt, s->v.If.orelse);
1606 } else if (constant == 1) {
1607 VISIT_SEQ(c, stmt, s->v.If.body);
1608 } else {
1609 VISIT(c, expr, s->v.If.test);
1610 ADDOP_JREL(c, JUMP_IF_FALSE, next);
1611 ADDOP(c, POP_TOP);
1612 VISIT_SEQ(c, stmt, s->v.If.body);
1613 ADDOP_JREL(c, JUMP_FORWARD, end);
1614 compiler_use_next_block(c, next);
1615 ADDOP(c, POP_TOP);
1616 if (s->v.If.orelse)
1617 VISIT_SEQ(c, stmt, s->v.If.orelse);
1618 }
1619 compiler_use_next_block(c, end);
1620 return 1;
1621 }
1622
1623 static int
1624 compiler_for(struct compiler *c, stmt_ty s)
1625 {
1626 basicblock *start, *cleanup, *end;
1627
1628 start = compiler_new_block(c);
1629 cleanup = compiler_new_block(c);
1630 end = compiler_new_block(c);
1631 if (start == NULL || end == NULL || cleanup == NULL)
1632 return 0;
1633 ADDOP_JREL(c, SETUP_LOOP, end);
1634 if (!compiler_push_fblock(c, LOOP, start))
1635 return 0;
1636 VISIT(c, expr, s->v.For.iter);
1637 ADDOP(c, GET_ITER);
1638 compiler_use_next_block(c, start);
1639 /* for expressions must be traced on each iteration,
1640 so we need to set an extra line number. */
1641 c->u->u_lineno_set = false;
1642 ADDOP_JREL(c, FOR_ITER, cleanup);
1643 VISIT(c, expr, s->v.For.target);
1644 VISIT_SEQ(c, stmt, s->v.For.body);
1645 ADDOP_JABS(c, JUMP_ABSOLUTE, start);
1646 compiler_use_next_block(c, cleanup);
1647 ADDOP(c, POP_BLOCK);
1648 compiler_pop_fblock(c, LOOP, start);
1649 VISIT_SEQ(c, stmt, s->v.For.orelse);
1650 compiler_use_next_block(c, end);
1651 return 1;
1652 }
1653
1654 static int
1655 compiler_while(struct compiler *c, stmt_ty s)
1656 {
1657 basicblock *loop, *orelse, *end, *anchor = NULL;
1658 int constant = expr_constant(s->v.While.test);
1659
1660 if (constant == 0) {
1661 if (s->v.While.orelse)
1662 VISIT_SEQ(c, stmt, s->v.While.orelse);
1663 return 1;
1664 }
1665 loop = compiler_new_block(c);
1666 end = compiler_new_block(c);
1667 if (constant == -1) {
1668 anchor = compiler_new_block(c);
1669 if (anchor == NULL)
1670 return 0;
1671 }
1672 if (loop == NULL || end == NULL)
1673 return 0;
1674 if (s->v.While.orelse) {
1675 orelse = compiler_new_block(c);
1676 if (orelse == NULL)
1677 return 0;
1678 }
1679 else
1680 orelse = NULL;
1681
1682 ADDOP_JREL(c, SETUP_LOOP, end);
1683 compiler_use_next_block(c, loop);
1684 if (!compiler_push_fblock(c, LOOP, loop))
1685 return 0;
1686 if (constant == -1) {
1687 /* while expressions must be traced on each iteration,
1688 so we need to set an extra line number. */
1689 c->u->u_lineno_set = false;
1690 VISIT(c, expr, s->v.While.test);
1691 ADDOP_JREL(c, JUMP_IF_FALSE, anchor);
1692 ADDOP(c, POP_TOP);
1693 }
1694 VISIT_SEQ(c, stmt, s->v.While.body);
1695 ADDOP_JABS(c, JUMP_ABSOLUTE, loop);
1696
1697 /* XXX should the two POP instructions be in a separate block
1698 if there is no else clause ?
1699 */
1700
1701 if (constant == -1) {
1702 compiler_use_next_block(c, anchor);
1703 ADDOP(c, POP_TOP);
1704 ADDOP(c, POP_BLOCK);
1705 }
1706 compiler_pop_fblock(c, LOOP, loop);
1707 if (orelse != NULL) /* what if orelse is just pass? */
1708 VISIT_SEQ(c, stmt, s->v.While.orelse);
1709 compiler_use_next_block(c, end);
1710
1711 return 1;
1712 }
1713
1714 static int
1715 compiler_continue(struct compiler *c)
1716 {
1717 static const char LOOP_ERROR_MSG[] = "'continue' not properly in loop";
1718 static const char IN_FINALLY_ERROR_MSG[] =
1719 "'continue' not supported inside 'finally' clause";
1720 int i;
1721
1722 if (!c->u->u_nfblocks)
1723 return compiler_error(c, LOOP_ERROR_MSG);
1724 i = c->u->u_nfblocks - 1;
1725 switch (c->u->u_fblock[i].fb_type) {
1726 case LOOP:
1727 ADDOP_JABS(c, JUMP_ABSOLUTE, c->u->u_fblock[i].fb_block);
1728 break;
1729 case EXCEPT:
1730 case FINALLY_TRY:
1731 while (--i >= 0 && c->u->u_fblock[i].fb_type != LOOP) {
1732 /* Prevent continue anywhere under a finally
1733 even if hidden in a sub-try or except. */
1734 if (c->u->u_fblock[i].fb_type == FINALLY_END)
1735 return compiler_error(c, IN_FINALLY_ERROR_MSG);
1736 }
1737 if (i == -1)
1738 return compiler_error(c, LOOP_ERROR_MSG);
1739 ADDOP_JABS(c, CONTINUE_LOOP, c->u->u_fblock[i].fb_block);
1740 break;
1741 case FINALLY_END:
1742 return compiler_error(c, IN_FINALLY_ERROR_MSG);
1743 }
1744
1745 return 1;
1746 }
1747
1748 /* Code generated for "try: <body> finally: <finalbody>" is as follows:
1749
1750 SETUP_FINALLY L
1751 <code for body>
1752 POP_BLOCK
1753 LOAD_CONST <None>
1754 L: <code for finalbody>
1755 END_FINALLY
1756
1757 The special instructions use the block stack. Each block
1758 stack entry contains the instruction that created it (here
1759 SETUP_FINALLY), the level of the value stack at the time the
1760 block stack entry was created, and a label (here L).
1761
1762 SETUP_FINALLY:
1763 Pushes the current value stack level and the label
1764 onto the block stack.
1765 POP_BLOCK:
1766 Pops en entry from the block stack, and pops the value
1767 stack until its level is the same as indicated on the
1768 block stack. (The label is ignored.)
1769 END_FINALLY:
1770 Pops a variable number of entries from the *value* stack
1771 and re-raises the exception they specify. The number of
1772 entries popped depends on the (pseudo) exception type.
1773
1774 The block stack is unwound when an exception is raised:
1775 when a SETUP_FINALLY entry is found, the exception is pushed
1776 onto the value stack (and the exception condition is cleared),
1777 and the interpreter jumps to the label gotten from the block
1778 stack.
1779 */
1780
1781 static int
1782 compiler_try_finally(struct compiler *c, stmt_ty s)
1783 {
1784 basicblock *body, *end;
1785 body = compiler_new_block(c);
1786 end = compiler_new_block(c);
1787 if (body == NULL || end == NULL)
1788 return 0;
1789
1790 ADDOP_JREL(c, SETUP_FINALLY, end);
1791 compiler_use_next_block(c, body);
1792 if (!compiler_push_fblock(c, FINALLY_TRY, body))
1793 return 0;
1794 VISIT_SEQ(c, stmt, s->v.TryFinally.body);
1795 ADDOP(c, POP_BLOCK);
1796 compiler_pop_fblock(c, FINALLY_TRY, body);
1797
1798 ADDOP_O(c, LOAD_CONST, Py_None, consts);
1799 compiler_use_next_block(c, end);
1800 if (!compiler_push_fblock(c, FINALLY_END, end))
1801 return 0;
1802 VISIT_SEQ(c, stmt, s->v.TryFinally.finalbody);
1803 ADDOP(c, END_FINALLY);
1804 compiler_pop_fblock(c, FINALLY_END, end);
1805
1806 return 1;
1807 }
1808
1809 /*
1810 Code generated for "try: S except E1, V1: S1 except E2, V2: S2 ...":
1811 (The contents of the value stack is shown in [], with the top
1812 at the right; 'tb' is trace-back info, 'val' the exception's
1813 associated value, and 'exc' the exception.)
1814
1815 Value stack Label Instruction Argument
1816 [] SETUP_EXCEPT L1
1817 [] <code for S>
1818 [] POP_BLOCK
1819 [] JUMP_FORWARD L0
1820
1821 [tb, val, exc] L1: DUP )
1822 [tb, val, exc, exc] <evaluate E1> )
1823 [tb, val, exc, exc, E1] COMPARE_OP EXC_MATCH ) only if E1
1824 [tb, val, exc, 1-or-0] JUMP_IF_FALSE L2 )
1825 [tb, val, exc, 1] POP )
1826 [tb, val, exc] POP
1827 [tb, val] <assign to V1> (or POP if no V1)
1828 [tb] POP
1829 [] <code for S1>
1830 JUMP_FORWARD L0
1831
1832 [tb, val, exc, 0] L2: POP
1833 [tb, val, exc] DUP
1834 .............................etc.......................
1835
1836 [tb, val, exc, 0] Ln+1: POP
1837 [tb, val, exc] END_FINALLY # re-raise exception
1838
1839 [] L0: <next statement>
1840
1841 Of course, parts are not generated if Vi or Ei is not present.
1842 */
1843 static int
1844 compiler_try_except(struct compiler *c, stmt_ty s)
1845 {
1846 basicblock *body, *orelse, *except, *end;
1847 int i, n;
1848
1849 body = compiler_new_block(c);
1850 except = compiler_new_block(c);
1851 orelse = compiler_new_block(c);
1852 end = compiler_new_block(c);
1853 if (body == NULL || except == NULL || orelse == NULL || end == NULL)
1854 return 0;
1855 ADDOP_JREL(c, SETUP_EXCEPT, except);
1856 compiler_use_next_block(c, body);
1857 if (!compiler_push_fblock(c, EXCEPT, body))
1858 return 0;
1859 VISIT_SEQ(c, stmt, s->v.TryExcept.body);
1860 ADDOP(c, POP_BLOCK);
1861 compiler_pop_fblock(c, EXCEPT, body);
1862 ADDOP_JREL(c, JUMP_FORWARD, orelse);
1863 n = asdl_seq_LEN(s->v.TryExcept.handlers);
1864 compiler_use_next_block(c, except);
1865 for (i = 0; i < n; i++) {
1866 excepthandler_ty handler = (excepthandler_ty)asdl_seq_GET(
1867 s->v.TryExcept.handlers, i);
1868 if (!handler->v.ExceptHandler.type && i < n-1)
1869 return compiler_error(c, "default 'except:' must be last");
1870 c->u->u_lineno_set = false;
1871 c->u->u_lineno = handler->lineno;
1872 except = compiler_new_block(c);
1873 if (except == NULL)
1874 return 0;
1875 if (handler->v.ExceptHandler.type) {
1876 ADDOP(c, DUP_TOP);
1877 VISIT(c, expr, handler->v.ExceptHandler.type);
1878 ADDOP_I(c, COMPARE_OP, PyCmp_EXC_MATCH);
1879 ADDOP_JREL(c, JUMP_IF_FALSE, except);
1880 ADDOP(c, POP_TOP);
1881 }
1882 ADDOP(c, POP_TOP);
1883 if (handler->v.ExceptHandler.name) {
1884 VISIT(c, expr, handler->v.ExceptHandler.name);
1885 }
1886 else {
1887 ADDOP(c, POP_TOP);
1888 }
1889 ADDOP(c, POP_TOP);
1890 VISIT_SEQ(c, stmt, handler->v.ExceptHandler.body);
1891 ADDOP_JREL(c, JUMP_FORWARD, end);
1892 compiler_use_next_block(c, except);
1893 if (handler->v.ExceptHandler.type)
1894 ADDOP(c, POP_TOP);
1895 }
1896 ADDOP(c, END_FINALLY);
1897 compiler_use_next_block(c, orelse);
1898 VISIT_SEQ(c, stmt, s->v.TryExcept.orelse);
1899 compiler_use_next_block(c, end);
1900 return 1;
1901 }
1902
1903 static int
1904 compiler_import_as(struct compiler *c, identifier name, identifier asname)
1905 {
1906 /* The IMPORT_NAME opcode was already generated. This function
1907 merely needs to bind the result to a name.
1908
1909 If there is a dot in name, we need to split it and emit a
1910 LOAD_ATTR for each name.
1911 */
1912 const char *src = PyString_AS_STRING(name);
1913 const char *dot = strchr(src, '.');
1914 if (dot) {
1915 /* Consume the base module name to get the first attribute */
1916 src = dot + 1;
1917 while (dot) {
1918 /* NB src is only defined when dot != NULL */
1919 PyObject *attr;
1920 dot = strchr(src, '.');
1921 attr = PyString_FromStringAndSize(src,
1922 dot ? dot - src : strlen(src));
1923 if (!attr)
1924 return -1;
1925 ADDOP_O(c, LOAD_ATTR, attr, names);
1926 Py_DECREF(attr);
1927 src = dot + 1;
1928 }
1929 }
1930 return compiler_nameop(c, asname, Store);
1931 }
1932
1933 static int
1934 compiler_import(struct compiler *c, stmt_ty s)
1935 {
1936 /* The Import node stores a module name like a.b.c as a single
1937 string. This is convenient for all cases except
1938 import a.b.c as d
1939 where we need to parse that string to extract the individual
1940 module names.
1941 XXX Perhaps change the representation to make this case simpler?
1942 */
1943 int i, n = asdl_seq_LEN(s->v.Import.names);
1944
1945 for (i = 0; i < n; i++) {
1946 alias_ty alias = (alias_ty)asdl_seq_GET(s->v.Import.names, i);
1947 int r;
1948 PyObject *level;
1949
1950 if (c->c_flags && (c->c_flags->cf_flags & CO_FUTURE_ABSOLUTE_IMPORT))
1951 level = PyInt_FromLong(0);
1952 else
1953 level = PyInt_FromLong(-1);
1954
1955 if (level == NULL)
1956 return 0;
1957
1958 ADDOP_O(c, LOAD_CONST, level, consts);
1959 Py_DECREF(level);
1960 ADDOP_O(c, LOAD_CONST, Py_None, consts);
1961 ADDOP_NAME(c, IMPORT_NAME, alias->name, names);
1962
1963 if (alias->asname) {
1964 r = compiler_import_as(c, alias->name, alias->asname);
1965 if (!r)
1966 return r;
1967 }
1968 else {
1969 identifier tmp = alias->name;
1970 const char *base = PyString_AS_STRING(alias->name);
1971 char *dot = strchr(base, '.');
1972 if (dot)
1973 tmp = PyString_FromStringAndSize(base,
1974 dot - base);
1975 r = compiler_nameop(c, tmp, Store);
1976 if (dot) {
1977 Py_DECREF(tmp);
1978 }
1979 if (!r)
1980 return r;
1981 }
1982 }
1983 return 1;
1984 }
1985
1986 static int
1987 compiler_from_import(struct compiler *c, stmt_ty s)
1988 {
1989 int i, n = asdl_seq_LEN(s->v.ImportFrom.names);
1990
1991 PyObject *names = PyTuple_New(n);
1992 PyObject *level;
1993
1994 if (!names)
1995 return 0;
1996
1997 if (s->v.ImportFrom.level == 0 && c->c_flags &&
1998 !(c->c_flags->cf_flags & CO_FUTURE_ABSOLUTE_IMPORT))
1999 level = PyInt_FromLong(-1);
2000 else
2001 level = PyInt_FromLong(s->v.ImportFrom.level);
2002
2003 if (!level) {
2004 Py_DECREF(names);
2005 return 0;
2006 }
2007
2008 /* build up the names */
2009 for (i = 0; i < n; i++) {
2010 alias_ty alias = (alias_ty)asdl_seq_GET(s->v.ImportFrom.names, i);
2011 Py_INCREF(alias->name);
2012 PyTuple_SET_ITEM(names, i, alias->name);
2013 }
2014
2015 if (s->lineno > c->c_future->ff_lineno) {
2016 if (!strcmp(PyString_AS_STRING(s->v.ImportFrom.module),
2017 "__future__")) {
2018 Py_DECREF(level);
2019 Py_DECREF(names);
2020 return compiler_error(c,
2021 "from __future__ imports must occur "
2022 "at the beginning of the file");
2023
2024 }
2025 }
2026
2027 ADDOP_O(c, LOAD_CONST, level, consts);
2028 Py_DECREF(level);
2029 ADDOP_O(c, LOAD_CONST, names, consts);
2030 Py_DECREF(names);
2031 ADDOP_NAME(c, IMPORT_NAME, s->v.ImportFrom.module, names);
2032 for (i = 0; i < n; i++) {
2033 alias_ty alias = (alias_ty)asdl_seq_GET(s->v.ImportFrom.names, i);
2034 identifier store_name;
2035
2036 if (i == 0 && *PyString_AS_STRING(alias->name) == '*') {
2037 assert(n == 1);
2038 ADDOP(c, IMPORT_STAR);
2039 return 1;
2040 }
2041
2042 ADDOP_NAME(c, IMPORT_FROM, alias->name, names);
2043 store_name = alias->name;
2044 if (alias->asname)
2045 store_name = alias->asname;
2046
2047 if (!compiler_nameop(c, store_name, Store)) {
2048 Py_DECREF(names);
2049 return 0;
2050 }
2051 }
2052 /* remove imported module */
2053 ADDOP(c, POP_TOP);
2054 return 1;
2055 }
2056
2057 static int
2058 compiler_assert(struct compiler *c, stmt_ty s)
2059 {
2060 static PyObject *assertion_error = NULL;
2061 basicblock *end;
2062
2063 if (Py_OptimizeFlag)
2064 return 1;
2065 if (assertion_error == NULL) {
2066 assertion_error = PyString_InternFromString("AssertionError");
2067 if (assertion_error == NULL)
2068 return 0;
2069 }
2070 if (s->v.Assert.test->kind == Tuple_kind &&
2071 asdl_seq_LEN(s->v.Assert.test->v.Tuple.elts) > 0) {
2072 const char* msg =
2073 "assertion is always true, perhaps remove parentheses?";
2074 if (PyErr_WarnExplicit(PyExc_SyntaxWarning, msg, c->c_filename,
2075 c->u->u_lineno, NULL, NULL) == -1)
2076 return 0;
2077 }
2078 VISIT(c, expr, s->v.Assert.test);
2079 end = compiler_new_block(c);
2080 if (end == NULL)
2081 return 0;
2082 ADDOP_JREL(c, JUMP_IF_TRUE, end);
2083 ADDOP(c, POP_TOP);
2084 ADDOP_O(c, LOAD_GLOBAL, assertion_error, names);
2085 if (s->v.Assert.msg) {
2086 VISIT(c, expr, s->v.Assert.msg);
2087 ADDOP_I(c, RAISE_VARARGS, 2);
2088 }
2089 else {
2090 ADDOP_I(c, RAISE_VARARGS, 1);
2091 }
2092 compiler_use_next_block(c, end);
2093 ADDOP(c, POP_TOP);
2094 return 1;
2095 }
2096
2097 static int
2098 compiler_visit_stmt(struct compiler *c, stmt_ty s)
2099 {
2100 int i, n;
2101
2102 /* Always assign a lineno to the next instruction for a stmt. */
2103 c->u->u_lineno = s->lineno;
2104 c->u->u_lineno_set = false;
2105
2106 switch (s->kind) {
2107 case FunctionDef_kind:
2108 return compiler_function(c, s);
2109 case ClassDef_kind:
2110 return compiler_class(c, s);
2111 case Return_kind:
2112 if (c->u->u_ste->ste_type != FunctionBlock)
2113 return compiler_error(c, "'return' outside function");
2114 if (s->v.Return.value) {
2115 VISIT(c, expr, s->v.Return.value);
2116 }
2117 else
2118 ADDOP_O(c, LOAD_CONST, Py_None, consts);
2119 ADDOP(c, RETURN_VALUE);
2120 break;
2121 case Delete_kind:
2122 VISIT_SEQ(c, expr, s->v.Delete.targets)
2123 break;
2124 case Assign_kind:
2125 n = asdl_seq_LEN(s->v.Assign.targets);
2126 VISIT(c, expr, s->v.Assign.value);
2127 for (i = 0; i < n; i++) {
2128 if (i < n - 1)
2129 ADDOP(c, DUP_TOP);
2130 VISIT(c, expr,
2131 (expr_ty)asdl_seq_GET(s->v.Assign.targets, i));
2132 }
2133 break;
2134 case AugAssign_kind:
2135 return compiler_augassign(c, s);
2136 case Print_kind:
2137 return compiler_print(c, s);
2138 case For_kind:
2139 return compiler_for(c, s);
2140 case While_kind:
2141 return compiler_while(c, s);
2142 case If_kind:
2143 return compiler_if(c, s);
2144 case Raise_kind:
2145 n = 0;
2146 if (s->v.Raise.type) {
2147 VISIT(c, expr, s->v.Raise.type);
2148 n++;
2149 if (s->v.Raise.inst) {
2150 VISIT(c, expr, s->v.Raise.inst);
2151 n++;
2152 if (s->v.Raise.tback) {
2153 VISIT(c, expr, s->v.Raise.tback);
2154 n++;
2155 }
2156 }
2157 }
2158 ADDOP_I(c, RAISE_VARARGS, n);
2159 break;
2160 case TryExcept_kind:
2161 return compiler_try_except(c, s);
2162 case TryFinally_kind:
2163 return compiler_try_finally(c, s);
2164 case Assert_kind:
2165 return compiler_assert(c, s);
2166 case Import_kind:
2167 return compiler_import(c, s);
2168 case ImportFrom_kind:
2169 return compiler_from_import(c, s);
2170 case Exec_kind:
2171 VISIT(c, expr, s->v.Exec.body);
2172 if (s->v.Exec.globals) {
2173 VISIT(c, expr, s->v.Exec.globals);
2174 if (s->v.Exec.locals) {
2175 VISIT(c, expr, s->v.Exec.locals);
2176 } else {
2177 ADDOP(c, DUP_TOP);
2178 }
2179 } else {
2180 ADDOP_O(c, LOAD_CONST, Py_None, consts);
2181 ADDOP(c, DUP_TOP);
2182 }
2183 ADDOP(c, EXEC_STMT);
2184 break;
2185 case Global_kind:
2186 break;
2187 case Expr_kind:
2188 if (c->c_interactive && c->c_nestlevel <= 1) {
2189 VISIT(c, expr, s->v.Expr.value);
2190 ADDOP(c, PRINT_EXPR);
2191 }
2192 else if (s->v.Expr.value->kind != Str_kind &&
2193 s->v.Expr.value->kind != Num_kind) {
2194 VISIT(c, expr, s->v.Expr.value);
2195 ADDOP(c, POP_TOP);
2196 }
2197 break;
2198 case Pass_kind:
2199 break;
2200 case Break_kind:
2201 if (!compiler_in_loop(c))
2202 return compiler_error(c, "'break' outside loop");
2203 ADDOP(c, BREAK_LOOP);
2204 break;
2205 case Continue_kind:
2206 return compiler_continue(c);
2207 case With_kind:
2208 return compiler_with(c, s);
2209 }
2210 return 1;
2211 }
2212
2213 static int
2214 unaryop(unaryop_ty op)
2215 {
2216 switch (op) {
2217 case Invert:
2218 return UNARY_INVERT;
2219 case Not:
2220 return UNARY_NOT;
2221 case UAdd:
2222 return UNARY_POSITIVE;
2223 case USub:
2224 return UNARY_NEGATIVE;
2225 default:
2226 PyErr_Format(PyExc_SystemError,
2227 "unary op %d should not be possible", op);
2228 return 0;
2229 }
2230 }
2231
2232 static int
2233 binop(struct compiler *c, operator_ty op)
2234 {
2235 switch (op) {
2236 case Add:
2237 return BINARY_ADD;
2238 case Sub:
2239 return BINARY_SUBTRACT;
2240 case Mult:
2241 return BINARY_MULTIPLY;
2242 case Div:
2243 if (c->c_flags && c->c_flags->cf_flags & CO_FUTURE_DIVISION)
2244 return BINARY_TRUE_DIVIDE;
2245 else
2246 return BINARY_DIVIDE;
2247 case Mod:
2248 return BINARY_MODULO;
2249 case Pow:
2250 return BINARY_POWER;
2251 case LShift:
2252 return BINARY_LSHIFT;
2253 case RShift:
2254 return BINARY_RSHIFT;
2255 case BitOr:
2256 return BINARY_OR;
2257 case BitXor:
2258 return BINARY_XOR;
2259 case BitAnd:
2260 return BINARY_AND;
2261 case FloorDiv:
2262 return BINARY_FLOOR_DIVIDE;
2263 default:
2264 PyErr_Format(PyExc_SystemError,
2265 "binary op %d should not be possible", op);
2266 return 0;
2267 }
2268 }
2269
2270 static int
2271 cmpop(cmpop_ty op)
2272 {
2273 switch (op) {
2274 case Eq:
2275 return PyCmp_EQ;
2276 case NotEq:
2277 return PyCmp_NE;
2278 case Lt:
2279 return PyCmp_LT;
2280 case LtE:
2281 return PyCmp_LE;
2282 case Gt:
2283 return PyCmp_GT;
2284 case GtE:
2285 return PyCmp_GE;
2286 case Is:
2287 return PyCmp_IS;
2288 case IsNot:
2289 return PyCmp_IS_NOT;
2290 case In:
2291 return PyCmp_IN;
2292 case NotIn:
2293 return PyCmp_NOT_IN;
2294 default:
2295 return PyCmp_BAD;
2296 }
2297 }
2298
2299 static int
2300 inplace_binop(struct compiler *c, operator_ty op)
2301 {
2302 switch (op) {
2303 case Add:
2304 return INPLACE_ADD;
2305 case Sub:
2306 return INPLACE_SUBTRACT;
2307 case Mult:
2308 return INPLACE_MULTIPLY;
2309 case Div:
2310 if (c->c_flags && c->c_flags->cf_flags & CO_FUTURE_DIVISION)
2311 return INPLACE_TRUE_DIVIDE;
2312 else
2313 return INPLACE_DIVIDE;
2314 case Mod:
2315 return INPLACE_MODULO;
2316 case Pow:
2317 return INPLACE_POWER;
2318 case LShift:
2319 return INPLACE_LSHIFT;
2320 case RShift:
2321 return INPLACE_RSHIFT;
2322 case BitOr:
2323 return INPLACE_OR;
2324 case BitXor:
2325 return INPLACE_XOR;
2326 case BitAnd:
2327 return INPLACE_AND;
2328 case FloorDiv:
2329 return INPLACE_FLOOR_DIVIDE;
2330 default:
2331 PyErr_Format(PyExc_SystemError,
2332 "inplace binary op %d should not be possible", op);
2333 return 0;
2334 }
2335 }
2336
2337 static int
2338 compiler_nameop(struct compiler *c, identifier name, expr_context_ty ctx)
2339 {
2340 int op, scope, arg;
2341 enum { OP_FAST, OP_GLOBAL, OP_DEREF, OP_NAME } optype;
2342
2343 PyObject *dict = c->u->u_names;
2344 PyObject *mangled;
2345 /* XXX AugStore isn't used anywhere! */
2346
2347 mangled = _Py_Mangle(c->u->u_private, name);
2348 if (!mangled)
2349 return 0;
2350
2351 op = 0;
2352 optype = OP_NAME;
2353 scope = PyST_GetScope(c->u->u_ste, mangled);
2354 switch (scope) {
2355 case FREE:
2356 dict = c->u->u_freevars;
2357 optype = OP_DEREF;
2358 break;
2359 case CELL:
2360 dict = c->u->u_cellvars;
2361 optype = OP_DEREF;
2362 break;
2363 case LOCAL:
2364 if (c->u->u_ste->ste_type == FunctionBlock)
2365 optype = OP_FAST;
2366 break;
2367 case GLOBAL_IMPLICIT:
2368 if (c->u->u_ste->ste_type == FunctionBlock &&
2369 !c->u->u_ste->ste_unoptimized)
2370 optype = OP_GLOBAL;
2371 break;
2372 case GLOBAL_EXPLICIT:
2373 optype = OP_GLOBAL;
2374 break;
2375 default:
2376 /* scope can be 0 */
2377 break;
2378 }
2379
2380 /* XXX Leave assert here, but handle __doc__ and the like better */
2381 assert(scope || PyString_AS_STRING(name)[0] == '_');
2382
2383 switch (optype) {
2384 case OP_DEREF:
2385 switch (ctx) {
2386 case Load: op = LOAD_DEREF; break;
2387 case Store: op = STORE_DEREF; break;
2388 case AugLoad:
2389 case AugStore:
2390 break;
2391 case Del:
2392 PyErr_Format(PyExc_SyntaxError,
2393 "can not delete variable '%s' referenced "
2394 "in nested scope",
2395 PyString_AS_STRING(name));
2396 Py_DECREF(mangled);
2397 return 0;
2398 case Param:
2399 default:
2400 PyErr_SetString(PyExc_SystemError,
2401 "param invalid for deref variable");
2402 return 0;
2403 }
2404 break;
2405 case OP_FAST:
2406 switch (ctx) {
2407 case Load: op = LOAD_FAST; break;
2408 case Store: op = STORE_FAST; break;
2409 case Del: op = DELETE_FAST; break;
2410 case AugLoad:
2411 case AugStore:
2412 break;
2413 case Param:
2414 default:
2415 PyErr_SetString(PyExc_SystemError,
2416 "param invalid for local variable");
2417 return 0;
2418 }
2419 ADDOP_O(c, op, mangled, varnames);
2420 Py_DECREF(mangled);
2421 return 1;
2422 case OP_GLOBAL:
2423 switch (ctx) {
2424 case Load: op = LOAD_GLOBAL; break;
2425 case Store: op = STORE_GLOBAL; break;
2426 case Del: op = DELETE_GLOBAL; break;
2427 case AugLoad:
2428 case AugStore:
2429 break;
2430 case Param:
2431 default:
2432 PyErr_SetString(PyExc_SystemError,
2433 "param invalid for global variable");
2434 return 0;
2435 }
2436 break;
2437 case OP_NAME:
2438 switch (ctx) {
2439 case Load: op = LOAD_NAME; break;
2440 case Store: op = STORE_NAME; break;
2441 case Del: op = DELETE_NAME; break;
2442 case AugLoad:
2443 case AugStore:
2444 break;
2445 case Param:
2446 default:
2447 PyErr_SetString(PyExc_SystemError,
2448 "param invalid for name variable");
2449 return 0;
2450 }
2451 break;
2452 }
2453
2454 assert(op);
2455 arg = compiler_add_o(c, dict, mangled);
2456 Py_DECREF(mangled);
2457 if (arg < 0)
2458 return 0;
2459 return compiler_addop_i(c, op, arg);
2460 }
2461
2462 static int
2463 compiler_boolop(struct compiler *c, expr_ty e)
2464 {
2465 basicblock *end;
2466 int jumpi, i, n;
2467 asdl_seq *s;
2468
2469 assert(e->kind == BoolOp_kind);
2470 if (e->v.BoolOp.op == And)
2471 jumpi = JUMP_IF_FALSE;
2472 else
2473 jumpi = JUMP_IF_TRUE;
2474 end = compiler_new_block(c);
2475 if (end == NULL)
2476 return 0;
2477 s = e->v.BoolOp.values;
2478 n = asdl_seq_LEN(s) - 1;
2479 assert(n >= 0);
2480 for (i = 0; i < n; ++i) {
2481 VISIT(c, expr, (expr_ty)asdl_seq_GET(s, i));
2482 ADDOP_JREL(c, jumpi, end);
2483 ADDOP(c, POP_TOP)
2484 }
2485 VISIT(c, expr, (expr_ty)asdl_seq_GET(s, n));
2486 compiler_use_next_block(c, end);
2487 return 1;
2488 }
2489
2490 static int
2491 compiler_list(struct compiler *c, expr_ty e)
2492 {
2493 int n = asdl_seq_LEN(e->v.List.elts);
2494 if (e->v.List.ctx == Store) {
2495 ADDOP_I(c, UNPACK_SEQUENCE, n);
2496 }
2497 VISIT_SEQ(c, expr, e->v.List.elts);
2498 if (e->v.List.ctx == Load) {
2499 ADDOP_I(c, BUILD_LIST, n);
2500 }
2501 return 1;
2502 }
2503
2504 static int
2505 compiler_tuple(struct compiler *c, expr_ty e)
2506 {
2507 int n = asdl_seq_LEN(e->v.Tuple.elts);
2508 if (e->v.Tuple.ctx == Store) {
2509 ADDOP_I(c, UNPACK_SEQUENCE, n);
2510 }
2511 VISIT_SEQ(c, expr, e->v.Tuple.elts);
2512 if (e->v.Tuple.ctx == Load) {
2513 ADDOP_I(c, BUILD_TUPLE, n);
2514 }
2515 return 1;
2516 }
2517
2518 static int
2519 compiler_compare(struct compiler *c, expr_ty e)
2520 {
2521 int i, n;
2522 basicblock *cleanup = NULL;
2523
2524 /* XXX the logic can be cleaned up for 1 or multiple comparisons */
2525 VISIT(c, expr, e->v.Compare.left);
2526 n = asdl_seq_LEN(e->v.Compare.ops);
2527 assert(n > 0);
2528 if (n > 1) {
2529 cleanup = compiler_new_block(c);
2530 if (cleanup == NULL)
2531 return 0;
2532 VISIT(c, expr,
2533 (expr_ty)asdl_seq_GET(e->v.Compare.comparators, 0));
2534 }
2535 for (i = 1; i < n; i++) {
2536 ADDOP(c, DUP_TOP);
2537 ADDOP(c, ROT_THREE);
2538 ADDOP_I(c, COMPARE_OP,
2539 cmpop((cmpop_ty)(asdl_seq_GET(
2540 e->v.Compare.ops, i - 1))));
2541 ADDOP_JREL(c, JUMP_IF_FALSE, cleanup);
2542 NEXT_BLOCK(c);
2543 ADDOP(c, POP_TOP);
2544 if (i < (n - 1))
2545 VISIT(c, expr,
2546 (expr_ty)asdl_seq_GET(e->v.Compare.comparators, i));
2547 }
2548 VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Compare.comparators, n - 1));
2549 ADDOP_I(c, COMPARE_OP,
2550 cmpop((cmpop_ty)(asdl_seq_GET(e->v.Compare.ops, n - 1))));
2551 if (n > 1) {
2552 basicblock *end = compiler_new_block(c);
2553 if (end == NULL)
2554 return 0;
2555 ADDOP_JREL(c, JUMP_FORWARD, end);
2556 compiler_use_next_block(c, cleanup);
2557 ADDOP(c, ROT_TWO);
2558 ADDOP(c, POP_TOP);
2559 compiler_use_next_block(c, end);
2560 }
2561 return 1;
2562 }
2563
2564 static int
2565 compiler_call(struct compiler *c, expr_ty e)
2566 {
2567 int n, code = 0;
2568
2569 VISIT(c, expr, e->v.Call.func);
2570 n = asdl_seq_LEN(e->v.Call.args);
2571 VISIT_SEQ(c, expr, e->v.Call.args);
2572 if (e->v.Call.keywords) {
2573 VISIT_SEQ(c, keyword, e->v.Call.keywords);
2574 n |= asdl_seq_LEN(e->v.Call.keywords) << 8;
2575 }
2576 if (e->v.Call.starargs) {
2577 VISIT(c, expr, e->v.Call.starargs);
2578 code |= 1;
2579 }
2580 if (e->v.Call.kwargs) {
2581 VISIT(c, expr, e->v.Call.kwargs);
2582 code |= 2;
2583 }
2584 switch (code) {
2585 case 0:
2586 ADDOP_I(c, CALL_FUNCTION, n);
2587 break;
2588 case 1:
2589 ADDOP_I(c, CALL_FUNCTION_VAR, n);
2590 break;
2591 case 2:
2592 ADDOP_I(c, CALL_FUNCTION_KW, n);
2593 break;
2594 case 3:
2595 ADDOP_I(c, CALL_FUNCTION_VAR_KW, n);
2596 break;
2597 }
2598 return 1;
2599 }
2600
2601 static int
2602 compiler_listcomp_generator(struct compiler *c, asdl_seq *generators,
2603 int gen_index, expr_ty elt)
2604 {
2605 /* generate code for the iterator, then each of the ifs,
2606 and then write to the element */
2607
2608 comprehension_ty l;
2609 basicblock *start, *anchor, *skip, *if_cleanup;
2610 int i, n;
2611
2612 start = compiler_new_block(c);
2613 skip = compiler_new_block(c);
2614 if_cleanup = compiler_new_block(c);
2615 anchor = compiler_new_block(c);
2616
2617 if (start == NULL || skip == NULL || if_cleanup == NULL ||
2618 anchor == NULL)
2619 return 0;
2620
2621 l = (comprehension_ty)asdl_seq_GET(generators, gen_index);
2622 VISIT(c, expr, l->iter);
2623 ADDOP(c, GET_ITER);
2624 compiler_use_next_block(c, start);
2625 ADDOP_JREL(c, FOR_ITER, anchor);
2626 NEXT_BLOCK(c);
2627 VISIT(c, expr, l->target);
2628
2629 /* XXX this needs to be cleaned up...a lot! */
2630 n = asdl_seq_LEN(l->ifs);
2631 for (i = 0; i < n; i++) {
2632 expr_ty e = (expr_ty)asdl_seq_GET(l->ifs, i);
2633 VISIT(c, expr, e);
2634 ADDOP_JREL(c, JUMP_IF_FALSE, if_cleanup);
2635 NEXT_BLOCK(c);
2636 ADDOP(c, POP_TOP);
2637 }
2638
2639 if (++gen_index < asdl_seq_LEN(generators))
2640 if (!compiler_listcomp_generator(c, generators, gen_index, elt))
2641 return 0;
2642
2643 /* only append after the last for generator */
2644 if (gen_index >= asdl_seq_LEN(generators)) {
2645 VISIT(c, expr, elt);
2646 ADDOP_I(c, LIST_APPEND, gen_index+1);
2647
2648 compiler_use_next_block(c, skip);
2649 }
2650 for (i = 0; i < n; i++) {
2651 ADDOP_I(c, JUMP_FORWARD, 1);
2652 if (i == 0)
2653 compiler_use_next_block(c, if_cleanup);
2654 ADDOP(c, POP_TOP);
2655 }
2656 ADDOP_JABS(c, JUMP_ABSOLUTE, start);
2657 compiler_use_next_block(c, anchor);
2658
2659 return 1;
2660 }
2661
2662 static int
2663 compiler_listcomp(struct compiler *c, expr_ty e)
2664 {
2665 assert(e->kind == ListComp_kind);
2666 ADDOP_I(c, BUILD_LIST, 0);
2667 return compiler_listcomp_generator(c, e->v.ListComp.generators, 0,
2668 e->v.ListComp.elt);
2669 }
2670
2671 static int
2672 compiler_genexp_generator(struct compiler *c,
2673 asdl_seq *generators, int gen_index,
2674 expr_ty elt)
2675 {
2676 /* generate code for the iterator, then each of the ifs,
2677 and then write to the element */
2678
2679 comprehension_ty ge;
2680 basicblock *start, *anchor, *skip, *if_cleanup, *end;
2681 int i, n;
2682
2683 start = compiler_new_block(c);
2684 skip = compiler_new_block(c);
2685 if_cleanup = compiler_new_block(c);
2686 anchor = compiler_new_block(c);
2687 end = compiler_new_block(c);
2688
2689 if (start == NULL || skip == NULL || if_cleanup == NULL ||
2690 anchor == NULL || end == NULL)
2691 return 0;
2692
2693 ge = (comprehension_ty)asdl_seq_GET(generators, gen_index);
2694 ADDOP_JREL(c, SETUP_LOOP, end);
2695 if (!compiler_push_fblock(c, LOOP, start))
2696 return 0;
2697
2698 if (gen_index == 0) {
2699 /* Receive outermost iter as an implicit argument */
2700 c->u->u_argcount = 1;
2701 ADDOP_I(c, LOAD_FAST, 0);
2702 }
2703 else {
2704 /* Sub-iter - calculate on the fly */
2705 VISIT(c, expr, ge->iter);
2706 ADDOP(c, GET_ITER);
2707 }
2708 compiler_use_next_block(c, start);
2709 ADDOP_JREL(c, FOR_ITER, anchor);
2710 NEXT_BLOCK(c);
2711 VISIT(c, expr, ge->target);
2712
2713 /* XXX this needs to be cleaned up...a lot! */
2714 n = asdl_seq_LEN(ge->ifs);
2715 for (i = 0; i < n; i++) {
2716 expr_ty e = (expr_ty)asdl_seq_GET(ge->ifs, i);
2717 VISIT(c, expr, e);
2718 ADDOP_JREL(c, JUMP_IF_FALSE, if_cleanup);
2719 NEXT_BLOCK(c);
2720 ADDOP(c, POP_TOP);
2721 }
2722
2723 if (++gen_index < asdl_seq_LEN(generators))
2724 if (!compiler_genexp_generator(c, generators, gen_index, elt))
2725 return 0;
2726
2727 /* only append after the last 'for' generator */
2728 if (gen_index >= asdl_seq_LEN(generators)) {
2729 VISIT(c, expr, elt);
2730 ADDOP(c, YIELD_VALUE);
2731 ADDOP(c, POP_TOP);
2732
2733 compiler_use_next_block(c, skip);
2734 }
2735 for (i = 0; i < n; i++) {
2736 ADDOP_I(c, JUMP_FORWARD, 1);
2737 if (i == 0)
2738 compiler_use_next_block(c, if_cleanup);
2739
2740 ADDOP(c, POP_TOP);
2741 }
2742 ADDOP_JABS(c, JUMP_ABSOLUTE, start);
2743 compiler_use_next_block(c, anchor);
2744 ADDOP(c, POP_BLOCK);
2745 compiler_pop_fblock(c, LOOP, start);
2746 compiler_use_next_block(c, end);
2747
2748 return 1;
2749 }
2750
2751 static int
2752 compiler_genexp(struct compiler *c, expr_ty e)
2753 {
2754 static identifier name;
2755 PyCodeObject *co;
2756 expr_ty outermost_iter = ((comprehension_ty)
2757 (asdl_seq_GET(e->v.GeneratorExp.generators,
2758 0)))->iter;
2759
2760 if (!name) {
2761 name = PyString_FromString("<genexpr>");
2762 if (!name)
2763 return 0;
2764 }
2765
2766 if (!compiler_enter_scope(c, name, (void *)e, e->lineno))
2767 return 0;
2768 compiler_genexp_generator(c, e->v.GeneratorExp.generators, 0,
2769 e->v.GeneratorExp.elt);
2770 co = assemble(c, 1);
2771 compiler_exit_scope(c);
2772 if (co == NULL)
2773 return 0;
2774
2775 compiler_make_closure(c, co, 0);
2776 Py_DECREF(co);
2777
2778 VISIT(c, expr, outermost_iter);
2779 ADDOP(c, GET_ITER);
2780 ADDOP_I(c, CALL_FUNCTION, 1);
2781
2782 return 1;
2783 }
2784
2785 static int
2786 compiler_visit_keyword(struct compiler *c, keyword_ty k)
2787 {
2788 ADDOP_O(c, LOAD_CONST, k->arg, consts);
2789 VISIT(c, expr, k->value);
2790 return 1;
2791 }
2792
2793 /* Test whether expression is constant. For constants, report
2794 whether they are true or false.
2795
2796 Return values: 1 for true, 0 for false, -1 for non-constant.
2797 */
2798
2799 static int
2800 expr_constant(expr_ty e)
2801 {
2802 switch (e->kind) {
2803 case Num_kind:
2804 return PyObject_IsTrue(e->v.Num.n);
2805 case Str_kind:
2806 return PyObject_IsTrue(e->v.Str.s);
2807 case Name_kind:
2808 /* __debug__ is not assignable, so we can optimize
2809 * it away in if and while statements */
2810 if (strcmp(PyString_AS_STRING(e->v.Name.id),
2811 "__debug__") == 0)
2812 return ! Py_OptimizeFlag;
2813 /* fall through */
2814 default:
2815 return -1;
2816 }
2817 }
2818
2819 /*
2820 Implements the with statement from PEP 343.
2821
2822 The semantics outlined in that PEP are as follows:
2823
2824 with EXPR as VAR:
2825 BLOCK
2826
2827 It is implemented roughly as:
2828
2829 context = EXPR
2830 exit = context.__exit__ # not calling it
2831 value = context.__enter__()
2832 try:
2833 VAR = value # if VAR present in the syntax
2834 BLOCK
2835 finally:
2836 if an exception was raised:
2837 exc = copy of (exception, instance, traceback)
2838 else:
2839 exc = (None, None, None)
2840 exit(*exc)
2841 */
2842 static int
2843 compiler_with(struct compiler *c, stmt_ty s)
2844 {
2845 static identifier enter_attr, exit_attr;
2846 basicblock *block, *finally;
2847 identifier tmpvalue = NULL;
2848
2849 assert(s->kind == With_kind);
2850
2851 if (!enter_attr) {
2852 enter_attr = PyString_InternFromString("__enter__");
2853 if (!enter_attr)
2854 return 0;
2855 }
2856 if (!exit_attr) {
2857 exit_attr = PyString_InternFromString("__exit__");
2858 if (!exit_attr)
2859 return 0;
2860 }
2861
2862 block = compiler_new_block(c);
2863 finally = compiler_new_block(c);
2864 if (!block || !finally)
2865 return 0;
2866
2867 if (s->v.With.optional_vars) {
2868 /* Create a temporary variable to hold context.__enter__().
2869 We need to do this rather than preserving it on the stack
2870 because SETUP_FINALLY remembers the stack level.
2871 We need to do the assignment *inside* the try/finally
2872 so that context.__exit__() is called when the assignment
2873 fails. But we need to call context.__enter__() *before*
2874 the try/finally so that if it fails we won't call
2875 context.__exit__().
2876 */
2877 tmpvalue = compiler_new_tmpname(c);
2878 if (tmpvalue == NULL)
2879 return 0;
2880 PyArena_AddPyObject(c->c_arena, tmpvalue);
2881 }
2882
2883 /* Evaluate EXPR */
2884 VISIT(c, expr, s->v.With.context_expr);
2885
2886 /* Squirrel away context.__exit__ by stuffing it under context */
2887 ADDOP(c, DUP_TOP);
2888 ADDOP_O(c, LOAD_ATTR, exit_attr, names);
2889 ADDOP(c, ROT_TWO);
2890
2891 /* Call context.__enter__() */
2892 ADDOP_O(c, LOAD_ATTR, enter_attr, names);
2893 ADDOP_I(c, CALL_FUNCTION, 0);
2894
2895 if (s->v.With.optional_vars) {
2896 /* Store it in tmpvalue */
2897 if (!compiler_nameop(c, tmpvalue, Store))
2898 return 0;
2899 }
2900 else {
2901 /* Discard result from context.__enter__() */
2902 ADDOP(c, POP_TOP);
2903 }
2904
2905 /* Start the try block */
2906 ADDOP_JREL(c, SETUP_FINALLY, finally);
2907
2908 compiler_use_next_block(c, block);
2909 if (!compiler_push_fblock(c, FINALLY_TRY, block)) {
2910 return 0;
2911 }
2912
2913 if (s->v.With.optional_vars) {
2914 /* Bind saved result of context.__enter__() to VAR */
2915 if (!compiler_nameop(c, tmpvalue, Load) ||
2916 !compiler_nameop(c, tmpvalue, Del))
2917 return 0;
2918 VISIT(c, expr, s->v.With.optional_vars);
2919 }
2920
2921 /* BLOCK code */
2922 VISIT_SEQ(c, stmt, s->v.With.body);
2923
2924 /* End of try block; start the finally block */
2925 ADDOP(c, POP_BLOCK);
2926 compiler_pop_fblock(c, FINALLY_TRY, block);
2927
2928 ADDOP_O(c, LOAD_CONST, Py_None, consts);
2929 compiler_use_next_block(c, finally);
2930 if (!compiler_push_fblock(c, FINALLY_END, finally))
2931 return 0;
2932
2933 /* Finally block starts; context.__exit__ is on the stack under
2934 the exception or return information. Just issue our magic
2935 opcode. */
2936 ADDOP(c, WITH_CLEANUP);
2937
2938 /* Finally block ends. */
2939 ADDOP(c, END_FINALLY);
2940 compiler_pop_fblock(c, FINALLY_END, finally);
2941 return 1;
2942 }
2943
2944 static int
2945 compiler_visit_expr(struct compiler *c, expr_ty e)
2946 {
2947 int i, n;
2948
2949 /* If expr e has a different line number than the last expr/stmt,
2950 set a new line number for the next instruction.
2951 */
2952 if (e->lineno > c->u->u_lineno) {
2953 c->u->u_lineno = e->lineno;
2954 c->u->u_lineno_set = false;
2955 }
2956 switch (e->kind) {
2957 case BoolOp_kind:
2958 return compiler_boolop(c, e);
2959 case BinOp_kind:
2960 VISIT(c, expr, e->v.BinOp.left);
2961 VISIT(c, expr, e->v.BinOp.right);
2962 ADDOP(c, binop(c, e->v.BinOp.op));
2963 break;
2964 case UnaryOp_kind:
2965 VISIT(c, expr, e->v.UnaryOp.operand);
2966 ADDOP(c, unaryop(e->v.UnaryOp.op));
2967 break;
2968 case Lambda_kind:
2969 return compiler_lambda(c, e);
2970 case IfExp_kind:
2971 return compiler_ifexp(c, e);
2972 case Dict_kind:
2973 n = asdl_seq_LEN(e->v.Dict.values);
2974 ADDOP_I(c, BUILD_MAP, (n>0xFFFF ? 0xFFFF : n));
2975 for (i = 0; i < n; i++) {
2976 VISIT(c, expr,
2977 (expr_ty)asdl_seq_GET(e->v.Dict.values, i));
2978 VISIT(c, expr,
2979 (expr_ty)asdl_seq_GET(e->v.Dict.keys, i));
2980 ADDOP(c, STORE_MAP);
2981 }
2982 break;
2983 case ListComp_kind:
2984 return compiler_listcomp(c, e);
2985 case GeneratorExp_kind:
2986 return compiler_genexp(c, e);
2987 case Yield_kind:
2988 if (c->u->u_ste->ste_type != FunctionBlock)
2989 return compiler_error(c, "'yield' outside function");
2990 if (e->v.Yield.value) {
2991 VISIT(c, expr, e->v.Yield.value);
2992 }
2993 else {
2994 ADDOP_O(c, LOAD_CONST, Py_None, consts);
2995 }
2996 ADDOP(c, YIELD_VALUE);
2997 break;
2998 case Compare_kind:
2999 return compiler_compare(c, e);
3000 case Call_kind:
3001 return compiler_call(c, e);
3002 case Repr_kind:
3003 VISIT(c, expr, e->v.Repr.value);
3004 ADDOP(c, UNARY_CONVERT);
3005 break;
3006 case Num_kind:
3007 ADDOP_O(c, LOAD_CONST, e->v.Num.n, consts);
3008 break;
3009 case Str_kind:
3010 ADDOP_O(c, LOAD_CONST, e->v.Str.s, consts);
3011 break;
3012 /* The following exprs can be assignment targets. */
3013 case Attribute_kind:
3014 if (e->v.Attribute.ctx != AugStore)
3015 VISIT(c, expr, e->v.Attribute.value);
3016 switch (e->v.Attribute.ctx) {
3017 case AugLoad:
3018 ADDOP(c, DUP_TOP);
3019 /* Fall through to load */
3020 case Load:
3021 ADDOP_NAME(c, LOAD_ATTR, e->v.Attribute.attr, names);
3022 break;
3023 case AugStore:
3024 ADDOP(c, ROT_TWO);
3025 /* Fall through to save */
3026 case Store:
3027 ADDOP_NAME(c, STORE_ATTR, e->v.Attribute.attr, names);
3028 break;
3029 case Del:
3030 ADDOP_NAME(c, DELETE_ATTR, e->v.Attribute.attr, names);
3031 break;
3032 case Param:
3033 default:
3034 PyErr_SetString(PyExc_SystemError,
3035 "param invalid in attribute expression");
3036 return 0;
3037 }
3038 break;
3039 case Subscript_kind:
3040 switch (e->v.Subscript.ctx) {
3041 case AugLoad:
3042 VISIT(c, expr, e->v.Subscript.value);
3043 VISIT_SLICE(c, e->v.Subscript.slice, AugLoad);
3044 break;
3045 case Load:
3046 VISIT(c, expr, e->v.Subscript.value);
3047 VISIT_SLICE(c, e->v.Subscript.slice, Load);
3048 break;
3049 case AugStore:
3050 VISIT_SLICE(c, e->v.Subscript.slice, AugStore);
3051 break;
3052 case Store:
3053 VISIT(c, expr, e->v.Subscript.value);
3054 VISIT_SLICE(c, e->v.Subscript.slice, Store);
3055 break;
3056 case Del:
3057 VISIT(c, expr, e->v.Subscript.value);
3058 VISIT_SLICE(c, e->v.Subscript.slice, Del);
3059 break;
3060 case Param:
3061 default:
3062 PyErr_SetString(PyExc_SystemError,
3063 "param invalid in subscript expression");
3064 return 0;
3065 }
3066 break;
3067 case Name_kind:
3068 return compiler_nameop(c, e->v.Name.id, e->v.Name.ctx);
3069 /* child nodes of List and Tuple will have expr_context set */
3070 case List_kind:
3071 return compiler_list(c, e);
3072 case Tuple_kind:
3073 return compiler_tuple(c, e);
3074 }
3075 return 1;
3076 }
3077
3078 static int
3079 compiler_augassign(struct compiler *c, stmt_ty s)
3080 {
3081 expr_ty e = s->v.AugAssign.target;
3082 expr_ty auge;
3083
3084 assert(s->kind == AugAssign_kind);
3085
3086 switch (e->kind) {
3087 case Attribute_kind:
3088 auge = Attribute(e->v.Attribute.value, e->v.Attribute.attr,
3089 AugLoad, e->lineno, e->col_offset, c->c_arena);
3090 if (auge == NULL)
3091 return 0;
3092 VISIT(c, expr, auge);
3093 VISIT(c, expr, s->v.AugAssign.value);
3094 ADDOP(c, inplace_binop(c, s->v.AugAssign.op));
3095 auge->v.Attribute.ctx = AugStore;
3096 VISIT(c, expr, auge);
3097 break;
3098 case Subscript_kind:
3099 auge = Subscript(e->v.Subscript.value, e->v.Subscript.slice,
3100 AugLoad, e->lineno, e->col_offset, c->c_arena);
3101 if (auge == NULL)
3102 return 0;
3103 VISIT(c, expr, auge);
3104 VISIT(c, expr, s->v.AugAssign.value);
3105 ADDOP(c, inplace_binop(c, s->v.AugAssign.op));
3106 auge->v.Subscript.ctx = AugStore;
3107 VISIT(c, expr, auge);
3108 break;
3109 case Name_kind:
3110 if (!compiler_nameop(c, e->v.Name.id, Load))
3111 return 0;
3112 VISIT(c, expr, s->v.AugAssign.value);
3113 ADDOP(c, inplace_binop(c, s->v.AugAssign.op));
3114 return compiler_nameop(c, e->v.Name.id, Store);
3115 default:
3116 PyErr_Format(PyExc_SystemError,
3117 "invalid node type (%d) for augmented assignment",
3118 e->kind);
3119 return 0;
3120 }
3121 return 1;
3122 }
3123
3124 static int
3125 compiler_push_fblock(struct compiler *c, enum fblocktype t, basicblock *b)
3126 {
3127 struct fblockinfo *f;
3128 if (c->u->u_nfblocks >= CO_MAXBLOCKS) {
3129 PyErr_SetString(PyExc_SystemError,
3130 "too many statically nested blocks");
3131 return 0;
3132 }
3133 f = &c->u->u_fblock[c->u->u_nfblocks++];
3134 f->fb_type = t;
3135 f->fb_block = b;
3136 return 1;
3137 }
3138
3139 static void
3140 compiler_pop_fblock(struct compiler *c, enum fblocktype t, basicblock *b)
3141 {
3142 struct compiler_unit *u = c->u;
3143 assert(u->u_nfblocks > 0);
3144 u->u_nfblocks--;
3145 assert(u->u_fblock[u->u_nfblocks].fb_type == t);
3146 assert(u->u_fblock[u->u_nfblocks].fb_block == b);
3147 }
3148
3149 static int
3150 compiler_in_loop(struct compiler *c) {
3151 int i;
3152 struct compiler_unit *u = c->u;
3153 for (i = 0; i < u->u_nfblocks; ++i) {
3154 if (u->u_fblock[i].fb_type == LOOP)
3155 return 1;
3156 }
3157 return 0;
3158 }
3159 /* Raises a SyntaxError and returns 0.
3160 If something goes wrong, a different exception may be raised.
3161 */
3162
3163 static int
3164 compiler_error(struct compiler *c, const char *errstr)
3165 {
3166 PyObject *loc;
3167 PyObject *u = NULL, *v = NULL;
3168
3169 loc = PyErr_ProgramText(c->c_filename, c->u->u_lineno);
3170 if (!loc) {
3171 Py_INCREF(Py_None);
3172 loc = Py_None;
3173 }
3174 u = Py_BuildValue("(ziOO)", c->c_filename, c->u->u_lineno,
3175 Py_None, loc);
3176 if (!u)
3177 goto exit;
3178 v = Py_BuildValue("(zO)", errstr, u);
3179 if (!v)
3180 goto exit;
3181 PyErr_SetObject(PyExc_SyntaxError, v);
3182 exit:
3183 Py_DECREF(loc);
3184 Py_XDECREF(u);
3185 Py_XDECREF(v);
3186 return 0;
3187 }
3188
3189 static int
3190 compiler_handle_subscr(struct compiler *c, const char *kind,
3191 expr_context_ty ctx)
3192 {
3193 int op = 0;
3194
3195 /* XXX this code is duplicated */
3196 switch (ctx) {
3197 case AugLoad: /* fall through to Load */
3198 case Load: op = BINARY_SUBSCR; break;
3199 case AugStore:/* fall through to Store */
3200 case Store: op = STORE_SUBSCR; break;
3201 case Del: op = DELETE_SUBSCR; break;
3202 case Param:
3203 PyErr_Format(PyExc_SystemError,
3204 "invalid %s kind %d in subscript\n",
3205 kind, ctx);
3206 return 0;
3207 }
3208 if (ctx == AugLoad) {
3209 ADDOP_I(c, DUP_TOPX, 2);
3210 }
3211 else if (ctx == AugStore) {
3212 ADDOP(c, ROT_THREE);
3213 }
3214 ADDOP(c, op);
3215 return 1;
3216 }
3217
3218 static int
3219 compiler_slice(struct compiler *c, slice_ty s, expr_context_ty ctx)
3220 {
3221 int n = 2;
3222 assert(s->kind == Slice_kind);
3223
3224 /* only handles the cases where BUILD_SLICE is emitted */
3225 if (s->v.Slice.lower) {
3226 VISIT(c, expr, s->v.Slice.lower);
3227 }
3228 else {
3229 ADDOP_O(c, LOAD_CONST, Py_None, consts);
3230 }
3231
3232 if (s->v.Slice.upper) {
3233 VISIT(c, expr, s->v.Slice.upper);
3234 }
3235 else {
3236 ADDOP_O(c, LOAD_CONST, Py_None, consts);
3237 }
3238
3239 if (s->v.Slice.step) {
3240 n++;
3241 VISIT(c, expr, s->v.Slice.step);
3242 }
3243 ADDOP_I(c, BUILD_SLICE, n);
3244 return 1;
3245 }
3246
3247 static int
3248 compiler_simple_slice(struct compiler *c, slice_ty s, expr_context_ty ctx)
3249 {
3250 int op = 0, slice_offset = 0, stack_count = 0;
3251
3252 assert(s->v.Slice.step == NULL);
3253 if (s->v.Slice.lower) {
3254 slice_offset++;
3255 stack_count++;
3256 if (ctx != AugStore)
3257 VISIT(c, expr, s->v.Slice.lower);
3258 }
3259 if (s->v.Slice.upper) {
3260 slice_offset += 2;
3261 stack_count++;
3262 if (ctx != AugStore)
3263 VISIT(c, expr, s->v.Slice.upper);
3264 }
3265
3266 if (ctx == AugLoad) {
3267 switch (stack_count) {
3268 case 0: ADDOP(c, DUP_TOP); break;
3269 case 1: ADDOP_I(c, DUP_TOPX, 2); break;
3270 case 2: ADDOP_I(c, DUP_TOPX, 3); break;
3271 }
3272 }
3273 else if (ctx == AugStore) {
3274 switch (stack_count) {
3275 case 0: ADDOP(c, ROT_TWO); break;
3276 case 1: ADDOP(c, ROT_THREE); break;
3277 case 2: ADDOP(c, ROT_FOUR); break;
3278 }
3279 }
3280
3281 switch (ctx) {
3282 case AugLoad: /* fall through to Load */
3283 case Load: op = SLICE; break;
3284 case AugStore:/* fall through to Store */
3285 case Store: op = STORE_SLICE; break;
3286 case Del: op = DELETE_SLICE; break;
3287 case Param:
3288 default:
3289 PyErr_SetString(PyExc_SystemError,
3290 "param invalid in simple slice");
3291 return 0;
3292 }
3293
3294 ADDOP(c, op + slice_offset);
3295 return 1;
3296 }
3297
3298 static int
3299 compiler_visit_nested_slice(struct compiler *c, slice_ty s,
3300 expr_context_ty ctx)
3301 {
3302 switch (s->kind) {
3303 case Ellipsis_kind:
3304 ADDOP_O(c, LOAD_CONST, Py_Ellipsis, consts);
3305 break;
3306 case Slice_kind:
3307 return compiler_slice(c, s, ctx);
3308 case Index_kind:
3309 VISIT(c, expr, s->v.Index.value);
3310 break;
3311 case ExtSlice_kind:
3312 default:
3313 PyErr_SetString(PyExc_SystemError,
3314 "extended slice invalid in nested slice");
3315 return 0;
3316 }
3317 return 1;
3318 }
3319
3320 static int
3321 compiler_visit_slice(struct compiler *c, slice_ty s, expr_context_ty ctx)
3322 {
3323 char * kindname = NULL;
3324 switch (s->kind) {
3325 case Index_kind:
3326 kindname = "index";
3327 if (ctx != AugStore) {
3328 VISIT(c, expr, s->v.Index.value);
3329 }
3330 break;
3331 case Ellipsis_kind:
3332 kindname = "ellipsis";
3333 if (ctx != AugStore) {
3334 ADDOP_O(c, LOAD_CONST, Py_Ellipsis, consts);
3335 }
3336 break;
3337 case Slice_kind:
3338 kindname = "slice";
3339 if (!s->v.Slice.step)
3340 return compiler_simple_slice(c, s, ctx);
3341 if (ctx != AugStore) {
3342 if (!compiler_slice(c, s, ctx))
3343 return 0;
3344 }
3345 break;
3346 case ExtSlice_kind:
3347 kindname = "extended slice";
3348 if (ctx != AugStore) {
3349 int i, n = asdl_seq_LEN(s->v.ExtSlice.dims);
3350 for (i = 0; i < n; i++) {
3351 slice_ty sub = (slice_ty)asdl_seq_GET(
3352 s->v.ExtSlice.dims, i);
3353 if (!compiler_visit_nested_slice(c, sub, ctx))
3354 return 0;
3355 }
3356 ADDOP_I(c, BUILD_TUPLE, n);
3357 }
3358 break;
3359 default:
3360 PyErr_Format(PyExc_SystemError,
3361 "invalid subscript kind %d", s->kind);
3362 return 0;
3363 }
3364 return compiler_handle_subscr(c, kindname, ctx);
3365 }
3366
3367
3368 /* End of the compiler section, beginning of the assembler section */
3369
3370 /* do depth-first search of basic block graph, starting with block.
3371 post records the block indices in post-order.
3372
3373 XXX must handle implicit jumps from one block to next
3374 */
3375
3376 struct assembler {
3377 PyObject *a_bytecode; /* string containing bytecode */
3378 int a_offset; /* offset into bytecode */
3379 int a_nblocks; /* number of reachable blocks */
3380 basicblock **a_postorder; /* list of blocks in dfs postorder */
3381 PyObject *a_lnotab; /* string containing lnotab */
3382 int a_lnotab_off; /* offset into lnotab */
3383 int a_lineno; /* last lineno of emitted instruction */
3384 int a_lineno_off; /* bytecode offset of last lineno */
3385 };
3386
3387 static void
3388 dfs(struct compiler *c, basicblock *b, struct assembler *a)
3389 {
3390 int i;
3391 struct instr *instr = NULL;
3392
3393 if (b->b_seen)
3394 return;
3395 b->b_seen = 1;
3396 if (b->b_next != NULL)
3397 dfs(c, b->b_next, a);
3398 for (i = 0; i < b->b_iused; i++) {
3399 instr = &b->b_instr[i];
3400 if (instr->i_jrel || instr->i_jabs)
3401 dfs(c, instr->i_target, a);
3402 }
3403 a->a_postorder[a->a_nblocks++] = b;
3404 }
3405
3406 static int
3407 stackdepth_walk(struct compiler *c, basicblock *b, int depth, int maxdepth)
3408 {
3409 int i;
3410 struct instr *instr;
3411 if (b->b_seen || b->b_startdepth >= depth)
3412 return maxdepth;
3413 b->b_seen = 1;
3414 b->b_startdepth = depth;
3415 for (i = 0; i < b->b_iused; i++) {
3416 instr = &b->b_instr[i];
3417 depth += opcode_stack_effect(instr->i_opcode, instr->i_oparg);
3418 if (depth > maxdepth)
3419 maxdepth = depth;
3420 assert(depth >= 0); /* invalid code or bug in stackdepth() */
3421 if (instr->i_jrel || instr->i_jabs) {
3422 maxdepth = stackdepth_walk(c, instr->i_target,
3423 depth, maxdepth);
3424 if (instr->i_opcode == JUMP_ABSOLUTE ||
3425 instr->i_opcode == JUMP_FORWARD) {
3426 goto out; /* remaining code is dead */
3427 }
3428 }
3429 }
3430 if (b->b_next)
3431 maxdepth = stackdepth_walk(c, b->b_next, depth, maxdepth);
3432 out:
3433 b->b_seen = 0;
3434 return maxdepth;
3435 }
3436
3437 /* Find the flow path that needs the largest stack. We assume that
3438 * cycles in the flow graph have no net effect on the stack depth.
3439 */
3440 static int
3441 stackdepth(struct compiler *c)
3442 {
3443 basicblock *b, *entryblock;
3444 entryblock = NULL;
3445 for (b = c->u->u_blocks; b != NULL; b = b->b_list) {
3446 b->b_seen = 0;
3447 b->b_startdepth = INT_MIN;
3448 entryblock = b;
3449 }
3450 if (!entryblock)
3451 return 0;
3452 return stackdepth_walk(c, entryblock, 0, 0);
3453 }
3454
3455 static int
3456 assemble_init(struct assembler *a, int nblocks, int firstlineno)
3457 {
3458 memset(a, 0, sizeof(struct assembler));
3459 a->a_lineno = firstlineno;
3460 a->a_bytecode = PyString_FromStringAndSize(NULL, DEFAULT_CODE_SIZE);
3461 if (!a->a_bytecode)
3462 return 0;
3463 a->a_lnotab = PyString_FromStringAndSize(NULL, DEFAULT_LNOTAB_SIZE);
3464 if (!a->a_lnotab)
3465 return 0;
3466 if (nblocks > PY_SIZE_MAX / sizeof(basicblock *)) {
3467 PyErr_NoMemory();
3468 return 0;
3469 }
3470 a->a_postorder = (basicblock **)PyObject_Malloc(
3471 sizeof(basicblock *) * nblocks);
3472 if (!a->a_postorder) {
3473 PyErr_NoMemory();
3474 return 0;
3475 }
3476 return 1;
3477 }
3478
3479 static void
3480 assemble_free(struct assembler *a)
3481 {
3482 Py_XDECREF(a->a_bytecode);
3483 Py_XDECREF(a->a_lnotab);
3484 if (a->a_postorder)
3485 PyObject_Free(a->a_postorder);
3486 }
3487
3488 /* Return the size of a basic block in bytes. */
3489
3490 static int
3491 instrsize(struct instr *instr)
3492 {
3493 if (!instr->i_hasarg)
3494 return 1; /* 1 byte for the opcode*/
3495 if (instr->i_oparg > 0xffff)
3496 return 6; /* 1 (opcode) + 1 (EXTENDED_ARG opcode) + 2 (oparg) + 2(oparg extended) */
3497 return 3; /* 1 (opcode) + 2 (oparg) */
3498 }
3499
3500 static int
3501 blocksize(basicblock *b)
3502 {
3503 int i;
3504 int size = 0;
3505
3506 for (i = 0; i < b->b_iused; i++)
3507 size += instrsize(&b->b_instr[i]);
3508 return size;
3509 }
3510
3511 /* All about a_lnotab.
3512
3513 c_lnotab is an array of unsigned bytes disguised as a Python string.
3514 It is used to map bytecode offsets to source code line #s (when needed
3515 for tracebacks).
3516
3517 The array is conceptually a list of
3518 (bytecode offset increment, line number increment)
3519 pairs. The details are important and delicate, best illustrated by example:
3520
3521 byte code offset source code line number
3522 0 1
3523 6 2
3524 50 7
3525 350 307
3526 361 308
3527
3528 The first trick is that these numbers aren't stored, only the increments
3529 from one row to the next (this doesn't really work, but it's a start):
3530
3531 0, 1, 6, 1, 44, 5, 300, 300, 11, 1
3532
3533 The second trick is that an unsigned byte can't hold negative values, or
3534 values larger than 255, so (a) there's a deep assumption that byte code
3535 offsets and their corresponding line #s both increase monotonically, and (b)
3536 if at least one column jumps by more than 255 from one row to the next, more
3537 than one pair is written to the table. In case #b, there's no way to know
3538 from looking at the table later how many were written. That's the delicate
3539 part. A user of c_lnotab desiring to find the source line number
3540 corresponding to a bytecode address A should do something like this
3541
3542 lineno = addr = 0
3543 for addr_incr, line_incr in c_lnotab:
3544 addr += addr_incr
3545 if addr > A:
3546 return lineno
3547 lineno += line_incr
3548
3549 In order for this to work, when the addr field increments by more than 255,
3550 the line # increment in each pair generated must be 0 until the remaining addr
3551 increment is < 256. So, in the example above, assemble_lnotab (it used
3552 to be called com_set_lineno) should not (as was actually done until 2.2)
3553 expand 300, 300 to 255, 255, 45, 45,
3554 but to 255, 0, 45, 255, 0, 45.
3555 */
3556
3557 static int
3558 assemble_lnotab(struct assembler *a, struct instr *i)
3559 {
3560 int d_bytecode, d_lineno;
3561 int len;
3562 unsigned char *lnotab;
3563
3564 d_bytecode = a->a_offset - a->a_lineno_off;
3565 d_lineno = i->i_lineno - a->a_lineno;
3566
3567 assert(d_bytecode >= 0);
3568 assert(d_lineno >= 0);
3569
3570 if(d_bytecode == 0 && d_lineno == 0)
3571 return 1;
3572
3573 if (d_bytecode > 255) {
3574 int j, nbytes, ncodes = d_bytecode / 255;
3575 nbytes = a->a_lnotab_off + 2 * ncodes;
3576 len = PyString_GET_SIZE(a->a_lnotab);
3577 if (nbytes >= len) {
3578 if ((len <= INT_MAX / 2) && (len * 2 < nbytes))
3579 len = nbytes;
3580 else if (len <= INT_MAX / 2)
3581 len *= 2;
3582 else {
3583 PyErr_NoMemory();
3584 return 0;
3585 }
3586 if (_PyString_Resize(&a->a_lnotab, len) < 0)
3587 return 0;
3588 }
3589 lnotab = (unsigned char *)
3590 PyString_AS_STRING(a->a_lnotab) + a->a_lnotab_off;
3591 for (j = 0; j < ncodes; j++) {
3592 *lnotab++ = 255;
3593 *lnotab++ = 0;
3594 }
3595 d_bytecode -= ncodes * 255;
3596 a->a_lnotab_off += ncodes * 2;
3597 }
3598 assert(d_bytecode <= 255);
3599 if (d_lineno > 255) {
3600 int j, nbytes, ncodes = d_lineno / 255;
3601 nbytes = a->a_lnotab_off + 2 * ncodes;
3602 len = PyString_GET_SIZE(a->a_lnotab);
3603 if (nbytes >= len) {
3604 if ((len <= INT_MAX / 2) && len * 2 < nbytes)
3605 len = nbytes;
3606 else if (len <= INT_MAX / 2)
3607 len *= 2;
3608 else {
3609 PyErr_NoMemory();
3610 return 0;
3611 }
3612 if (_PyString_Resize(&a->a_lnotab, len) < 0)
3613 return 0;
3614 }
3615 lnotab = (unsigned char *)
3616 PyString_AS_STRING(a->a_lnotab) + a->a_lnotab_off;
3617 *lnotab++ = d_bytecode;
3618 *lnotab++ = 255;
3619 d_bytecode = 0;
3620 for (j = 1; j < ncodes; j++) {
3621 *lnotab++ = 0;
3622 *lnotab++ = 255;
3623 }
3624 d_lineno -= ncodes * 255;
3625 a->a_lnotab_off += ncodes * 2;
3626 }
3627
3628 len = PyString_GET_SIZE(a->a_lnotab);
3629 if (a->a_lnotab_off + 2 >= len) {
3630 if (_PyString_Resize(&a->a_lnotab, len * 2) < 0)
3631 return 0;
3632 }
3633 lnotab = (unsigned char *)
3634 PyString_AS_STRING(a->a_lnotab) + a->a_lnotab_off;
3635
3636 a->a_lnotab_off += 2;
3637 if (d_bytecode) {
3638 *lnotab++ = d_bytecode;
3639 *lnotab++ = d_lineno;
3640 }
3641 else { /* First line of a block; def stmt, etc. */
3642 *lnotab++ = 0;
3643 *lnotab++ = d_lineno;
3644 }
3645 a->a_lineno = i->i_lineno;
3646 a->a_lineno_off = a->a_offset;
3647 return 1;
3648 }
3649
3650 /* assemble_emit()
3651 Extend the bytecode with a new instruction.
3652 Update lnotab if necessary.
3653 */
3654
3655 static int
3656 assemble_emit(struct assembler *a, struct instr *i)
3657 {
3658 int size, arg = 0, ext = 0;
3659 Py_ssize_t len = PyString_GET_SIZE(a->a_bytecode);
3660 char *code;
3661
3662 size = instrsize(i);
3663 if (i->i_hasarg) {
3664 arg = i->i_oparg;
3665 ext = arg >> 16;
3666 }
3667 if (i->i_lineno && !assemble_lnotab(a, i))
3668 return 0;
3669 if (a->a_offset + size >= len) {
3670 if (len > PY_SSIZE_T_MAX / 2)
3671 return 0;
3672 if (_PyString_Resize(&a->a_bytecode, len * 2) < 0)
3673 return 0;
3674 }
3675 code = PyString_AS_STRING(a->a_bytecode) + a->a_offset;
3676 a->a_offset += size;
3677 if (size == 6) {
3678 assert(i->i_hasarg);
3679 *code++ = (char)EXTENDED_ARG;
3680 *code++ = ext & 0xff;
3681 *code++ = ext >> 8;
3682 arg &= 0xffff;
3683 }
3684 *code++ = i->i_opcode;
3685 if (i->i_hasarg) {
3686 assert(size == 3 || size == 6);
3687 *code++ = arg & 0xff;
3688 *code++ = arg >> 8;
3689 }
3690 return 1;
3691 }
3692
3693 static void
3694 assemble_jump_offsets(struct assembler *a, struct compiler *c)
3695 {
3696 basicblock *b;
3697 int bsize, totsize, extended_arg_count, last_extended_arg_count = 0;
3698 int i;
3699
3700 /* Compute the size of each block and fixup jump args.
3701 Replace block pointer with position in bytecode. */
3702 start:
3703 totsize = 0;
3704 for (i = a->a_nblocks - 1; i >= 0; i--) {
3705 b = a->a_postorder[i];
3706 bsize = blocksize(b);
3707 b->b_offset = totsize;
3708 totsize += bsize;
3709 }
3710 extended_arg_count = 0;
3711 for (b = c->u->u_blocks; b != NULL; b = b->b_list) {
3712 bsize = b->b_offset;
3713 for (i = 0; i < b->b_iused; i++) {
3714 struct instr *instr = &b->b_instr[i];
3715 /* Relative jumps are computed relative to
3716 the instruction pointer after fetching
3717 the jump instruction.
3718 */
3719 bsize += instrsize(instr);
3720 if (instr->i_jabs)
3721 instr->i_oparg = instr->i_target->b_offset;
3722 else if (instr->i_jrel) {
3723 int delta = instr->i_target->b_offset - bsize;
3724 instr->i_oparg = delta;
3725 }
3726 else
3727 continue;
3728 if (instr->i_oparg > 0xffff)
3729 extended_arg_count++;
3730 }
3731 }
3732
3733 /* XXX: This is an awful hack that could hurt performance, but
3734 on the bright side it should work until we come up
3735 with a better solution.
3736
3737 In the meantime, should the goto be dropped in favor
3738 of a loop?
3739
3740 The issue is that in the first loop blocksize() is called
3741 which calls instrsize() which requires i_oparg be set
3742 appropriately. There is a bootstrap problem because
3743 i_oparg is calculated in the second loop above.
3744
3745 So we loop until we stop seeing new EXTENDED_ARGs.
3746 The only EXTENDED_ARGs that could be popping up are
3747 ones in jump instructions. So this should converge
3748 fairly quickly.
3749 */
3750 if (last_extended_arg_count != extended_arg_count) {
3751 last_extended_arg_count = extended_arg_count;
3752 goto start;
3753 }
3754 }
3755
3756 static PyObject *
3757 dict_keys_inorder(PyObject *dict, int offset)
3758 {
3759 PyObject *tuple, *k, *v;
3760 Py_ssize_t i, pos = 0, size = PyDict_Size(dict);
3761
3762 tuple = PyTuple_New(size);
3763 if (tuple == NULL)
3764 return NULL;
3765 while (PyDict_Next(dict, &pos, &k, &v)) {
3766 i = PyInt_AS_LONG(v);
3767 k = PyTuple_GET_ITEM(k, 0);
3768 Py_INCREF(k);
3769 assert((i - offset) < size);
3770 assert((i - offset) >= 0);
3771 PyTuple_SET_ITEM(tuple, i - offset, k);
3772 }
3773 return tuple;
3774 }
3775
3776 static int
3777 compute_code_flags(struct compiler *c)
3778 {
3779 PySTEntryObject *ste = c->u->u_ste;
3780 int flags = 0, n;
3781 if (ste->ste_type != ModuleBlock)
3782 flags |= CO_NEWLOCALS;
3783 if (ste->ste_type == FunctionBlock) {
3784 if (!ste->ste_unoptimized)
3785 flags |= CO_OPTIMIZED;
3786 if (ste->ste_nested)
3787 flags |= CO_NESTED;
3788 if (ste->ste_generator)
3789 flags |= CO_GENERATOR;
3790 }
3791 if (ste->ste_varargs)
3792 flags |= CO_VARARGS;
3793 if (ste->ste_varkeywords)
3794 flags |= CO_VARKEYWORDS;
3795 if (ste->ste_generator)
3796 flags |= CO_GENERATOR;
3797
3798 /* (Only) inherit compilerflags in PyCF_MASK */
3799 flags |= (c->c_flags->cf_flags & PyCF_MASK);
3800
3801 n = PyDict_Size(c->u->u_freevars);
3802 if (n < 0)
3803 return -1;
3804 if (n == 0) {
3805 n = PyDict_Size(c->u->u_cellvars);
3806 if (n < 0)
3807 return -1;
3808 if (n == 0) {
3809 flags |= CO_NOFREE;
3810 }
3811 }
3812
3813 return flags;
3814 }
3815
3816 static PyCodeObject *
3817 makecode(struct compiler *c, struct assembler *a)
3818 {
3819 PyObject *tmp;
3820 PyCodeObject *co = NULL;
3821 PyObject *consts = NULL;
3822 PyObject *names = NULL;
3823 PyObject *varnames = NULL;
3824 PyObject *filename = NULL;
3825 PyObject *name = NULL;
3826 PyObject *freevars = NULL;
3827 PyObject *cellvars = NULL;
3828 PyObject *bytecode = NULL;
3829 int nlocals, flags;
3830
3831 tmp = dict_keys_inorder(c->u->u_consts, 0);
3832 if (!tmp)
3833 goto error;
3834 consts = PySequence_List(tmp); /* optimize_code requires a list */
3835 Py_DECREF(tmp);
3836
3837 names = dict_keys_inorder(c->u->u_names, 0);
3838 varnames = dict_keys_inorder(c->u->u_varnames, 0);
3839 if (!consts || !names || !varnames)
3840 goto error;
3841
3842 cellvars = dict_keys_inorder(c->u->u_cellvars, 0);
3843 if (!cellvars)
3844 goto error;
3845 freevars = dict_keys_inorder(c->u->u_freevars, PyTuple_Size(cellvars));
3846 if (!freevars)
3847 goto error;
3848 filename = PyString_FromString(c->c_filename);
3849 if (!filename)
3850 goto error;
3851
3852 nlocals = PyDict_Size(c->u->u_varnames);
3853 flags = compute_code_flags(c);
3854 if (flags < 0)
3855 goto error;
3856
3857 bytecode = PyCode_Optimize(a->a_bytecode, consts, names, a->a_lnotab);
3858 if (!bytecode)
3859 goto error;
3860
3861 tmp = PyList_AsTuple(consts); /* PyCode_New requires a tuple */
3862 if (!tmp)
3863 goto error;
3864 Py_DECREF(consts);
3865 consts = tmp;
3866
3867 co = PyCode_New(c->u->u_argcount, nlocals, stackdepth(c), flags,
3868 bytecode, consts, names, varnames,
3869 freevars, cellvars,
3870 filename, c->u->u_name,
3871 c->u->u_firstlineno,
3872 a->a_lnotab);
3873 error:
3874 Py_XDECREF(consts);
3875 Py_XDECREF(names);
3876 Py_XDECREF(varnames);
3877 Py_XDECREF(filename);
3878 Py_XDECREF(name);
3879 Py_XDECREF(freevars);
3880 Py_XDECREF(cellvars);
3881 Py_XDECREF(bytecode);
3882 return co;
3883 }
3884
3885
3886 /* For debugging purposes only */
3887 #if 0
3888 static void
3889 dump_instr(const struct instr *i)
3890 {
3891 const char *jrel = i->i_jrel ? "jrel " : "";
3892 const char *jabs = i->i_jabs ? "jabs " : "";
3893 char arg[128];
3894
3895 *arg = '\0';
3896 if (i->i_hasarg)
3897 sprintf(arg, "arg: %d ", i->i_oparg);
3898
3899 fprintf(stderr, "line: %d, opcode: %d %s%s%s\n",
3900 i->i_lineno, i->i_opcode, arg, jabs, jrel);
3901 }
3902
3903 static void
3904 dump_basicblock(const basicblock *b)
3905 {
3906 const char *seen = b->b_seen ? "seen " : "";
3907 const char *b_return = b->b_return ? "return " : "";
3908 fprintf(stderr, "used: %d, depth: %d, offset: %d %s%s\n",
3909 b->b_iused, b->b_startdepth, b->b_offset, seen, b_return);
3910 if (b->b_instr) {
3911 int i;
3912 for (i = 0; i < b->b_iused; i++) {
3913 fprintf(stderr, " [%02d] ", i);
3914 dump_instr(b->b_instr + i);
3915 }
3916 }
3917 }
3918 #endif
3919
3920 static PyCodeObject *
3921 assemble(struct compiler *c, int addNone)
3922 {
3923 basicblock *b, *entryblock;
3924 struct assembler a;
3925 int i, j, nblocks;
3926 PyCodeObject *co = NULL;
3927
3928 /* Make sure every block that falls off the end returns None.
3929 XXX NEXT_BLOCK() isn't quite right, because if the last
3930 block ends with a jump or return b_next shouldn't set.
3931 */
3932 if (!c->u->u_curblock->b_return) {
3933 NEXT_BLOCK(c);
3934 if (addNone)
3935 ADDOP_O(c, LOAD_CONST, Py_None, consts);
3936 ADDOP(c, RETURN_VALUE);
3937 }
3938
3939 nblocks = 0;
3940 entryblock = NULL;
3941 for (b = c->u->u_blocks; b != NULL; b = b->b_list) {
3942 nblocks++;
3943 entryblock = b;
3944 }
3945
3946 /* Set firstlineno if it wasn't explicitly set. */
3947 if (!c->u->u_firstlineno) {
3948 if (entryblock && entryblock->b_instr)
3949 c->u->u_firstlineno = entryblock->b_instr->i_lineno;
3950 else
3951 c->u->u_firstlineno = 1;
3952 }
3953 if (!assemble_init(&a, nblocks, c->u->u_firstlineno))
3954 goto error;
3955 dfs(c, entryblock, &a);
3956
3957 /* Can't modify the bytecode after computing jump offsets. */
3958 assemble_jump_offsets(&a, c);
3959
3960 /* Emit code in reverse postorder from dfs. */
3961 for (i = a.a_nblocks - 1; i >= 0; i--) {
3962 b = a.a_postorder[i];
3963 for (j = 0; j < b->b_iused; j++)
3964 if (!assemble_emit(&a, &b->b_instr[j]))
3965 goto error;
3966 }
3967
3968 if (_PyString_Resize(&a.a_lnotab, a.a_lnotab_off) < 0)
3969 goto error;
3970 if (_PyString_Resize(&a.a_bytecode, a.a_offset) < 0)
3971 goto error;
3972
3973 co = makecode(c, &a);
3974 error:
3975 assemble_free(&a);
3976 return co;
3977 }
python git mirror