source: python/trunk/Python/compile.c@ 6

Last change on this file since 6 was 2, checked in by Yuri Dario, 15 years ago

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