Python-2.7.3/Python/compile.c

Location Tool Test ID Function Issue
/builddir/build/BUILD/Python-2.7.3/Python/compile.c:1025:34 clang-analyzer Access to field 'u_curblock' results in a dereference of a null pointer (loaded from field 'u')
/builddir/build/BUILD/Python-2.7.3/Python/compile.c:1025:34 clang-analyzer Access to field 'u_curblock' results in a dereference of a null pointer (loaded from field 'u')
/builddir/build/BUILD/Python-2.7.3/Python/compile.c:1025:34 clang-analyzer Access to field 'u_curblock' results in a dereference of a null pointer (loaded from field 'u')
/builddir/build/BUILD/Python-2.7.3/Python/compile.c:1243:31 clang-analyzer Access to field 'u_ste' results in a dereference of a null pointer (loaded from field 'u')
/builddir/build/BUILD/Python-2.7.3/Python/compile.c:1243:31 clang-analyzer Access to field 'u_ste' results in a dereference of a null pointer (loaded from field 'u')
/builddir/build/BUILD/Python-2.7.3/Python/compile.c:1243:31 clang-analyzer Access to field 'u_ste' results in a dereference of a null pointer (loaded from field 'u')
/builddir/build/BUILD/Python-2.7.3/Python/compile.c:1282:9 clang-analyzer Access to field 'u_consts' results in a dereference of a null pointer (loaded from field 'u')
/builddir/build/BUILD/Python-2.7.3/Python/compile.c:1282:9 clang-analyzer Access to field 'u_consts' results in a dereference of a null pointer (loaded from field 'u')
/builddir/build/BUILD/Python-2.7.3/Python/compile.c:1282:9 clang-analyzer Access to field 'u_consts' results in a dereference of a null pointer (loaded from field 'u')
/builddir/build/BUILD/Python-2.7.3/Python/compile.c:3431:9 clang-analyzer Access to field 'b_seen' results in a dereference of a null pointer (loaded from variable 'b')
/builddir/build/BUILD/Python-2.7.3/Python/compile.c:3431:9 clang-analyzer Access to field 'b_seen' results in a dereference of a null pointer (loaded from variable 'b')
/builddir/build/BUILD/Python-2.7.3/Python/compile.c:3431:9 clang-analyzer Access to field 'b_seen' results in a dereference of a null pointer (loaded from variable 'b')
   1 /*
   2  * This file compiles an abstract syntax tree (AST) into Python bytecode.
   3  *
   4  * The primary entry point is PyAST_Compile(), which returns a
   5  * PyCodeObject.  The compiler makes several passes to build the code
   6  * object:
   7  *   1. Checks for future statements.  See future.c
   8  *   2. Builds a symbol table.  See symtable.c.
   9  *   3. Generate code for basic blocks.  See compiler_mod() in this file.
  10  *   4. Assemble the basic blocks into final code.  See assemble() in
  11  *      this file.
  12  *   5. Optimize the byte code (peephole optimizations).  See peephole.c
  13  *
  14  * Note that compiler_mod() suggests module, but the module ast type
  15  * (mod_ty) has cases for expressions and interactive statements.
  16  *
  17  * CAUTION: The VISIT_* macros abort the current function when they
  18  * encounter a problem. So don't invoke them when there is memory
  19  * which needs to be released. Code blocks are OK, as the compiler
  20  * structure takes care of releasing those.  Use the arena to manage
  21  * objects.
  22  */
  23 
  24 #include "Python.h"
  25 
  26 #include "Python-ast.h"
  27 #include "node.h"
  28 #include "pyarena.h"
  29 #include "ast.h"
  30 #include "code.h"
  31 #include "compile.h"
  32 #include "symtable.h"
  33 #include "opcode.h"
  34 
  35 int Py_OptimizeFlag = 0;
  36 
  37 #define DEFAULT_BLOCK_SIZE 16
  38 #define DEFAULT_BLOCKS 8
  39 #define DEFAULT_CODE_SIZE 128
  40 #define DEFAULT_LNOTAB_SIZE 16
  41 
  42 #define COMP_GENEXP   0
  43 #define COMP_SETCOMP  1
  44 #define COMP_DICTCOMP 2
  45 
  46 struct instr {
  47     unsigned i_jabs : 1;
  48     unsigned i_jrel : 1;
  49     unsigned i_hasarg : 1;
  50     unsigned char i_opcode;
  51     int i_oparg;
  52     struct basicblock_ *i_target; /* target block (if jump instruction) */
  53     int i_lineno;
  54 };
  55 
  56 typedef struct basicblock_ {
  57     /* Each basicblock in a compilation unit is linked via b_list in the
  58        reverse order that the block are allocated.  b_list points to the next
  59        block, not to be confused with b_next, which is next by control flow. */
  60     struct basicblock_ *b_list;
  61     /* number of instructions used */
  62     int b_iused;
  63     /* length of instruction array (b_instr) */
  64     int b_ialloc;
  65     /* pointer to an array of instructions, initially NULL */
  66     struct instr *b_instr;
  67     /* If b_next is non-NULL, it is a pointer to the next
  68        block reached by normal control flow. */
  69     struct basicblock_ *b_next;
  70     /* b_seen is used to perform a DFS of basicblocks. */
  71     unsigned b_seen : 1;
  72     /* b_return is true if a RETURN_VALUE opcode is inserted. */
  73     unsigned b_return : 1;
  74     /* depth of stack upon entry of block, computed by stackdepth() */
  75     int b_startdepth;
  76     /* instruction offset for block, computed by assemble_jump_offsets() */
  77     int b_offset;
  78 } basicblock;
  79 
  80 /* fblockinfo tracks the current frame block.
  81 
  82 A frame block is used to handle loops, try/except, and try/finally.
  83 It's called a frame block to distinguish it from a basic block in the
  84 compiler IR.
  85 */
  86 
  87 enum fblocktype { LOOP, EXCEPT, FINALLY_TRY, FINALLY_END };
  88 
  89 struct fblockinfo {
  90     enum fblocktype fb_type;
  91     basicblock *fb_block;
  92 };
  93 
  94 /* The following items change on entry and exit of code blocks.
  95    They must be saved and restored when returning to a block.
  96 */
  97 struct compiler_unit {
  98     PySTEntryObject *u_ste;
  99 
 100     PyObject *u_name;
 101     /* The following fields are dicts that map objects to
 102        the index of them in co_XXX.      The index is used as
 103        the argument for opcodes that refer to those collections.
 104     */
 105     PyObject *u_consts;    /* all constants */
 106     PyObject *u_names;     /* all names */
 107     PyObject *u_varnames;  /* local variables */
 108     PyObject *u_cellvars;  /* cell variables */
 109     PyObject *u_freevars;  /* free variables */
 110 
 111     PyObject *u_private;        /* for private name mangling */
 112 
 113     int u_argcount;        /* number of arguments for block */
 114     /* Pointer to the most recently allocated block.  By following b_list
 115        members, you can reach all early allocated blocks. */
 116     basicblock *u_blocks;
 117     basicblock *u_curblock; /* pointer to current block */
 118 
 119     int u_nfblocks;
 120     struct fblockinfo u_fblock[CO_MAXBLOCKS];
 121 
 122     int u_firstlineno; /* the first lineno of the block */
 123     int u_lineno;          /* the lineno for the current stmt */
 124     bool u_lineno_set; /* boolean to indicate whether instr
 125                           has been generated with current lineno */
 126 };
 127 
 128 /* This struct captures the global state of a compilation.
 129 
 130 The u pointer points to the current compilation unit, while units
 131 for enclosing blocks are stored in c_stack.     The u and c_stack are
 132 managed by compiler_enter_scope() and compiler_exit_scope().
 133 */
 134 
 135 struct compiler {
 136     const char *c_filename;
 137     struct symtable *c_st;
 138     PyFutureFeatures *c_future; /* pointer to module's __future__ */
 139     PyCompilerFlags *c_flags;
 140 
 141     int c_interactive;           /* true if in interactive mode */
 142     int c_nestlevel;
 143 
 144     struct compiler_unit *u; /* compiler state for current block */
 145     PyObject *c_stack;           /* Python list holding compiler_unit ptrs */
 146     PyArena *c_arena;            /* pointer to memory allocation arena */
 147 };
 148 
 149 static int compiler_enter_scope(struct compiler *, identifier, void *, int);
 150 static void compiler_free(struct compiler *);
 151 static basicblock *compiler_new_block(struct compiler *);
 152 static int compiler_next_instr(struct compiler *, basicblock *);
 153 static int compiler_addop(struct compiler *, int);
 154 static int compiler_addop_o(struct compiler *, int, PyObject *, PyObject *);
 155 static int compiler_addop_i(struct compiler *, int, int);
 156 static int compiler_addop_j(struct compiler *, int, basicblock *, int);
 157 static basicblock *compiler_use_new_block(struct compiler *);
 158 static int compiler_error(struct compiler *, const char *);
 159 static int compiler_nameop(struct compiler *, identifier, expr_context_ty);
 160 
 161 static PyCodeObject *compiler_mod(struct compiler *, mod_ty);
 162 static int compiler_visit_stmt(struct compiler *, stmt_ty);
 163 static int compiler_visit_keyword(struct compiler *, keyword_ty);
 164 static int compiler_visit_expr(struct compiler *, expr_ty);
 165 static int compiler_augassign(struct compiler *, stmt_ty);
 166 static int compiler_visit_slice(struct compiler *, slice_ty,
 167                                 expr_context_ty);
 168 
 169 static int compiler_push_fblock(struct compiler *, enum fblocktype,
 170                                 basicblock *);
 171 static void compiler_pop_fblock(struct compiler *, enum fblocktype,
 172                                 basicblock *);
 173 /* Returns true if there is a loop on the fblock stack. */
 174 static int compiler_in_loop(struct compiler *);
 175 
 176 static int inplace_binop(struct compiler *, operator_ty);
 177 static int expr_constant(expr_ty e);
 178 
 179 static int compiler_with(struct compiler *, stmt_ty);
 180 
 181 static PyCodeObject *assemble(struct compiler *, int addNone);
 182 static PyObject *__doc__;
 183 
 184 #define COMPILER_CAPSULE_NAME_COMPILER_UNIT "compile.c compiler unit"
 185 
 186 PyObject *
 187 _Py_Mangle(PyObject *privateobj, PyObject *ident)
 188 {
 189     /* Name mangling: __private becomes _classname__private.
 190        This is independent from how the name is used. */
 191     const char *p, *name = PyString_AsString(ident);
 192     char *buffer;
 193     size_t nlen, plen;
 194     if (privateobj == NULL || !PyString_Check(privateobj) ||
 195         name == NULL || name[0] != '_' || name[1] != '_') {
 196         Py_INCREF(ident);
 197         return ident;
 198     }
 199     p = PyString_AsString(privateobj);
 200     nlen = strlen(name);
 201     /* Don't mangle __id__ or names with dots.
 202 
 203        The only time a name with a dot can occur is when
 204        we are compiling an import statement that has a
 205        package name.
 206 
 207        TODO(jhylton): Decide whether we want to support
 208        mangling of the module name, e.g. __M.X.
 209     */
 210     if ((name[nlen-1] == '_' && name[nlen-2] == '_')
 211         || strchr(name, '.')) {
 212         Py_INCREF(ident);
 213         return ident; /* Don't mangle __whatever__ */
 214     }
 215     /* Strip leading underscores from class name */
 216     while (*p == '_')
 217         p++;
 218     if (*p == '\0') {
 219         Py_INCREF(ident);
 220         return ident; /* Don't mangle if class is just underscores */
 221     }
 222     plen = strlen(p);
 223 
 224     assert(1 <= PY_SSIZE_T_MAX - nlen);
 225     assert(1 + nlen <= PY_SSIZE_T_MAX - plen);
 226 
 227     ident = PyString_FromStringAndSize(NULL, 1 + nlen + plen);
 228     if (!ident)
 229         return 0;
 230     /* ident = "_" + p[:plen] + name # i.e. 1+plen+nlen bytes */
 231     buffer = PyString_AS_STRING(ident);
 232     buffer[0] = '_';
 233     strncpy(buffer+1, p, plen);
 234     strcpy(buffer+1+plen, name);
 235     return ident;
 236 }
 237 
 238 static int
 239 compiler_init(struct compiler *c)
 240 {
 241     memset(c, 0, sizeof(struct compiler));
 242 
 243     c->c_stack = PyList_New(0);
 244     if (!c->c_stack)
 245         return 0;
 246 
 247     return 1;
 248 }
 249 
 250 PyCodeObject *
 251 PyAST_Compile(mod_ty mod, const char *filename, PyCompilerFlags *flags,
 252               PyArena *arena)
 253 {
 254     struct compiler c;
 255     PyCodeObject *co = NULL;
 256     PyCompilerFlags local_flags;
 257     int merged;
 258 
 259     if (!__doc__) {
 260         __doc__ = PyString_InternFromString("__doc__");
 261         if (!__doc__)
 262             return NULL;
 263     }
 264 
 265     if (!compiler_init(&c))
 266         return NULL;
 267     c.c_filename = filename;
 268     c.c_arena = arena;
 269     c.c_future = PyFuture_FromAST(mod, filename);
 270     if (c.c_future == NULL)
 271         goto finally;
 272     if (!flags) {
 273         local_flags.cf_flags = 0;
 274         flags = &local_flags;
 275     }
 276     merged = c.c_future->ff_features | flags->cf_flags;
 277     c.c_future->ff_features = merged;
 278     flags->cf_flags = merged;
 279     c.c_flags = flags;
 280     c.c_nestlevel = 0;
 281 
 282     c.c_st = PySymtable_Build(mod, filename, c.c_future);
 283     if (c.c_st == NULL) {
 284         if (!PyErr_Occurred())
 285             PyErr_SetString(PyExc_SystemError, "no symtable");
 286         goto finally;
 287     }
 288 
 289     co = compiler_mod(&c, mod);
 290 
 291  finally:
 292     compiler_free(&c);
 293     assert(co || PyErr_Occurred());
 294     return co;
 295 }
 296 
 297 PyCodeObject *
 298 PyNode_Compile(struct _node *n, const char *filename)
 299 {
 300     PyCodeObject *co = NULL;
 301     mod_ty mod;
 302     PyArena *arena = PyArena_New();
 303     if (!arena)
 304         return NULL;
 305     mod = PyAST_FromNode(n, NULL, filename, arena);
 306     if (mod)
 307         co = PyAST_Compile(mod, filename, NULL, arena);
 308     PyArena_Free(arena);
 309     return co;
 310 }
 311 
 312 static void
 313 compiler_free(struct compiler *c)
 314 {
 315     if (c->c_st)
 316         PySymtable_Free(c->c_st);
 317     if (c->c_future)
 318         PyObject_Free(c->c_future);
 319     Py_DECREF(c->c_stack);
 320 }
 321 
 322 static PyObject *
 323 list2dict(PyObject *list)
 324 {
 325     Py_ssize_t i, n;
 326     PyObject *v, *k;
 327     PyObject *dict = PyDict_New();
 328     if (!dict) return NULL;
 329 
 330     n = PyList_Size(list);
 331     for (i = 0; i < n; i++) {
 332         v = PyInt_FromLong(i);
 333         if (!v) {
 334             Py_DECREF(dict);
 335             return NULL;
 336         }
 337         k = PyList_GET_ITEM(list, i);
 338         k = PyTuple_Pack(2, k, k->ob_type);
 339         if (k == NULL || PyDict_SetItem(dict, k, v) < 0) {
 340             Py_XDECREF(k);
 341             Py_DECREF(v);
 342             Py_DECREF(dict);
 343             return NULL;
 344         }
 345         Py_DECREF(k);
 346         Py_DECREF(v);
 347     }
 348     return dict;
 349 }
 350 
 351 /* Return new dict containing names from src that match scope(s).
 352 
 353 src is a symbol table dictionary.  If the scope of a name matches
 354 either scope_type or flag is set, insert it into the new dict.  The
 355 values are integers, starting at offset and increasing by one for
 356 each key.
 357 */
 358 
 359 static PyObject *
 360 dictbytype(PyObject *src, int scope_type, int flag, int offset)
 361 {
 362     Py_ssize_t pos = 0, i = offset, scope;
 363     PyObject *k, *v, *dest = PyDict_New();
 364 
 365     assert(offset >= 0);
 366     if (dest == NULL)
 367         return NULL;
 368 
 369     while (PyDict_Next(src, &pos, &k, &v)) {
 370         /* XXX this should probably be a macro in symtable.h */
 371         assert(PyInt_Check(v));
 372         scope = (PyInt_AS_LONG(v) >> SCOPE_OFF) & SCOPE_MASK;
 373 
 374         if (scope == scope_type || PyInt_AS_LONG(v) & flag) {
 375             PyObject *tuple, *item = PyInt_FromLong(i);
 376             if (item == NULL) {
 377                 Py_DECREF(dest);
 378                 return NULL;
 379             }
 380             i++;
 381             tuple = PyTuple_Pack(2, k, k->ob_type);
 382             if (!tuple || PyDict_SetItem(dest, tuple, item) < 0) {
 383                 Py_DECREF(item);
 384                 Py_DECREF(dest);
 385                 Py_XDECREF(tuple);
 386                 return NULL;
 387             }
 388             Py_DECREF(item);
 389             Py_DECREF(tuple);
 390         }
 391     }
 392     return dest;
 393 }
 394 
 395 static void
 396 compiler_unit_check(struct compiler_unit *u)
 397 {
 398     basicblock *block;
 399     for (block = u->u_blocks; block != NULL; block = block->b_list) {
 400         assert((void *)block != (void *)0xcbcbcbcb);
 401         assert((void *)block != (void *)0xfbfbfbfb);
 402         assert((void *)block != (void *)0xdbdbdbdb);
 403         if (block->b_instr != NULL) {
 404             assert(block->b_ialloc > 0);
 405             assert(block->b_iused > 0);
 406             assert(block->b_ialloc >= block->b_iused);
 407         }
 408         else {
 409             assert (block->b_iused == 0);
 410             assert (block->b_ialloc == 0);
 411         }
 412     }
 413 }
 414 
 415 static void
 416 compiler_unit_free(struct compiler_unit *u)
 417 {
 418     basicblock *b, *next;
 419 
 420     compiler_unit_check(u);
 421     b = u->u_blocks;
 422     while (b != NULL) {
 423         if (b->b_instr)
 424             PyObject_Free((void *)b->b_instr);
 425         next = b->b_list;
 426         PyObject_Free((void *)b);
 427         b = next;
 428     }
 429     Py_CLEAR(u->u_ste);
 430     Py_CLEAR(u->u_name);
 431     Py_CLEAR(u->u_consts);
 432     Py_CLEAR(u->u_names);
 433     Py_CLEAR(u->u_varnames);
 434     Py_CLEAR(u->u_freevars);
 435     Py_CLEAR(u->u_cellvars);
 436     Py_CLEAR(u->u_private);
 437     PyObject_Free(u);
 438 }
 439 
 440 static int
 441 compiler_enter_scope(struct compiler *c, identifier name, void *key,
 442                      int lineno)
 443 {
 444     struct compiler_unit *u;
 445 
 446     u = (struct compiler_unit *)PyObject_Malloc(sizeof(
 447                                             struct compiler_unit));
 448     if (!u) {
 449         PyErr_NoMemory();
 450         return 0;
 451     }
 452     memset(u, 0, sizeof(struct compiler_unit));
 453     u->u_argcount = 0;
 454     u->u_ste = PySymtable_Lookup(c->c_st, key);
 455     if (!u->u_ste) {
 456         compiler_unit_free(u);
 457         return 0;
 458     }
 459     Py_INCREF(name);
 460     u->u_name = name;
 461     u->u_varnames = list2dict(u->u_ste->ste_varnames);
 462     u->u_cellvars = dictbytype(u->u_ste->ste_symbols, CELL, 0, 0);
 463     if (!u->u_varnames || !u->u_cellvars) {
 464         compiler_unit_free(u);
 465         return 0;
 466     }
 467 
 468     u->u_freevars = dictbytype(u->u_ste->ste_symbols, FREE, DEF_FREE_CLASS,
 469                                PyDict_Size(u->u_cellvars));
 470     if (!u->u_freevars) {
 471         compiler_unit_free(u);
 472         return 0;
 473     }
 474 
 475     u->u_blocks = NULL;
 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 *capsule = PyCapsule_New(c->u, COMPILER_CAPSULE_NAME_COMPILER_UNIT, NULL);
 496         if (!capsule || PyList_Append(c->c_stack, capsule) < 0) {
 497             Py_XDECREF(capsule);
 498             compiler_unit_free(u);
 499             return 0;
 500         }
 501         Py_DECREF(capsule);
 502         u->u_private = c->u->u_private;
 503         Py_XINCREF(u->u_private);
 504     }
 505     c->u = u;
 506 
 507     c->c_nestlevel++;
 508     if (compiler_use_new_block(c) == NULL)
 509         return 0;
 510 
 511     return 1;
 512 }
 513 
 514 static void
 515 compiler_exit_scope(struct compiler *c)
 516 {
 517     int n;
 518     PyObject *capsule;
 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         capsule = PyList_GET_ITEM(c->c_stack, n);
 526         c->u = (struct compiler_unit *)PyCapsule_GetPointer(capsule, COMPILER_CAPSULE_NAME_COMPILER_UNIT);
 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 block and return a pointer to it.
 539    Returns NULL on error.
 540 */
 541 
 542 static basicblock *
 543 compiler_new_block(struct compiler *c)
 544 {
 545     basicblock *b;
 546     struct compiler_unit *u;
 547 
 548     u = c->u;
 549     b = (basicblock *)PyObject_Malloc(sizeof(basicblock));
 550     if (b == NULL) {
 551         PyErr_NoMemory();
 552         return NULL;
 553     }
 554     memset((void *)b, 0, sizeof(basicblock));
 555     /* Extend the singly linked list of blocks with new block. */
 556     b->b_list = u->u_blocks;
 557     u->u_blocks = b;
 558     return b;
 559 }
 560 
 561 static basicblock *
 562 compiler_use_new_block(struct compiler *c)
 563 {
 564     basicblock *block = compiler_new_block(c);
 565     if (block == NULL)
 566         return NULL;
 567     c->u->u_curblock = block;
 568     return block;
 569 }
 570 
 571 static basicblock *
 572 compiler_next_block(struct compiler *c)
 573 {
 574     basicblock *block = compiler_new_block(c);
 575     if (block == NULL)
 576         return NULL;
 577     c->u->u_curblock->b_next = block;
 578     c->u->u_curblock = block;
 579     return block;
 580 }
 581 
 582 static basicblock *
 583 compiler_use_next_block(struct compiler *c, basicblock *block)
 584 {
 585     assert(block != NULL);
 586     c->u->u_curblock->b_next = block;
 587     c->u->u_curblock = block;
 588     return block;
 589 }
 590 
 591 /* Returns the offset of the next instruction in the current block's
 592    b_instr array.  Resizes the b_instr as necessary.
 593    Returns -1 on failure.
 594 */
 595 
 596 static int
 597 compiler_next_instr(struct compiler *c, basicblock *b)
 598 {
 599     assert(b != NULL);
 600     if (b->b_instr == NULL) {
 601         b->b_instr = (struct instr *)PyObject_Malloc(
 602                          sizeof(struct instr) * DEFAULT_BLOCK_SIZE);
 603         if (b->b_instr == NULL) {
 604             PyErr_NoMemory();
 605             return -1;
 606         }
 607         b->b_ialloc = DEFAULT_BLOCK_SIZE;
 608         memset((char *)b->b_instr, 0,
 609                sizeof(struct instr) * DEFAULT_BLOCK_SIZE);
 610     }
 611     else if (b->b_iused == b->b_ialloc) {
 612         struct instr *tmp;
 613         size_t oldsize, newsize;
 614         oldsize = b->b_ialloc * sizeof(struct instr);
 615         newsize = oldsize << 1;
 616 
 617         if (oldsize > (PY_SIZE_MAX >> 1)) {
 618             PyErr_NoMemory();
 619             return -1;
 620         }
 621 
 622         if (newsize == 0) {
 623             PyErr_NoMemory();
 624             return -1;
 625         }
 626         b->b_ialloc <<= 1;
 627         tmp = (struct instr *)PyObject_Realloc(
 628                                         (void *)b->b_instr, newsize);
 629         if (tmp == NULL) {
 630             PyErr_NoMemory();
 631             return -1;
 632         }
 633         b->b_instr = tmp;
 634         memset((char *)b->b_instr + oldsize, 0, newsize - oldsize);
 635     }
 636     return b->b_iused++;
 637 }
 638 
 639 /* Set the i_lineno member of the instruction at offset off if the
 640    line number for the current expression/statement has not
 641    already been set.  If it has been set, the call has no effect.
 642 
 643    The line number is reset in the following cases:
 644    - when entering a new scope
 645    - on each statement
 646    - on each expression that start a new line
 647    - before the "except" clause
 648    - before the "for" and "while" expressions
 649 */
 650 
 651 static void
 652 compiler_set_lineno(struct compiler *c, int off)
 653 {
 654     basicblock *b;
 655     if (c->u->u_lineno_set)
 656         return;
 657     c->u->u_lineno_set = true;
 658     b = c->u->u_curblock;
 659     b->b_instr[off].i_lineno = c->u->u_lineno;
 660 }
 661 
 662 static int
 663 opcode_stack_effect(int opcode, int oparg)
 664 {
 665     switch (opcode) {
 666         case POP_TOP:
 667             return -1;
 668         case ROT_TWO:
 669         case ROT_THREE:
 670             return 0;
 671         case DUP_TOP:
 672             return 1;
 673         case ROT_FOUR:
 674             return 0;
 675 
 676         case UNARY_POSITIVE:
 677         case UNARY_NEGATIVE:
 678         case UNARY_NOT:
 679         case UNARY_CONVERT:
 680         case UNARY_INVERT:
 681             return 0;
 682 
 683         case SET_ADD:
 684         case LIST_APPEND:
 685             return -1;
 686 
 687         case MAP_ADD:
 688             return -2;
 689 
 690         case BINARY_POWER:
 691         case BINARY_MULTIPLY:
 692         case BINARY_DIVIDE:
 693         case BINARY_MODULO:
 694         case BINARY_ADD:
 695         case BINARY_SUBTRACT:
 696         case BINARY_SUBSCR:
 697         case BINARY_FLOOR_DIVIDE:
 698         case BINARY_TRUE_DIVIDE:
 699             return -1;
 700         case INPLACE_FLOOR_DIVIDE:
 701         case INPLACE_TRUE_DIVIDE:
 702             return -1;
 703 
 704         case SLICE+0:
 705             return 0;
 706         case SLICE+1:
 707             return -1;
 708         case SLICE+2:
 709             return -1;
 710         case SLICE+3:
 711             return -2;
 712 
 713         case STORE_SLICE+0:
 714             return -2;
 715         case STORE_SLICE+1:
 716             return -3;
 717         case STORE_SLICE+2:
 718             return -3;
 719         case STORE_SLICE+3:
 720             return -4;
 721 
 722         case DELETE_SLICE+0:
 723             return -1;
 724         case DELETE_SLICE+1:
 725             return -2;
 726         case DELETE_SLICE+2:
 727             return -2;
 728         case DELETE_SLICE+3:
 729             return -3;
 730 
 731         case INPLACE_ADD:
 732         case INPLACE_SUBTRACT:
 733         case INPLACE_MULTIPLY:
 734         case INPLACE_DIVIDE:
 735         case INPLACE_MODULO:
 736             return -1;
 737         case STORE_SUBSCR:
 738             return -3;
 739         case STORE_MAP:
 740             return -2;
 741         case DELETE_SUBSCR:
 742             return -2;
 743 
 744         case BINARY_LSHIFT:
 745         case BINARY_RSHIFT:
 746         case BINARY_AND:
 747         case BINARY_XOR:
 748         case BINARY_OR:
 749             return -1;
 750         case INPLACE_POWER:
 751             return -1;
 752         case GET_ITER:
 753             return 0;
 754 
 755         case PRINT_EXPR:
 756             return -1;
 757         case PRINT_ITEM:
 758             return -1;
 759         case PRINT_NEWLINE:
 760             return 0;
 761         case PRINT_ITEM_TO:
 762             return -2;
 763         case PRINT_NEWLINE_TO:
 764             return -1;
 765         case INPLACE_LSHIFT:
 766         case INPLACE_RSHIFT:
 767         case INPLACE_AND:
 768         case INPLACE_XOR:
 769         case INPLACE_OR:
 770             return -1;
 771         case BREAK_LOOP:
 772             return 0;
 773         case SETUP_WITH:
 774             return 4;
 775         case WITH_CLEANUP:
 776             return -1; /* XXX Sometimes more */
 777         case LOAD_LOCALS:
 778             return 1;
 779         case RETURN_VALUE:
 780             return -1;
 781         case IMPORT_STAR:
 782             return -1;
 783         case EXEC_STMT:
 784             return -3;
 785         case YIELD_VALUE:
 786             return 0;
 787 
 788         case POP_BLOCK:
 789             return 0;
 790         case END_FINALLY:
 791             return -3; /* or -1 or -2 if no exception occurred or
 792                           return/break/continue */
 793         case BUILD_CLASS:
 794             return -2;
 795 
 796         case STORE_NAME:
 797             return -1;
 798         case DELETE_NAME:
 799             return 0;
 800         case UNPACK_SEQUENCE:
 801             return oparg-1;
 802         case FOR_ITER:
 803             return 1; /* or -1, at end of iterator */
 804 
 805         case STORE_ATTR:
 806             return -2;
 807         case DELETE_ATTR:
 808             return -1;
 809         case STORE_GLOBAL:
 810             return -1;
 811         case DELETE_GLOBAL:
 812             return 0;
 813         case DUP_TOPX:
 814             return oparg;
 815         case LOAD_CONST:
 816             return 1;
 817         case LOAD_NAME:
 818             return 1;
 819         case BUILD_TUPLE:
 820         case BUILD_LIST:
 821         case BUILD_SET:
 822             return 1-oparg;
 823         case BUILD_MAP:
 824             return 1;
 825         case LOAD_ATTR:
 826             return 0;
 827         case COMPARE_OP:
 828             return -1;
 829         case IMPORT_NAME:
 830             return -1;
 831         case IMPORT_FROM:
 832             return 1;
 833 
 834         case JUMP_FORWARD:
 835         case JUMP_IF_TRUE_OR_POP:  /* -1 if jump not taken */
 836         case JUMP_IF_FALSE_OR_POP:  /*  "" */
 837         case JUMP_ABSOLUTE:
 838             return 0;
 839 
 840         case POP_JUMP_IF_FALSE:
 841         case POP_JUMP_IF_TRUE:
 842             return -1;
 843 
 844         case LOAD_GLOBAL:
 845             return 1;
 846 
 847         case CONTINUE_LOOP:
 848             return 0;
 849         case SETUP_LOOP:
 850         case SETUP_EXCEPT:
 851         case SETUP_FINALLY:
 852             return 0;
 853 
 854         case LOAD_FAST:
 855             return 1;
 856         case STORE_FAST:
 857             return -1;
 858         case DELETE_FAST:
 859             return 0;
 860 
 861         case RAISE_VARARGS:
 862             return -oparg;
 863 #define NARGS(o) (((o) % 256) + 2*((o) / 256))
 864         case CALL_FUNCTION:
 865             return -NARGS(oparg);
 866         case CALL_FUNCTION_VAR:
 867         case CALL_FUNCTION_KW:
 868             return -NARGS(oparg)-1;
 869         case CALL_FUNCTION_VAR_KW:
 870             return -NARGS(oparg)-2;
 871 #undef NARGS
 872         case MAKE_FUNCTION:
 873             return -oparg;
 874         case BUILD_SLICE:
 875             if (oparg == 3)
 876                 return -2;
 877             else
 878                 return -1;
 879 
 880         case MAKE_CLOSURE:
 881             return -oparg-1;
 882         case LOAD_CLOSURE:
 883             return 1;
 884         case LOAD_DEREF:
 885             return 1;
 886         case STORE_DEREF:
 887             return -1;
 888         default:
 889             fprintf(stderr, "opcode = %d\n", opcode);
 890             Py_FatalError("opcode_stack_effect()");
 891 
 892     }
 893     return 0; /* not reachable */
 894 }
 895 
 896 /* Add an opcode with no argument.
 897    Returns 0 on failure, 1 on success.
 898 */
 899 
 900 static int
 901 compiler_addop(struct compiler *c, int opcode)
 902 {
 903     basicblock *b;
 904     struct instr *i;
 905     int off;
 906     off = compiler_next_instr(c, c->u->u_curblock);
 907     if (off < 0)
 908         return 0;
 909     b = c->u->u_curblock;
 910     i = &b->b_instr[off];
 911     i->i_opcode = opcode;
 912     i->i_hasarg = 0;
 913     if (opcode == RETURN_VALUE)
 914         b->b_return = 1;
 915     compiler_set_lineno(c, off);
 916     return 1;
 917 }
 918 
 919 static int
 920 compiler_add_o(struct compiler *c, PyObject *dict, PyObject *o)
 921 {
 922     PyObject *t, *v;
 923     Py_ssize_t arg;
 924     double d;
 925 
 926     /* necessary to make sure types aren't coerced (e.g., int and long) */
 927     /* _and_ to distinguish 0.0 from -0.0 e.g. on IEEE platforms */
 928     if (PyFloat_Check(o)) {
 929         d = PyFloat_AS_DOUBLE(o);
 930         /* all we need is to make the tuple different in either the 0.0
 931          * or -0.0 case from all others, just to avoid the "coercion".
 932          */
 933         if (d == 0.0 && copysign(1.0, d) < 0.0)
 934             t = PyTuple_Pack(3, o, o->ob_type, Py_None);
 935         else
 936             t = PyTuple_Pack(2, o, o->ob_type);
 937     }
 938 #ifndef WITHOUT_COMPLEX
 939     else if (PyComplex_Check(o)) {
 940         Py_complex z;
 941         int real_negzero, imag_negzero;
 942         /* For the complex case we must make complex(x, 0.)
 943            different from complex(x, -0.) and complex(0., y)
 944            different from complex(-0., y), for any x and y.
 945            All four complex zeros must be distinguished.*/
 946         z = PyComplex_AsCComplex(o);
 947         real_negzero = z.real == 0.0 && copysign(1.0, z.real) < 0.0;
 948         imag_negzero = z.imag == 0.0 && copysign(1.0, z.imag) < 0.0;
 949         if (real_negzero && imag_negzero) {
 950             t = PyTuple_Pack(5, o, o->ob_type,
 951                              Py_None, Py_None, Py_None);
 952         }
 953         else if (imag_negzero) {
 954             t = PyTuple_Pack(4, o, o->ob_type, Py_None, Py_None);
 955         }
 956         else if (real_negzero) {
 957             t = PyTuple_Pack(3, o, o->ob_type, Py_None);
 958         }
 959         else {
 960             t = PyTuple_Pack(2, o, o->ob_type);
 961         }
 962     }
 963 #endif /* WITHOUT_COMPLEX */
 964     else {
 965         t = PyTuple_Pack(2, o, o->ob_type);
 966     }
 967     if (t == NULL)
 968         return -1;
 969 
 970     v = PyDict_GetItem(dict, t);
 971     if (!v) {
 972         arg = PyDict_Size(dict);
 973         v = PyInt_FromLong(arg);
 974         if (!v) {
 975             Py_DECREF(t);
 976             return -1;
 977         }
 978         if (PyDict_SetItem(dict, t, v) < 0) {
 979             Py_DECREF(t);
 980             Py_DECREF(v);
 981             return -1;
 982         }
 983         Py_DECREF(v);
 984     }
 985     else
 986         arg = PyInt_AsLong(v);
 987     Py_DECREF(t);
 988     return arg;
 989 }
 990 
 991 static int
 992 compiler_addop_o(struct compiler *c, int opcode, PyObject *dict,
 993                      PyObject *o)
 994 {
 995     int arg = compiler_add_o(c, dict, o);
 996     if (arg < 0)
 997         return 0;
 998     return compiler_addop_i(c, opcode, arg);
 999 }
1000 
1001 static int
1002 compiler_addop_name(struct compiler *c, int opcode, PyObject *dict,
1003                     PyObject *o)
1004 {
1005     int arg;
1006     PyObject *mangled = _Py_Mangle(c->u->u_private, o);
1007     if (!mangled)
1008         return 0;
1009     arg = compiler_add_o(c, dict, mangled);
1010     Py_DECREF(mangled);
1011     if (arg < 0)
1012         return 0;
1013     return compiler_addop_i(c, opcode, arg);
1014 }
1015 
1016 /* Add an opcode with an integer argument.
1017    Returns 0 on failure, 1 on success.
1018 */
1019 
1020 static int
1021 compiler_addop_i(struct compiler *c, int opcode, int oparg)
1022 {
1023     struct instr *i;
1024     int off;
1025     off = compiler_next_instr(c, c->u->u_curblock);
Access to field 'u_curblock' results in a dereference of a null pointer (loaded from field 'u')
(emitted by clang-analyzer)

TODO: a detailed trace is available in the data model (not yet rendered in this report)

Access to field 'u_curblock' results in a dereference of a null pointer (loaded from field 'u')
(emitted by clang-analyzer)

TODO: a detailed trace is available in the data model (not yet rendered in this report)

Access to field 'u_curblock' results in a dereference of a null pointer (loaded from field 'u')
(emitted by clang-analyzer)

TODO: a detailed trace is available in the data model (not yet rendered in this report)

1026 if (off < 0) 1027 return 0; 1028 i = &c->u->u_curblock->b_instr[off]; 1029 i->i_opcode = opcode; 1030 i->i_oparg = oparg; 1031 i->i_hasarg = 1; 1032 compiler_set_lineno(c, off); 1033 return 1; 1034 } 1035 1036 static int 1037 compiler_addop_j(struct compiler *c, int opcode, basicblock *b, int absolute) 1038 { 1039 struct instr *i; 1040 int off; 1041 1042 assert(b != NULL); 1043 off = compiler_next_instr(c, c->u->u_curblock); 1044 if (off < 0) 1045 return 0; 1046 i = &c->u->u_curblock->b_instr[off]; 1047 i->i_opcode = opcode; 1048 i->i_target = b; 1049 i->i_hasarg = 1; 1050 if (absolute) 1051 i->i_jabs = 1; 1052 else 1053 i->i_jrel = 1; 1054 compiler_set_lineno(c, off); 1055 return 1; 1056 } 1057 1058 /* The distinction between NEW_BLOCK and NEXT_BLOCK is subtle. (I'd 1059 like to find better names.) NEW_BLOCK() creates a new block and sets 1060 it as the current block. NEXT_BLOCK() also creates an implicit jump 1061 from the current block to the new block. 1062 */ 1063 1064 /* The returns inside these macros make it impossible to decref objects 1065 created in the local function. Local objects should use the arena. 1066 */ 1067 1068 1069 #define NEW_BLOCK(C) { \ 1070 if (compiler_use_new_block((C)) == NULL) \ 1071 return 0; \ 1072 } 1073 1074 #define NEXT_BLOCK(C) { \ 1075 if (compiler_next_block((C)) == NULL) \ 1076 return 0; \ 1077 } 1078 1079 #define ADDOP(C, OP) { \ 1080 if (!compiler_addop((C), (OP))) \ 1081 return 0; \ 1082 } 1083 1084 #define ADDOP_IN_SCOPE(C, OP) { \ 1085 if (!compiler_addop((C), (OP))) { \ 1086 compiler_exit_scope(c); \ 1087 return 0; \ 1088 } \ 1089 } 1090 1091 #define ADDOP_O(C, OP, O, TYPE) { \ 1092 if (!compiler_addop_o((C), (OP), (C)->u->u_ ## TYPE, (O))) \ 1093 return 0; \ 1094 } 1095 1096 #define ADDOP_NAME(C, OP, O, TYPE) { \ 1097 if (!compiler_addop_name((C), (OP), (C)->u->u_ ## TYPE, (O))) \ 1098 return 0; \ 1099 } 1100 1101 #define ADDOP_I(C, OP, O) { \ 1102 if (!compiler_addop_i((C), (OP), (O))) \ 1103 return 0; \ 1104 } 1105 1106 #define ADDOP_JABS(C, OP, O) { \ 1107 if (!compiler_addop_j((C), (OP), (O), 1)) \ 1108 return 0; \ 1109 } 1110 1111 #define ADDOP_JREL(C, OP, O) { \ 1112 if (!compiler_addop_j((C), (OP), (O), 0)) \ 1113 return 0; \ 1114 } 1115 1116 /* VISIT and VISIT_SEQ takes an ASDL type as their second argument. They use 1117 the ASDL name to synthesize the name of the C type and the visit function. 1118 */ 1119 1120 #define VISIT(C, TYPE, V) {\ 1121 if (!compiler_visit_ ## TYPE((C), (V))) \ 1122 return 0; \ 1123 } 1124 1125 #define VISIT_IN_SCOPE(C, TYPE, V) {\ 1126 if (!compiler_visit_ ## TYPE((C), (V))) { \ 1127 compiler_exit_scope(c); \ 1128 return 0; \ 1129 } \ 1130 } 1131 1132 #define VISIT_SLICE(C, V, CTX) {\ 1133 if (!compiler_visit_slice((C), (V), (CTX))) \ 1134 return 0; \ 1135 } 1136 1137 #define VISIT_SEQ(C, TYPE, SEQ) { \ 1138 int _i; \ 1139 asdl_seq *seq = (SEQ); /* avoid variable capture */ \ 1140 for (_i = 0; _i < asdl_seq_LEN(seq); _i++) { \ 1141 TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, _i); \ 1142 if (!compiler_visit_ ## TYPE((C), elt)) \ 1143 return 0; \ 1144 } \ 1145 } 1146 1147 #define VISIT_SEQ_IN_SCOPE(C, TYPE, SEQ) { \ 1148 int _i; \ 1149 asdl_seq *seq = (SEQ); /* avoid variable capture */ \ 1150 for (_i = 0; _i < asdl_seq_LEN(seq); _i++) { \ 1151 TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, _i); \ 1152 if (!compiler_visit_ ## TYPE((C), elt)) { \ 1153 compiler_exit_scope(c); \ 1154 return 0; \ 1155 } \ 1156 } \ 1157 } 1158 1159 static int 1160 compiler_isdocstring(stmt_ty s) 1161 { 1162 if (s->kind != Expr_kind) 1163 return 0; 1164 return s->v.Expr.value->kind == Str_kind; 1165 } 1166 1167 /* Compile a sequence of statements, checking for a docstring. */ 1168 1169 static int 1170 compiler_body(struct compiler *c, asdl_seq *stmts) 1171 { 1172 int i = 0; 1173 stmt_ty st; 1174 1175 if (!asdl_seq_LEN(stmts)) 1176 return 1; 1177 st = (stmt_ty)asdl_seq_GET(stmts, 0); 1178 if (compiler_isdocstring(st) && Py_OptimizeFlag < 2) { 1179 /* don't generate docstrings if -OO */ 1180 i = 1; 1181 VISIT(c, expr, st->v.Expr.value); 1182 if (!compiler_nameop(c, __doc__, Store)) 1183 return 0; 1184 } 1185 for (; i < asdl_seq_LEN(stmts); i++) 1186 VISIT(c, stmt, (stmt_ty)asdl_seq_GET(stmts, i)); 1187 return 1; 1188 } 1189 1190 static PyCodeObject * 1191 compiler_mod(struct compiler *c, mod_ty mod) 1192 { 1193 PyCodeObject *co; 1194 int addNone = 1; 1195 static PyObject *module; 1196 if (!module) { 1197 module = PyString_InternFromString("<module>"); 1198 if (!module) 1199 return NULL; 1200 } 1201 /* Use 0 for firstlineno initially, will fixup in assemble(). */ 1202 if (!compiler_enter_scope(c, module, mod, 0)) 1203 return NULL; 1204 switch (mod->kind) { 1205 case Module_kind: 1206 if (!compiler_body(c, mod->v.Module.body)) { 1207 compiler_exit_scope(c); 1208 return 0; 1209 } 1210 break; 1211 case Interactive_kind: 1212 c->c_interactive = 1; 1213 VISIT_SEQ_IN_SCOPE(c, stmt, 1214 mod->v.Interactive.body); 1215 break; 1216 case Expression_kind: 1217 VISIT_IN_SCOPE(c, expr, mod->v.Expression.body); 1218 addNone = 0; 1219 break; 1220 case Suite_kind: 1221 PyErr_SetString(PyExc_SystemError, 1222 "suite should not be possible"); 1223 return 0; 1224 default: 1225 PyErr_Format(PyExc_SystemError, 1226 "module kind %d should not be possible", 1227 mod->kind); 1228 return 0; 1229 } 1230 co = assemble(c, addNone); 1231 compiler_exit_scope(c); 1232 return co; 1233 } 1234 1235 /* The test for LOCAL must come before the test for FREE in order to 1236 handle classes where name is both local and free. The local var is 1237 a method and the free var is a free var referenced within a method. 1238 */ 1239 1240 static int 1241 get_ref_type(struct compiler *c, PyObject *name) 1242 { 1243 int scope = PyST_GetScope(c->u->u_ste, name);
Access to field 'u_ste' results in a dereference of a null pointer (loaded from field 'u')
(emitted by clang-analyzer)

TODO: a detailed trace is available in the data model (not yet rendered in this report)

Access to field 'u_ste' results in a dereference of a null pointer (loaded from field 'u')
(emitted by clang-analyzer)

TODO: a detailed trace is available in the data model (not yet rendered in this report)

Access to field 'u_ste' results in a dereference of a null pointer (loaded from field 'u')
(emitted by clang-analyzer)

TODO: a detailed trace is available in the data model (not yet rendered in this report)

1244 if (scope == 0) { 1245 char buf[350]; 1246 PyOS_snprintf(buf, sizeof(buf), 1247 "unknown scope for %.100s in %.100s(%s) in %s\n" 1248 "symbols: %s\nlocals: %s\nglobals: %s", 1249 PyString_AS_STRING(name), 1250 PyString_AS_STRING(c->u->u_name), 1251 PyObject_REPR(c->u->u_ste->ste_id), 1252 c->c_filename, 1253 PyObject_REPR(c->u->u_ste->ste_symbols), 1254 PyObject_REPR(c->u->u_varnames), 1255 PyObject_REPR(c->u->u_names) 1256 ); 1257 Py_FatalError(buf); 1258 } 1259 1260 return scope; 1261 } 1262 1263 static int 1264 compiler_lookup_arg(PyObject *dict, PyObject *name) 1265 { 1266 PyObject *k, *v; 1267 k = PyTuple_Pack(2, name, name->ob_type); 1268 if (k == NULL) 1269 return -1; 1270 v = PyDict_GetItem(dict, k); 1271 Py_DECREF(k); 1272 if (v == NULL) 1273 return -1; 1274 return PyInt_AS_LONG(v); 1275 } 1276 1277 static int 1278 compiler_make_closure(struct compiler *c, PyCodeObject *co, int args) 1279 { 1280 int i, free = PyCode_GetNumFree(co); 1281 if (free == 0) { 1282 ADDOP_O(c, LOAD_CONST, (PyObject*)co, consts);
Access to field 'u_consts' results in a dereference of a null pointer (loaded from field 'u')
(emitted by clang-analyzer)

TODO: a detailed trace is available in the data model (not yet rendered in this report)

Access to field 'u_consts' results in a dereference of a null pointer (loaded from field 'u')
(emitted by clang-analyzer)

TODO: a detailed trace is available in the data model (not yet rendered in this report)

Access to field 'u_consts' results in a dereference of a null pointer (loaded from field 'u')
(emitted by clang-analyzer)

TODO: a detailed trace is available in the data model (not yet rendered in this report)

1283 ADDOP_I(c, MAKE_FUNCTION, args); 1284 return 1; 1285 } 1286 for (i = 0; i < free; ++i) { 1287 /* Bypass com_addop_varname because it will generate 1288 LOAD_DEREF but LOAD_CLOSURE is needed. 1289 */ 1290 PyObject *name = PyTuple_GET_ITEM(co->co_freevars, i); 1291 int arg, reftype; 1292 1293 /* Special case: If a class contains a method with a 1294 free variable that has the same name as a method, 1295 the name will be considered free *and* local in the 1296 class. It should be handled by the closure, as 1297 well as by the normal name loookup logic. 1298 */ 1299 reftype = get_ref_type(c, name); 1300 if (reftype == CELL) 1301 arg = compiler_lookup_arg(c->u->u_cellvars, name); 1302 else /* (reftype == FREE) */ 1303 arg = compiler_lookup_arg(c->u->u_freevars, name); 1304 if (arg == -1) { 1305 printf("lookup %s in %s %d %d\n" 1306 "freevars of %s: %s\n", 1307 PyObject_REPR(name), 1308 PyString_AS_STRING(c->u->u_name), 1309 reftype, arg, 1310 PyString_AS_STRING(co->co_name), 1311 PyObject_REPR(co->co_freevars)); 1312 Py_FatalError("compiler_make_closure()"); 1313 } 1314 ADDOP_I(c, LOAD_CLOSURE, arg); 1315 } 1316 ADDOP_I(c, BUILD_TUPLE, free); 1317 ADDOP_O(c, LOAD_CONST, (PyObject*)co, consts); 1318 ADDOP_I(c, MAKE_CLOSURE, args); 1319 return 1; 1320 } 1321 1322 static int 1323 compiler_decorators(struct compiler *c, asdl_seq* decos) 1324 { 1325 int i; 1326 1327 if (!decos) 1328 return 1; 1329 1330 for (i = 0; i < asdl_seq_LEN(decos); i++) { 1331 VISIT(c, expr, (expr_ty)asdl_seq_GET(decos, i)); 1332 } 1333 return 1; 1334 } 1335 1336 static int 1337 compiler_arguments(struct compiler *c, arguments_ty args) 1338 { 1339 int i; 1340 int n = asdl_seq_LEN(args->args); 1341 /* Correctly handle nested argument lists */ 1342 for (i = 0; i < n; i++) { 1343 expr_ty arg = (expr_ty)asdl_seq_GET(args->args, i); 1344 if (arg->kind == Tuple_kind) { 1345 PyObject *id = PyString_FromFormat(".%d", i); 1346 if (id == NULL) { 1347 return 0; 1348 } 1349 if (!compiler_nameop(c, id, Load)) { 1350 Py_DECREF(id); 1351 return 0; 1352 } 1353 Py_DECREF(id); 1354 VISIT(c, expr, arg); 1355 } 1356 } 1357 return 1; 1358 } 1359 1360 static int 1361 compiler_function(struct compiler *c, stmt_ty s) 1362 { 1363 PyCodeObject *co; 1364 PyObject *first_const = Py_None; 1365 arguments_ty args = s->v.FunctionDef.args; 1366 asdl_seq* decos = s->v.FunctionDef.decorator_list; 1367 stmt_ty st; 1368 int i, n, docstring; 1369 1370 assert(s->kind == FunctionDef_kind); 1371 1372 if (!compiler_decorators(c, decos)) 1373 return 0; 1374 if (args->defaults) 1375 VISIT_SEQ(c, expr, args->defaults); 1376 if (!compiler_enter_scope(c, s->v.FunctionDef.name, (void *)s, 1377 s->lineno)) 1378 return 0; 1379 1380 st = (stmt_ty)asdl_seq_GET(s->v.FunctionDef.body, 0); 1381 docstring = compiler_isdocstring(st); 1382 if (docstring && Py_OptimizeFlag < 2) 1383 first_const = st->v.Expr.value->v.Str.s; 1384 if (compiler_add_o(c, c->u->u_consts, first_const) < 0) { 1385 compiler_exit_scope(c); 1386 return 0; 1387 } 1388 1389 /* unpack nested arguments */ 1390 compiler_arguments(c, args); 1391 1392 c->u->u_argcount = asdl_seq_LEN(args->args); 1393 n = asdl_seq_LEN(s->v.FunctionDef.body); 1394 /* if there was a docstring, we need to skip the first statement */ 1395 for (i = docstring; i < n; i++) { 1396 st = (stmt_ty)asdl_seq_GET(s->v.FunctionDef.body, i); 1397 VISIT_IN_SCOPE(c, stmt, st); 1398 } 1399 co = assemble(c, 1); 1400 compiler_exit_scope(c); 1401 if (co == NULL) 1402 return 0; 1403 1404 compiler_make_closure(c, co, asdl_seq_LEN(args->defaults)); 1405 Py_DECREF(co); 1406 1407 for (i = 0; i < asdl_seq_LEN(decos); i++) { 1408 ADDOP_I(c, CALL_FUNCTION, 1); 1409 } 1410 1411 return compiler_nameop(c, s->v.FunctionDef.name, Store); 1412 } 1413 1414 static int 1415 compiler_class(struct compiler *c, stmt_ty s) 1416 { 1417 int n, i; 1418 PyCodeObject *co; 1419 PyObject *str; 1420 asdl_seq* decos = s->v.ClassDef.decorator_list; 1421 1422 if (!compiler_decorators(c, decos)) 1423 return 0; 1424 1425 /* push class name on stack, needed by BUILD_CLASS */ 1426 ADDOP_O(c, LOAD_CONST, s->v.ClassDef.name, consts); 1427 /* push the tuple of base classes on the stack */ 1428 n = asdl_seq_LEN(s->v.ClassDef.bases); 1429 if (n > 0) 1430 VISIT_SEQ(c, expr, s->v.ClassDef.bases); 1431 ADDOP_I(c, BUILD_TUPLE, n); 1432 if (!compiler_enter_scope(c, s->v.ClassDef.name, (void *)s, 1433 s->lineno)) 1434 return 0; 1435 Py_XDECREF(c->u->u_private); 1436 c->u->u_private = s->v.ClassDef.name; 1437 Py_INCREF(c->u->u_private); 1438 str = PyString_InternFromString("__name__"); 1439 if (!str || !compiler_nameop(c, str, Load)) { 1440 Py_XDECREF(str); 1441 compiler_exit_scope(c); 1442 return 0; 1443 } 1444 1445 Py_DECREF(str); 1446 str = PyString_InternFromString("__module__"); 1447 if (!str || !compiler_nameop(c, str, Store)) { 1448 Py_XDECREF(str); 1449 compiler_exit_scope(c); 1450 return 0; 1451 } 1452 Py_DECREF(str); 1453 1454 if (!compiler_body(c, s->v.ClassDef.body)) { 1455 compiler_exit_scope(c); 1456 return 0; 1457 } 1458 1459 ADDOP_IN_SCOPE(c, LOAD_LOCALS); 1460 ADDOP_IN_SCOPE(c, RETURN_VALUE); 1461 co = assemble(c, 1); 1462 compiler_exit_scope(c); 1463 if (co == NULL) 1464 return 0; 1465 1466 compiler_make_closure(c, co, 0); 1467 Py_DECREF(co); 1468 1469 ADDOP_I(c, CALL_FUNCTION, 0); 1470 ADDOP(c, BUILD_CLASS); 1471 /* apply decorators */ 1472 for (i = 0; i < asdl_seq_LEN(decos); i++) { 1473 ADDOP_I(c, CALL_FUNCTION, 1); 1474 } 1475 if (!compiler_nameop(c, s->v.ClassDef.name, Store)) 1476 return 0; 1477 return 1; 1478 } 1479 1480 static int 1481 compiler_ifexp(struct compiler *c, expr_ty e) 1482 { 1483 basicblock *end, *next; 1484 1485 assert(e->kind == IfExp_kind); 1486 end = compiler_new_block(c); 1487 if (end == NULL) 1488 return 0; 1489 next = compiler_new_block(c); 1490 if (next == NULL) 1491 return 0; 1492 VISIT(c, expr, e->v.IfExp.test); 1493 ADDOP_JABS(c, POP_JUMP_IF_FALSE, next); 1494 VISIT(c, expr, e->v.IfExp.body); 1495 ADDOP_JREL(c, JUMP_FORWARD, end); 1496 compiler_use_next_block(c, next); 1497 VISIT(c, expr, e->v.IfExp.orelse); 1498 compiler_use_next_block(c, end); 1499 return 1; 1500 } 1501 1502 static int 1503 compiler_lambda(struct compiler *c, expr_ty e) 1504 { 1505 PyCodeObject *co; 1506 static identifier name; 1507 arguments_ty args = e->v.Lambda.args; 1508 assert(e->kind == Lambda_kind); 1509 1510 if (!name) { 1511 name = PyString_InternFromString("<lambda>"); 1512 if (!name) 1513 return 0; 1514 } 1515 1516 if (args->defaults) 1517 VISIT_SEQ(c, expr, args->defaults); 1518 if (!compiler_enter_scope(c, name, (void *)e, e->lineno)) 1519 return 0; 1520 1521 /* unpack nested arguments */ 1522 compiler_arguments(c, args); 1523 1524 /* Make None the first constant, so the lambda can't have a 1525 docstring. */ 1526 if (compiler_add_o(c, c->u->u_consts, Py_None) < 0) 1527 return 0; 1528 1529 c->u->u_argcount = asdl_seq_LEN(args->args); 1530 VISIT_IN_SCOPE(c, expr, e->v.Lambda.body); 1531 if (c->u->u_ste->ste_generator) { 1532 ADDOP_IN_SCOPE(c, POP_TOP); 1533 } 1534 else { 1535 ADDOP_IN_SCOPE(c, RETURN_VALUE); 1536 } 1537 co = assemble(c, 1); 1538 compiler_exit_scope(c); 1539 if (co == NULL) 1540 return 0; 1541 1542 compiler_make_closure(c, co, asdl_seq_LEN(args->defaults)); 1543 Py_DECREF(co); 1544 1545 return 1; 1546 } 1547 1548 static int 1549 compiler_print(struct compiler *c, stmt_ty s) 1550 { 1551 int i, n; 1552 bool dest; 1553 1554 assert(s->kind == Print_kind); 1555 n = asdl_seq_LEN(s->v.Print.values); 1556 dest = false; 1557 if (s->v.Print.dest) { 1558 VISIT(c, expr, s->v.Print.dest); 1559 dest = true; 1560 } 1561 for (i = 0; i < n; i++) { 1562 expr_ty e = (expr_ty)asdl_seq_GET(s->v.Print.values, i); 1563 if (dest) { 1564 ADDOP(c, DUP_TOP); 1565 VISIT(c, expr, e); 1566 ADDOP(c, ROT_TWO); 1567 ADDOP(c, PRINT_ITEM_TO); 1568 } 1569 else { 1570 VISIT(c, expr, e); 1571 ADDOP(c, PRINT_ITEM); 1572 } 1573 } 1574 if (s->v.Print.nl) { 1575 if (dest) 1576 ADDOP(c, PRINT_NEWLINE_TO) 1577 else 1578 ADDOP(c, PRINT_NEWLINE) 1579 } 1580 else if (dest) 1581 ADDOP(c, POP_TOP); 1582 return 1; 1583 } 1584 1585 static int 1586 compiler_if(struct compiler *c, stmt_ty s) 1587 { 1588 basicblock *end, *next; 1589 int constant; 1590 assert(s->kind == If_kind); 1591 end = compiler_new_block(c); 1592 if (end == NULL) 1593 return 0; 1594 1595 constant = expr_constant(s->v.If.test); 1596 /* constant = 0: "if 0" 1597 * constant = 1: "if 1", "if 2", ... 1598 * constant = -1: rest */ 1599 if (constant == 0) { 1600 if (s->v.If.orelse) 1601 VISIT_SEQ(c, stmt, s->v.If.orelse); 1602 } else if (constant == 1) { 1603 VISIT_SEQ(c, stmt, s->v.If.body); 1604 } else { 1605 if (s->v.If.orelse) { 1606 next = compiler_new_block(c); 1607 if (next == NULL) 1608 return 0; 1609 } 1610 else 1611 next = end; 1612 VISIT(c, expr, s->v.If.test); 1613 ADDOP_JABS(c, POP_JUMP_IF_FALSE, next); 1614 VISIT_SEQ(c, stmt, s->v.If.body); 1615 ADDOP_JREL(c, JUMP_FORWARD, end); 1616 if (s->v.If.orelse) { 1617 compiler_use_next_block(c, next); 1618 VISIT_SEQ(c, stmt, s->v.If.orelse); 1619 } 1620 } 1621 compiler_use_next_block(c, end); 1622 return 1; 1623 } 1624 1625 static int 1626 compiler_for(struct compiler *c, stmt_ty s) 1627 { 1628 basicblock *start, *cleanup, *end; 1629 1630 start = compiler_new_block(c); 1631 cleanup = compiler_new_block(c); 1632 end = compiler_new_block(c); 1633 if (start == NULL || end == NULL || cleanup == NULL) 1634 return 0; 1635 ADDOP_JREL(c, SETUP_LOOP, end); 1636 if (!compiler_push_fblock(c, LOOP, start)) 1637 return 0; 1638 VISIT(c, expr, s->v.For.iter); 1639 ADDOP(c, GET_ITER); 1640 compiler_use_next_block(c, start); 1641 ADDOP_JREL(c, FOR_ITER, cleanup); 1642 VISIT(c, expr, s->v.For.target); 1643 VISIT_SEQ(c, stmt, s->v.For.body); 1644 ADDOP_JABS(c, JUMP_ABSOLUTE, start); 1645 compiler_use_next_block(c, cleanup); 1646 ADDOP(c, POP_BLOCK); 1647 compiler_pop_fblock(c, LOOP, start); 1648 VISIT_SEQ(c, stmt, s->v.For.orelse); 1649 compiler_use_next_block(c, end); 1650 return 1; 1651 } 1652 1653 static int 1654 compiler_while(struct compiler *c, stmt_ty s) 1655 { 1656 basicblock *loop, *orelse, *end, *anchor = NULL; 1657 int constant = expr_constant(s->v.While.test); 1658 1659 if (constant == 0) { 1660 if (s->v.While.orelse) 1661 VISIT_SEQ(c, stmt, s->v.While.orelse); 1662 return 1; 1663 } 1664 loop = compiler_new_block(c); 1665 end = compiler_new_block(c); 1666 if (constant == -1) { 1667 anchor = compiler_new_block(c); 1668 if (anchor == NULL) 1669 return 0; 1670 } 1671 if (loop == NULL || end == NULL) 1672 return 0; 1673 if (s->v.While.orelse) { 1674 orelse = compiler_new_block(c); 1675 if (orelse == NULL) 1676 return 0; 1677 } 1678 else 1679 orelse = NULL; 1680 1681 ADDOP_JREL(c, SETUP_LOOP, end); 1682 compiler_use_next_block(c, loop); 1683 if (!compiler_push_fblock(c, LOOP, loop)) 1684 return 0; 1685 if (constant == -1) { 1686 VISIT(c, expr, s->v.While.test); 1687 ADDOP_JABS(c, POP_JUMP_IF_FALSE, anchor); 1688 } 1689 VISIT_SEQ(c, stmt, s->v.While.body); 1690 ADDOP_JABS(c, JUMP_ABSOLUTE, loop); 1691 1692 /* XXX should the two POP instructions be in a separate block 1693 if there is no else clause ? 1694 */ 1695 1696 if (constant == -1) { 1697 compiler_use_next_block(c, anchor); 1698 ADDOP(c, POP_BLOCK); 1699 } 1700 compiler_pop_fblock(c, LOOP, loop); 1701 if (orelse != NULL) /* what if orelse is just pass? */ 1702 VISIT_SEQ(c, stmt, s->v.While.orelse); 1703 compiler_use_next_block(c, end); 1704 1705 return 1; 1706 } 1707 1708 static int 1709 compiler_continue(struct compiler *c) 1710 { 1711 static const char LOOP_ERROR_MSG[] = "'continue' not properly in loop"; 1712 static const char IN_FINALLY_ERROR_MSG[] = 1713 "'continue' not supported inside 'finally' clause"; 1714 int i; 1715 1716 if (!c->u->u_nfblocks) 1717 return compiler_error(c, LOOP_ERROR_MSG); 1718 i = c->u->u_nfblocks - 1; 1719 switch (c->u->u_fblock[i].fb_type) { 1720 case LOOP: 1721 ADDOP_JABS(c, JUMP_ABSOLUTE, c->u->u_fblock[i].fb_block); 1722 break; 1723 case EXCEPT: 1724 case FINALLY_TRY: 1725 while (--i >= 0 && c->u->u_fblock[i].fb_type != LOOP) { 1726 /* Prevent continue anywhere under a finally 1727 even if hidden in a sub-try or except. */ 1728 if (c->u->u_fblock[i].fb_type == FINALLY_END) 1729 return compiler_error(c, IN_FINALLY_ERROR_MSG); 1730 } 1731 if (i == -1) 1732 return compiler_error(c, LOOP_ERROR_MSG); 1733 ADDOP_JABS(c, CONTINUE_LOOP, c->u->u_fblock[i].fb_block); 1734 break; 1735 case FINALLY_END: 1736 return compiler_error(c, IN_FINALLY_ERROR_MSG); 1737 } 1738 1739 return 1; 1740 } 1741 1742 /* Code generated for "try: <body> finally: <finalbody>" is as follows: 1743 1744 SETUP_FINALLY L 1745 <code for body> 1746 POP_BLOCK 1747 LOAD_CONST <None> 1748 L: <code for finalbody> 1749 END_FINALLY 1750 1751 The special instructions use the block stack. Each block 1752 stack entry contains the instruction that created it (here 1753 SETUP_FINALLY), the level of the value stack at the time the 1754 block stack entry was created, and a label (here L). 1755 1756 SETUP_FINALLY: 1757 Pushes the current value stack level and the label 1758 onto the block stack. 1759 POP_BLOCK: 1760 Pops en entry from the block stack, and pops the value 1761 stack until its level is the same as indicated on the 1762 block stack. (The label is ignored.) 1763 END_FINALLY: 1764 Pops a variable number of entries from the *value* stack 1765 and re-raises the exception they specify. The number of 1766 entries popped depends on the (pseudo) exception type. 1767 1768 The block stack is unwound when an exception is raised: 1769 when a SETUP_FINALLY entry is found, the exception is pushed 1770 onto the value stack (and the exception condition is cleared), 1771 and the interpreter jumps to the label gotten from the block 1772 stack. 1773 */ 1774 1775 static int 1776 compiler_try_finally(struct compiler *c, stmt_ty s) 1777 { 1778 basicblock *body, *end; 1779 body = compiler_new_block(c); 1780 end = compiler_new_block(c); 1781 if (body == NULL || end == NULL) 1782 return 0; 1783 1784 ADDOP_JREL(c, SETUP_FINALLY, end); 1785 compiler_use_next_block(c, body); 1786 if (!compiler_push_fblock(c, FINALLY_TRY, body)) 1787 return 0; 1788 VISIT_SEQ(c, stmt, s->v.TryFinally.body); 1789 ADDOP(c, POP_BLOCK); 1790 compiler_pop_fblock(c, FINALLY_TRY, body); 1791 1792 ADDOP_O(c, LOAD_CONST, Py_None, consts); 1793 compiler_use_next_block(c, end); 1794 if (!compiler_push_fblock(c, FINALLY_END, end)) 1795 return 0; 1796 VISIT_SEQ(c, stmt, s->v.TryFinally.finalbody); 1797 ADDOP(c, END_FINALLY); 1798 compiler_pop_fblock(c, FINALLY_END, end); 1799 1800 return 1; 1801 } 1802 1803 /* 1804 Code generated for "try: S except E1, V1: S1 except E2, V2: S2 ...": 1805 (The contents of the value stack is shown in [], with the top 1806 at the right; 'tb' is trace-back info, 'val' the exception's 1807 associated value, and 'exc' the exception.) 1808 1809 Value stack Label Instruction Argument 1810 [] SETUP_EXCEPT L1 1811 [] <code for S> 1812 [] POP_BLOCK 1813 [] JUMP_FORWARD L0 1814 1815 [tb, val, exc] L1: DUP ) 1816 [tb, val, exc, exc] <evaluate E1> ) 1817 [tb, val, exc, exc, E1] COMPARE_OP EXC_MATCH ) only if E1 1818 [tb, val, exc, 1-or-0] POP_JUMP_IF_FALSE L2 ) 1819 [tb, val, exc] POP 1820 [tb, val] <assign to V1> (or POP if no V1) 1821 [tb] POP 1822 [] <code for S1> 1823 JUMP_FORWARD L0 1824 1825 [tb, val, exc] L2: DUP 1826 .............................etc....................... 1827 1828 [tb, val, exc] Ln+1: END_FINALLY # re-raise exception 1829 1830 [] L0: <next statement> 1831 1832 Of course, parts are not generated if Vi or Ei is not present. 1833 */ 1834 static int 1835 compiler_try_except(struct compiler *c, stmt_ty s) 1836 { 1837 basicblock *body, *orelse, *except, *end; 1838 int i, n; 1839 1840 body = compiler_new_block(c); 1841 except = compiler_new_block(c); 1842 orelse = compiler_new_block(c); 1843 end = compiler_new_block(c); 1844 if (body == NULL || except == NULL || orelse == NULL || end == NULL) 1845 return 0; 1846 ADDOP_JREL(c, SETUP_EXCEPT, except); 1847 compiler_use_next_block(c, body); 1848 if (!compiler_push_fblock(c, EXCEPT, body)) 1849 return 0; 1850 VISIT_SEQ(c, stmt, s->v.TryExcept.body); 1851 ADDOP(c, POP_BLOCK); 1852 compiler_pop_fblock(c, EXCEPT, body); 1853 ADDOP_JREL(c, JUMP_FORWARD, orelse); 1854 n = asdl_seq_LEN(s->v.TryExcept.handlers); 1855 compiler_use_next_block(c, except); 1856 for (i = 0; i < n; i++) { 1857 excepthandler_ty handler = (excepthandler_ty)asdl_seq_GET( 1858 s->v.TryExcept.handlers, i); 1859 if (!handler->v.ExceptHandler.type && i < n-1) 1860 return compiler_error(c, "default 'except:' must be last"); 1861 c->u->u_lineno_set = false; 1862 c->u->u_lineno = handler->lineno; 1863 except = compiler_new_block(c); 1864 if (except == NULL) 1865 return 0; 1866 if (handler->v.ExceptHandler.type) { 1867 ADDOP(c, DUP_TOP); 1868 VISIT(c, expr, handler->v.ExceptHandler.type); 1869 ADDOP_I(c, COMPARE_OP, PyCmp_EXC_MATCH); 1870 ADDOP_JABS(c, POP_JUMP_IF_FALSE, except); 1871 } 1872 ADDOP(c, POP_TOP); 1873 if (handler->v.ExceptHandler.name) { 1874 VISIT(c, expr, handler->v.ExceptHandler.name); 1875 } 1876 else { 1877 ADDOP(c, POP_TOP); 1878 } 1879 ADDOP(c, POP_TOP); 1880 VISIT_SEQ(c, stmt, handler->v.ExceptHandler.body); 1881 ADDOP_JREL(c, JUMP_FORWARD, end); 1882 compiler_use_next_block(c, except); 1883 } 1884 ADDOP(c, END_FINALLY); 1885 compiler_use_next_block(c, orelse); 1886 VISIT_SEQ(c, stmt, s->v.TryExcept.orelse); 1887 compiler_use_next_block(c, end); 1888 return 1; 1889 } 1890 1891 static int 1892 compiler_import_as(struct compiler *c, identifier name, identifier asname) 1893 { 1894 /* The IMPORT_NAME opcode was already generated. This function 1895 merely needs to bind the result to a name. 1896 1897 If there is a dot in name, we need to split it and emit a 1898 LOAD_ATTR for each name. 1899 */ 1900 const char *src = PyString_AS_STRING(name); 1901 const char *dot = strchr(src, '.'); 1902 if (dot) { 1903 /* Consume the base module name to get the first attribute */ 1904 src = dot + 1; 1905 while (dot) { 1906 /* NB src is only defined when dot != NULL */ 1907 PyObject *attr; 1908 dot = strchr(src, '.'); 1909 attr = PyString_FromStringAndSize(src, 1910 dot ? dot - src : strlen(src)); 1911 if (!attr) 1912 return -1; 1913 ADDOP_O(c, LOAD_ATTR, attr, names); 1914 Py_DECREF(attr); 1915 src = dot + 1; 1916 } 1917 } 1918 return compiler_nameop(c, asname, Store); 1919 } 1920 1921 static int 1922 compiler_import(struct compiler *c, stmt_ty s) 1923 { 1924 /* The Import node stores a module name like a.b.c as a single 1925 string. This is convenient for all cases except 1926 import a.b.c as d 1927 where we need to parse that string to extract the individual 1928 module names. 1929 XXX Perhaps change the representation to make this case simpler? 1930 */ 1931 int i, n = asdl_seq_LEN(s->v.Import.names); 1932 1933 for (i = 0; i < n; i++) { 1934 alias_ty alias = (alias_ty)asdl_seq_GET(s->v.Import.names, i); 1935 int r; 1936 PyObject *level; 1937 1938 if (c->c_flags && (c->c_flags->cf_flags & CO_FUTURE_ABSOLUTE_IMPORT)) 1939 level = PyInt_FromLong(0); 1940 else 1941 level = PyInt_FromLong(-1); 1942 1943 if (level == NULL) 1944 return 0; 1945 1946 ADDOP_O(c, LOAD_CONST, level, consts); 1947 Py_DECREF(level); 1948 ADDOP_O(c, LOAD_CONST, Py_None, consts); 1949 ADDOP_NAME(c, IMPORT_NAME, alias->name, names); 1950 1951 if (alias->asname) { 1952 r = compiler_import_as(c, alias->name, alias->asname); 1953 if (!r) 1954 return r; 1955 } 1956 else { 1957 identifier tmp = alias->name; 1958 const char *base = PyString_AS_STRING(alias->name); 1959 char *dot = strchr(base, '.'); 1960 if (dot) 1961 tmp = PyString_FromStringAndSize(base, 1962 dot - base); 1963 r = compiler_nameop(c, tmp, Store); 1964 if (dot) { 1965 Py_DECREF(tmp); 1966 } 1967 if (!r) 1968 return r; 1969 } 1970 } 1971 return 1; 1972 } 1973 1974 static int 1975 compiler_from_import(struct compiler *c, stmt_ty s) 1976 { 1977 int i, n = asdl_seq_LEN(s->v.ImportFrom.names); 1978 1979 PyObject *names = PyTuple_New(n); 1980 PyObject *level; 1981 static PyObject *empty_string; 1982 1983 if (!empty_string) { 1984 empty_string = PyString_FromString(""); 1985 if (!empty_string) 1986 return 0; 1987 } 1988 1989 if (!names) 1990 return 0; 1991 1992 if (s->v.ImportFrom.level == 0 && c->c_flags && 1993 !(c->c_flags->cf_flags & CO_FUTURE_ABSOLUTE_IMPORT)) 1994 level = PyInt_FromLong(-1); 1995 else 1996 level = PyInt_FromLong(s->v.ImportFrom.level); 1997 1998 if (!level) { 1999 Py_DECREF(names); 2000 return 0; 2001 } 2002 2003 /* build up the names */ 2004 for (i = 0; i < n; i++) { 2005 alias_ty alias = (alias_ty)asdl_seq_GET(s->v.ImportFrom.names, i); 2006 Py_INCREF(alias->name); 2007 PyTuple_SET_ITEM(names, i, alias->name); 2008 } 2009 2010 if (s->lineno > c->c_future->ff_lineno && s->v.ImportFrom.module && 2011 !strcmp(PyString_AS_STRING(s->v.ImportFrom.module), "__future__")) { 2012 Py_DECREF(level); 2013 Py_DECREF(names); 2014 return compiler_error(c, "from __future__ imports must occur " 2015 "at the beginning of the file"); 2016 } 2017 2018 ADDOP_O(c, LOAD_CONST, level, consts); 2019 Py_DECREF(level); 2020 ADDOP_O(c, LOAD_CONST, names, consts); 2021 Py_DECREF(names); 2022 if (s->v.ImportFrom.module) { 2023 ADDOP_NAME(c, IMPORT_NAME, s->v.ImportFrom.module, names); 2024 } 2025 else { 2026 ADDOP_NAME(c, IMPORT_NAME, empty_string, names); 2027 } 2028 for (i = 0; i < n; i++) { 2029 alias_ty alias = (alias_ty)asdl_seq_GET(s->v.ImportFrom.names, i); 2030 identifier store_name; 2031 2032 if (i == 0 && *PyString_AS_STRING(alias->name) == '*') { 2033 assert(n == 1); 2034 ADDOP(c, IMPORT_STAR); 2035 return 1; 2036 } 2037 2038 ADDOP_NAME(c, IMPORT_FROM, alias->name, names); 2039 store_name = alias->name; 2040 if (alias->asname) 2041 store_name = alias->asname; 2042 2043 if (!compiler_nameop(c, store_name, Store)) { 2044 Py_DECREF(names); 2045 return 0; 2046 } 2047 } 2048 /* remove imported module */ 2049 ADDOP(c, POP_TOP); 2050 return 1; 2051 } 2052 2053 static int 2054 compiler_assert(struct compiler *c, stmt_ty s) 2055 { 2056 static PyObject *assertion_error = NULL; 2057 basicblock *end; 2058 2059 if (Py_OptimizeFlag) 2060 return 1; 2061 if (assertion_error == NULL) { 2062 assertion_error = PyString_InternFromString("AssertionError"); 2063 if (assertion_error == NULL) 2064 return 0; 2065 } 2066 if (s->v.Assert.test->kind == Tuple_kind && 2067 asdl_seq_LEN(s->v.Assert.test->v.Tuple.elts) > 0) { 2068 const char* msg = 2069 "assertion is always true, perhaps remove parentheses?"; 2070 if (PyErr_WarnExplicit(PyExc_SyntaxWarning, msg, c->c_filename, 2071 c->u->u_lineno, NULL, NULL) == -1) 2072 return 0; 2073 } 2074 VISIT(c, expr, s->v.Assert.test); 2075 end = compiler_new_block(c); 2076 if (end == NULL) 2077 return 0; 2078 ADDOP_JABS(c, POP_JUMP_IF_TRUE, end); 2079 ADDOP_O(c, LOAD_GLOBAL, assertion_error, names); 2080 if (s->v.Assert.msg) { 2081 VISIT(c, expr, s->v.Assert.msg); 2082 ADDOP_I(c, CALL_FUNCTION, 1); 2083 } 2084 ADDOP_I(c, RAISE_VARARGS, 1); 2085 compiler_use_next_block(c, end); 2086 return 1; 2087 } 2088 2089 static int 2090 compiler_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 2205 static int 2206 unaryop(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 2224 static int 2225 binop(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 2262 static int 2263 cmpop(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 2291 static int 2292 inplace_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 2329 static int 2330 compiler_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 mangled = _Py_Mangle(c->u->u_private, name); 2340 if (!mangled) 2341 return 0; 2342 2343 op = 0; 2344 optype = OP_NAME; 2345 scope = PyST_GetScope(c->u->u_ste, mangled); 2346 switch (scope) { 2347 case FREE: 2348 dict = c->u->u_freevars; 2349 optype = OP_DEREF; 2350 break; 2351 case CELL: 2352 dict = c->u->u_cellvars; 2353 optype = OP_DEREF; 2354 break; 2355 case LOCAL: 2356 if (c->u->u_ste->ste_type == FunctionBlock) 2357 optype = OP_FAST; 2358 break; 2359 case GLOBAL_IMPLICIT: 2360 if (c->u->u_ste->ste_type == FunctionBlock && 2361 !c->u->u_ste->ste_unoptimized) 2362 optype = OP_GLOBAL; 2363 break; 2364 case GLOBAL_EXPLICIT: 2365 optype = OP_GLOBAL; 2366 break; 2367 default: 2368 /* scope can be 0 */ 2369 break; 2370 } 2371 2372 /* XXX Leave assert here, but handle __doc__ and the like better */ 2373 assert(scope || PyString_AS_STRING(name)[0] == '_'); 2374 2375 switch (optype) { 2376 case OP_DEREF: 2377 switch (ctx) { 2378 case Load: op = LOAD_DEREF; break; 2379 case Store: op = STORE_DEREF; break; 2380 case AugLoad: 2381 case AugStore: 2382 break; 2383 case Del: 2384 PyErr_Format(PyExc_SyntaxError, 2385 "can not delete variable '%s' referenced " 2386 "in nested scope", 2387 PyString_AS_STRING(name)); 2388 Py_DECREF(mangled); 2389 return 0; 2390 case Param: 2391 default: 2392 PyErr_SetString(PyExc_SystemError, 2393 "param invalid for deref variable"); 2394 return 0; 2395 } 2396 break; 2397 case OP_FAST: 2398 switch (ctx) { 2399 case Load: op = LOAD_FAST; break; 2400 case Store: op = STORE_FAST; break; 2401 case Del: op = DELETE_FAST; break; 2402 case AugLoad: 2403 case AugStore: 2404 break; 2405 case Param: 2406 default: 2407 PyErr_SetString(PyExc_SystemError, 2408 "param invalid for local variable"); 2409 return 0; 2410 } 2411 ADDOP_O(c, op, mangled, varnames); 2412 Py_DECREF(mangled); 2413 return 1; 2414 case OP_GLOBAL: 2415 switch (ctx) { 2416 case Load: op = LOAD_GLOBAL; break; 2417 case Store: op = STORE_GLOBAL; break; 2418 case Del: op = DELETE_GLOBAL; break; 2419 case AugLoad: 2420 case AugStore: 2421 break; 2422 case Param: 2423 default: 2424 PyErr_SetString(PyExc_SystemError, 2425 "param invalid for global variable"); 2426 return 0; 2427 } 2428 break; 2429 case OP_NAME: 2430 switch (ctx) { 2431 case Load: op = LOAD_NAME; break; 2432 case Store: op = STORE_NAME; break; 2433 case Del: op = DELETE_NAME; break; 2434 case AugLoad: 2435 case AugStore: 2436 break; 2437 case Param: 2438 default: 2439 PyErr_SetString(PyExc_SystemError, 2440 "param invalid for name variable"); 2441 return 0; 2442 } 2443 break; 2444 } 2445 2446 assert(op); 2447 arg = compiler_add_o(c, dict, mangled); 2448 Py_DECREF(mangled); 2449 if (arg < 0) 2450 return 0; 2451 return compiler_addop_i(c, op, arg); 2452 } 2453 2454 static int 2455 compiler_boolop(struct compiler *c, expr_ty e) 2456 { 2457 basicblock *end; 2458 int jumpi, i, n; 2459 asdl_seq *s; 2460 2461 assert(e->kind == BoolOp_kind); 2462 if (e->v.BoolOp.op == And) 2463 jumpi = JUMP_IF_FALSE_OR_POP; 2464 else 2465 jumpi = JUMP_IF_TRUE_OR_POP; 2466 end = compiler_new_block(c); 2467 if (end == NULL) 2468 return 0; 2469 s = e->v.BoolOp.values; 2470 n = asdl_seq_LEN(s) - 1; 2471 assert(n >= 0); 2472 for (i = 0; i < n; ++i) { 2473 VISIT(c, expr, (expr_ty)asdl_seq_GET(s, i)); 2474 ADDOP_JABS(c, jumpi, end); 2475 } 2476 VISIT(c, expr, (expr_ty)asdl_seq_GET(s, n)); 2477 compiler_use_next_block(c, end); 2478 return 1; 2479 } 2480 2481 static int 2482 compiler_list(struct compiler *c, expr_ty e) 2483 { 2484 int n = asdl_seq_LEN(e->v.List.elts); 2485 if (e->v.List.ctx == Store) { 2486 ADDOP_I(c, UNPACK_SEQUENCE, n); 2487 } 2488 VISIT_SEQ(c, expr, e->v.List.elts); 2489 if (e->v.List.ctx == Load) { 2490 ADDOP_I(c, BUILD_LIST, n); 2491 } 2492 return 1; 2493 } 2494 2495 static int 2496 compiler_tuple(struct compiler *c, expr_ty e) 2497 { 2498 int n = asdl_seq_LEN(e->v.Tuple.elts); 2499 if (e->v.Tuple.ctx == Store) { 2500 ADDOP_I(c, UNPACK_SEQUENCE, n); 2501 } 2502 VISIT_SEQ(c, expr, e->v.Tuple.elts); 2503 if (e->v.Tuple.ctx == Load) { 2504 ADDOP_I(c, BUILD_TUPLE, n); 2505 } 2506 return 1; 2507 } 2508 2509 static int 2510 compiler_compare(struct compiler *c, expr_ty e) 2511 { 2512 int i, n; 2513 basicblock *cleanup = NULL; 2514 2515 /* XXX the logic can be cleaned up for 1 or multiple comparisons */ 2516 VISIT(c, expr, e->v.Compare.left); 2517 n = asdl_seq_LEN(e->v.Compare.ops); 2518 assert(n > 0); 2519 if (n > 1) { 2520 cleanup = compiler_new_block(c); 2521 if (cleanup == NULL) 2522 return 0; 2523 VISIT(c, expr, 2524 (expr_ty)asdl_seq_GET(e->v.Compare.comparators, 0)); 2525 } 2526 for (i = 1; i < n; i++) { 2527 ADDOP(c, DUP_TOP); 2528 ADDOP(c, ROT_THREE); 2529 ADDOP_I(c, COMPARE_OP, 2530 cmpop((cmpop_ty)(asdl_seq_GET( 2531 e->v.Compare.ops, i - 1)))); 2532 ADDOP_JABS(c, JUMP_IF_FALSE_OR_POP, cleanup); 2533 NEXT_BLOCK(c); 2534 if (i < (n - 1)) 2535 VISIT(c, expr, 2536 (expr_ty)asdl_seq_GET(e->v.Compare.comparators, i)); 2537 } 2538 VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Compare.comparators, n - 1)); 2539 ADDOP_I(c, COMPARE_OP, 2540 cmpop((cmpop_ty)(asdl_seq_GET(e->v.Compare.ops, n - 1)))); 2541 if (n > 1) { 2542 basicblock *end = compiler_new_block(c); 2543 if (end == NULL) 2544 return 0; 2545 ADDOP_JREL(c, JUMP_FORWARD, end); 2546 compiler_use_next_block(c, cleanup); 2547 ADDOP(c, ROT_TWO); 2548 ADDOP(c, POP_TOP); 2549 compiler_use_next_block(c, end); 2550 } 2551 return 1; 2552 } 2553 2554 static int 2555 compiler_call(struct compiler *c, expr_ty e) 2556 { 2557 int n, code = 0; 2558 2559 VISIT(c, expr, e->v.Call.func); 2560 n = asdl_seq_LEN(e->v.Call.args); 2561 VISIT_SEQ(c, expr, e->v.Call.args); 2562 if (e->v.Call.keywords) { 2563 VISIT_SEQ(c, keyword, e->v.Call.keywords); 2564 n |= asdl_seq_LEN(e->v.Call.keywords) << 8; 2565 } 2566 if (e->v.Call.starargs) { 2567 VISIT(c, expr, e->v.Call.starargs); 2568 code |= 1; 2569 } 2570 if (e->v.Call.kwargs) { 2571 VISIT(c, expr, e->v.Call.kwargs); 2572 code |= 2; 2573 } 2574 switch (code) { 2575 case 0: 2576 ADDOP_I(c, CALL_FUNCTION, n); 2577 break; 2578 case 1: 2579 ADDOP_I(c, CALL_FUNCTION_VAR, n); 2580 break; 2581 case 2: 2582 ADDOP_I(c, CALL_FUNCTION_KW, n); 2583 break; 2584 case 3: 2585 ADDOP_I(c, CALL_FUNCTION_VAR_KW, n); 2586 break; 2587 } 2588 return 1; 2589 } 2590 2591 static int 2592 compiler_listcomp_generator(struct compiler *c, asdl_seq *generators, 2593 int gen_index, expr_ty elt) 2594 { 2595 /* generate code for the iterator, then each of the ifs, 2596 and then write to the element */ 2597 2598 comprehension_ty l; 2599 basicblock *start, *anchor, *skip, *if_cleanup; 2600 int i, n; 2601 2602 start = compiler_new_block(c); 2603 skip = compiler_new_block(c); 2604 if_cleanup = compiler_new_block(c); 2605 anchor = compiler_new_block(c); 2606 2607 if (start == NULL || skip == NULL || if_cleanup == NULL || 2608 anchor == NULL) 2609 return 0; 2610 2611 l = (comprehension_ty)asdl_seq_GET(generators, gen_index); 2612 VISIT(c, expr, l->iter); 2613 ADDOP(c, GET_ITER); 2614 compiler_use_next_block(c, start); 2615 ADDOP_JREL(c, FOR_ITER, anchor); 2616 NEXT_BLOCK(c); 2617 VISIT(c, expr, l->target); 2618 2619 /* XXX this needs to be cleaned up...a lot! */ 2620 n = asdl_seq_LEN(l->ifs); 2621 for (i = 0; i < n; i++) { 2622 expr_ty e = (expr_ty)asdl_seq_GET(l->ifs, i); 2623 VISIT(c, expr, e); 2624 ADDOP_JABS(c, POP_JUMP_IF_FALSE, if_cleanup); 2625 NEXT_BLOCK(c); 2626 } 2627 2628 if (++gen_index < asdl_seq_LEN(generators)) 2629 if (!compiler_listcomp_generator(c, generators, gen_index, elt)) 2630 return 0; 2631 2632 /* only append after the last for generator */ 2633 if (gen_index >= asdl_seq_LEN(generators)) { 2634 VISIT(c, expr, elt); 2635 ADDOP_I(c, LIST_APPEND, gen_index+1); 2636 2637 compiler_use_next_block(c, skip); 2638 } 2639 compiler_use_next_block(c, if_cleanup); 2640 ADDOP_JABS(c, JUMP_ABSOLUTE, start); 2641 compiler_use_next_block(c, anchor); 2642 2643 return 1; 2644 } 2645 2646 static int 2647 compiler_listcomp(struct compiler *c, expr_ty e) 2648 { 2649 assert(e->kind == ListComp_kind); 2650 ADDOP_I(c, BUILD_LIST, 0); 2651 return compiler_listcomp_generator(c, e->v.ListComp.generators, 0, 2652 e->v.ListComp.elt); 2653 } 2654 2655 /* Dict and set comprehensions and generator expressions work by creating a 2656 nested function to perform the actual iteration. This means that the 2657 iteration variables don't leak into the current scope. 2658 The defined function is called immediately following its definition, with the 2659 result of that call being the result of the expression. 2660 The LC/SC version returns the populated container, while the GE version is 2661 flagged in symtable.c as a generator, so it returns the generator object 2662 when the function is called. 2663 This code *knows* that the loop cannot contain break, continue, or return, 2664 so it cheats and skips the SETUP_LOOP/POP_BLOCK steps used in normal loops. 2665 2666 Possible cleanups: 2667 - iterate over the generator sequence instead of using recursion 2668 */ 2669 2670 static int 2671 compiler_comprehension_generator(struct compiler *c, 2672 asdl_seq *generators, int gen_index, 2673 expr_ty elt, expr_ty val, int type) 2674 { 2675 /* generate code for the iterator, then each of the ifs, 2676 and then write to the element */ 2677 2678 comprehension_ty gen; 2679 basicblock *start, *anchor, *skip, *if_cleanup; 2680 int i, n; 2681 2682 start = compiler_new_block(c); 2683 skip = compiler_new_block(c); 2684 if_cleanup = compiler_new_block(c); 2685 anchor = compiler_new_block(c); 2686 2687 if (start == NULL || skip == NULL || if_cleanup == NULL || 2688 anchor == NULL) 2689 return 0; 2690 2691 gen = (comprehension_ty)asdl_seq_GET(generators, gen_index); 2692 2693 if (gen_index == 0) { 2694 /* Receive outermost iter as an implicit argument */ 2695 c->u->u_argcount = 1; 2696 ADDOP_I(c, LOAD_FAST, 0); 2697 } 2698 else { 2699 /* Sub-iter - calculate on the fly */ 2700 VISIT(c, expr, gen->iter); 2701 ADDOP(c, GET_ITER); 2702 } 2703 compiler_use_next_block(c, start); 2704 ADDOP_JREL(c, FOR_ITER, anchor); 2705 NEXT_BLOCK(c); 2706 VISIT(c, expr, gen->target); 2707 2708 /* XXX this needs to be cleaned up...a lot! */ 2709 n = asdl_seq_LEN(gen->ifs); 2710 for (i = 0; i < n; i++) { 2711 expr_ty e = (expr_ty)asdl_seq_GET(gen->ifs, i); 2712 VISIT(c, expr, e); 2713 ADDOP_JABS(c, POP_JUMP_IF_FALSE, if_cleanup); 2714 NEXT_BLOCK(c); 2715 } 2716 2717 if (++gen_index < asdl_seq_LEN(generators)) 2718 if (!compiler_comprehension_generator(c, 2719 generators, gen_index, 2720 elt, val, type)) 2721 return 0; 2722 2723 /* only append after the last for generator */ 2724 if (gen_index >= asdl_seq_LEN(generators)) { 2725 /* comprehension specific code */ 2726 switch (type) { 2727 case COMP_GENEXP: 2728 VISIT(c, expr, elt); 2729 ADDOP(c, YIELD_VALUE); 2730 ADDOP(c, POP_TOP); 2731 break; 2732 case COMP_SETCOMP: 2733 VISIT(c, expr, elt); 2734 ADDOP_I(c, SET_ADD, gen_index + 1); 2735 break; 2736 case COMP_DICTCOMP: 2737 /* With 'd[k] = v', v is evaluated before k, so we do 2738 the same. */ 2739 VISIT(c, expr, val); 2740 VISIT(c, expr, elt); 2741 ADDOP_I(c, MAP_ADD, gen_index + 1); 2742 break; 2743 default: 2744 return 0; 2745 } 2746 2747 compiler_use_next_block(c, skip); 2748 } 2749 compiler_use_next_block(c, if_cleanup); 2750 ADDOP_JABS(c, JUMP_ABSOLUTE, start); 2751 compiler_use_next_block(c, anchor); 2752 2753 return 1; 2754 } 2755 2756 static int 2757 compiler_comprehension(struct compiler *c, expr_ty e, int type, identifier name, 2758 asdl_seq *generators, expr_ty elt, expr_ty val) 2759 { 2760 PyCodeObject *co = NULL; 2761 expr_ty outermost_iter; 2762 2763 outermost_iter = ((comprehension_ty) 2764 asdl_seq_GET(generators, 0))->iter; 2765 2766 if (!compiler_enter_scope(c, name, (void *)e, e->lineno)) 2767 goto error; 2768 2769 if (type != COMP_GENEXP) { 2770 int op; 2771 switch (type) { 2772 case COMP_SETCOMP: 2773 op = BUILD_SET; 2774 break; 2775 case COMP_DICTCOMP: 2776 op = BUILD_MAP; 2777 break; 2778 default: 2779 PyErr_Format(PyExc_SystemError, 2780 "unknown comprehension type %d", type); 2781 goto error_in_scope; 2782 } 2783 2784 ADDOP_I(c, op, 0); 2785 } 2786 2787 if (!compiler_comprehension_generator(c, generators, 0, elt, 2788 val, type)) 2789 goto error_in_scope; 2790 2791 if (type != COMP_GENEXP) { 2792 ADDOP(c, RETURN_VALUE); 2793 } 2794 2795 co = assemble(c, 1); 2796 compiler_exit_scope(c); 2797 if (co == NULL) 2798 goto error; 2799 2800 if (!compiler_make_closure(c, co, 0)) 2801 goto error; 2802 Py_DECREF(co); 2803 2804 VISIT(c, expr, outermost_iter); 2805 ADDOP(c, GET_ITER); 2806 ADDOP_I(c, CALL_FUNCTION, 1); 2807 return 1; 2808 error_in_scope: 2809 compiler_exit_scope(c); 2810 error: 2811 Py_XDECREF(co); 2812 return 0; 2813 } 2814 2815 static int 2816 compiler_genexp(struct compiler *c, expr_ty e) 2817 { 2818 static identifier name; 2819 if (!name) { 2820 name = PyString_FromString("<genexpr>"); 2821 if (!name) 2822 return 0; 2823 } 2824 assert(e->kind == GeneratorExp_kind); 2825 return compiler_comprehension(c, e, COMP_GENEXP, name, 2826 e->v.GeneratorExp.generators, 2827 e->v.GeneratorExp.elt, NULL); 2828 } 2829 2830 static int 2831 compiler_setcomp(struct compiler *c, expr_ty e) 2832 { 2833 static identifier name; 2834 if (!name) { 2835 name = PyString_FromString("<setcomp>"); 2836 if (!name) 2837 return 0; 2838 } 2839 assert(e->kind == SetComp_kind); 2840 return compiler_comprehension(c, e, COMP_SETCOMP, name, 2841 e->v.SetComp.generators, 2842 e->v.SetComp.elt, NULL); 2843 } 2844 2845 static int 2846 compiler_dictcomp(struct compiler *c, expr_ty e) 2847 { 2848 static identifier name; 2849 if (!name) { 2850 name = PyString_FromString("<dictcomp>"); 2851 if (!name) 2852 return 0; 2853 } 2854 assert(e->kind == DictComp_kind); 2855 return compiler_comprehension(c, e, COMP_DICTCOMP, name, 2856 e->v.DictComp.generators, 2857 e->v.DictComp.key, e->v.DictComp.value); 2858 } 2859 2860 static int 2861 compiler_visit_keyword(struct compiler *c, keyword_ty k) 2862 { 2863 ADDOP_O(c, LOAD_CONST, k->arg, consts); 2864 VISIT(c, expr, k->value); 2865 return 1; 2866 } 2867 2868 /* Test whether expression is constant. For constants, report 2869 whether they are true or false. 2870 2871 Return values: 1 for true, 0 for false, -1 for non-constant. 2872 */ 2873 2874 static int 2875 expr_constant(expr_ty e) 2876 { 2877 switch (e->kind) { 2878 case Num_kind: 2879 return PyObject_IsTrue(e->v.Num.n); 2880 case Str_kind: 2881 return PyObject_IsTrue(e->v.Str.s); 2882 case Name_kind: 2883 /* __debug__ is not assignable, so we can optimize 2884 * it away in if and while statements */ 2885 if (strcmp(PyString_AS_STRING(e->v.Name.id), 2886 "__debug__") == 0) 2887 return ! Py_OptimizeFlag; 2888 /* fall through */ 2889 default: 2890 return -1; 2891 } 2892 } 2893 2894 /* 2895 Implements the with statement from PEP 343. 2896 2897 The semantics outlined in that PEP are as follows: 2898 2899 with EXPR as VAR: 2900 BLOCK 2901 2902 It is implemented roughly as: 2903 2904 context = EXPR 2905 exit = context.__exit__ # not calling it 2906 value = context.__enter__() 2907 try: 2908 VAR = value # if VAR present in the syntax 2909 BLOCK 2910 finally: 2911 if an exception was raised: 2912 exc = copy of (exception, instance, traceback) 2913 else: 2914 exc = (None, None, None) 2915 exit(*exc) 2916 */ 2917 static int 2918 compiler_with(struct compiler *c, stmt_ty s) 2919 { 2920 basicblock *block, *finally; 2921 2922 assert(s->kind == With_kind); 2923 2924 block = compiler_new_block(c); 2925 finally = compiler_new_block(c); 2926 if (!block || !finally) 2927 return 0; 2928 2929 /* Evaluate EXPR */ 2930 VISIT(c, expr, s->v.With.context_expr); 2931 ADDOP_JREL(c, SETUP_WITH, finally); 2932 2933 /* SETUP_WITH pushes a finally block. */ 2934 compiler_use_next_block(c, block); 2935 /* Note that the block is actually called SETUP_WITH in ceval.c, but 2936 functions the same as SETUP_FINALLY except that exceptions are 2937 normalized. */ 2938 if (!compiler_push_fblock(c, FINALLY_TRY, block)) { 2939 return 0; 2940 } 2941 2942 if (s->v.With.optional_vars) { 2943 VISIT(c, expr, s->v.With.optional_vars); 2944 } 2945 else { 2946 /* Discard result from context.__enter__() */ 2947 ADDOP(c, POP_TOP); 2948 } 2949 2950 /* BLOCK code */ 2951 VISIT_SEQ(c, stmt, s->v.With.body); 2952 2953 /* End of try block; start the finally block */ 2954 ADDOP(c, POP_BLOCK); 2955 compiler_pop_fblock(c, FINALLY_TRY, block); 2956 2957 ADDOP_O(c, LOAD_CONST, Py_None, consts); 2958 compiler_use_next_block(c, finally); 2959 if (!compiler_push_fblock(c, FINALLY_END, finally)) 2960 return 0; 2961 2962 /* Finally block starts; context.__exit__ is on the stack under 2963 the exception or return information. Just issue our magic 2964 opcode. */ 2965 ADDOP(c, WITH_CLEANUP); 2966 2967 /* Finally block ends. */ 2968 ADDOP(c, END_FINALLY); 2969 compiler_pop_fblock(c, FINALLY_END, finally); 2970 return 1; 2971 } 2972 2973 static int 2974 compiler_visit_expr(struct compiler *c, expr_ty e) 2975 { 2976 int i, n; 2977 2978 /* If expr e has a different line number than the last expr/stmt, 2979 set a new line number for the next instruction. 2980 */ 2981 if (e->lineno > c->u->u_lineno) { 2982 c->u->u_lineno = e->lineno; 2983 c->u->u_lineno_set = false; 2984 } 2985 switch (e->kind) { 2986 case BoolOp_kind: 2987 return compiler_boolop(c, e); 2988 case BinOp_kind: 2989 VISIT(c, expr, e->v.BinOp.left); 2990 VISIT(c, expr, e->v.BinOp.right); 2991 ADDOP(c, binop(c, e->v.BinOp.op)); 2992 break; 2993 case UnaryOp_kind: 2994 VISIT(c, expr, e->v.UnaryOp.operand); 2995 ADDOP(c, unaryop(e->v.UnaryOp.op)); 2996 break; 2997 case Lambda_kind: 2998 return compiler_lambda(c, e); 2999 case IfExp_kind: 3000 return compiler_ifexp(c, e); 3001 case Dict_kind: 3002 n = asdl_seq_LEN(e->v.Dict.values); 3003 ADDOP_I(c, BUILD_MAP, (n>0xFFFF ? 0xFFFF : n)); 3004 for (i = 0; i < n; i++) { 3005 VISIT(c, expr, 3006 (expr_ty)asdl_seq_GET(e->v.Dict.values, i)); 3007 VISIT(c, expr, 3008 (expr_ty)asdl_seq_GET(e->v.Dict.keys, i)); 3009 ADDOP(c, STORE_MAP); 3010 } 3011 break; 3012 case Set_kind: 3013 n = asdl_seq_LEN(e->v.Set.elts); 3014 VISIT_SEQ(c, expr, e->v.Set.elts); 3015 ADDOP_I(c, BUILD_SET, n); 3016 break; 3017 case ListComp_kind: 3018 return compiler_listcomp(c, e); 3019 case SetComp_kind: 3020 return compiler_setcomp(c, e); 3021 case DictComp_kind: 3022 return compiler_dictcomp(c, e); 3023 case GeneratorExp_kind: 3024 return compiler_genexp(c, e); 3025 case Yield_kind: 3026 if (c->u->u_ste->ste_type != FunctionBlock) 3027 return compiler_error(c, "'yield' outside function"); 3028 if (e->v.Yield.value) { 3029 VISIT(c, expr, e->v.Yield.value); 3030 } 3031 else { 3032 ADDOP_O(c, LOAD_CONST, Py_None, consts); 3033 } 3034 ADDOP(c, YIELD_VALUE); 3035 break; 3036 case Compare_kind: 3037 return compiler_compare(c, e); 3038 case Call_kind: 3039 return compiler_call(c, e); 3040 case Repr_kind: 3041 VISIT(c, expr, e->v.Repr.value); 3042 ADDOP(c, UNARY_CONVERT); 3043 break; 3044 case Num_kind: 3045 ADDOP_O(c, LOAD_CONST, e->v.Num.n, consts); 3046 break; 3047 case Str_kind: 3048 ADDOP_O(c, LOAD_CONST, e->v.Str.s, consts); 3049 break; 3050 /* The following exprs can be assignment targets. */ 3051 case Attribute_kind: 3052 if (e->v.Attribute.ctx != AugStore) 3053 VISIT(c, expr, e->v.Attribute.value); 3054 switch (e->v.Attribute.ctx) { 3055 case AugLoad: 3056 ADDOP(c, DUP_TOP); 3057 /* Fall through to load */ 3058 case Load: 3059 ADDOP_NAME(c, LOAD_ATTR, e->v.Attribute.attr, names); 3060 break; 3061 case AugStore: 3062 ADDOP(c, ROT_TWO); 3063 /* Fall through to save */ 3064 case Store: 3065 ADDOP_NAME(c, STORE_ATTR, e->v.Attribute.attr, names); 3066 break; 3067 case Del: 3068 ADDOP_NAME(c, DELETE_ATTR, e->v.Attribute.attr, names); 3069 break; 3070 case Param: 3071 default: 3072 PyErr_SetString(PyExc_SystemError, 3073 "param invalid in attribute expression"); 3074 return 0; 3075 } 3076 break; 3077 case Subscript_kind: 3078 switch (e->v.Subscript.ctx) { 3079 case AugLoad: 3080 VISIT(c, expr, e->v.Subscript.value); 3081 VISIT_SLICE(c, e->v.Subscript.slice, AugLoad); 3082 break; 3083 case Load: 3084 VISIT(c, expr, e->v.Subscript.value); 3085 VISIT_SLICE(c, e->v.Subscript.slice, Load); 3086 break; 3087 case AugStore: 3088 VISIT_SLICE(c, e->v.Subscript.slice, AugStore); 3089 break; 3090 case Store: 3091 VISIT(c, expr, e->v.Subscript.value); 3092 VISIT_SLICE(c, e->v.Subscript.slice, Store); 3093 break; 3094 case Del: 3095 VISIT(c, expr, e->v.Subscript.value); 3096 VISIT_SLICE(c, e->v.Subscript.slice, Del); 3097 break; 3098 case Param: 3099 default: 3100 PyErr_SetString(PyExc_SystemError, 3101 "param invalid in subscript expression"); 3102 return 0; 3103 } 3104 break; 3105 case Name_kind: 3106 return compiler_nameop(c, e->v.Name.id, e->v.Name.ctx); 3107 /* child nodes of List and Tuple will have expr_context set */ 3108 case List_kind: 3109 return compiler_list(c, e); 3110 case Tuple_kind: 3111 return compiler_tuple(c, e); 3112 } 3113 return 1; 3114 } 3115 3116 static int 3117 compiler_augassign(struct compiler *c, stmt_ty s) 3118 { 3119 expr_ty e = s->v.AugAssign.target; 3120 expr_ty auge; 3121 3122 assert(s->kind == AugAssign_kind); 3123 3124 switch (e->kind) { 3125 case Attribute_kind: 3126 auge = Attribute(e->v.Attribute.value, e->v.Attribute.attr, 3127 AugLoad, e->lineno, e->col_offset, c->c_arena); 3128 if (auge == NULL) 3129 return 0; 3130 VISIT(c, expr, auge); 3131 VISIT(c, expr, s->v.AugAssign.value); 3132 ADDOP(c, inplace_binop(c, s->v.AugAssign.op)); 3133 auge->v.Attribute.ctx = AugStore; 3134 VISIT(c, expr, auge); 3135 break; 3136 case Subscript_kind: 3137 auge = Subscript(e->v.Subscript.value, e->v.Subscript.slice, 3138 AugLoad, e->lineno, e->col_offset, c->c_arena); 3139 if (auge == NULL) 3140 return 0; 3141 VISIT(c, expr, auge); 3142 VISIT(c, expr, s->v.AugAssign.value); 3143 ADDOP(c, inplace_binop(c, s->v.AugAssign.op)); 3144 auge->v.Subscript.ctx = AugStore; 3145 VISIT(c, expr, auge); 3146 break; 3147 case Name_kind: 3148 if (!compiler_nameop(c, e->v.Name.id, Load)) 3149 return 0; 3150 VISIT(c, expr, s->v.AugAssign.value); 3151 ADDOP(c, inplace_binop(c, s->v.AugAssign.op)); 3152 return compiler_nameop(c, e->v.Name.id, Store); 3153 default: 3154 PyErr_Format(PyExc_SystemError, 3155 "invalid node type (%d) for augmented assignment", 3156 e->kind); 3157 return 0; 3158 } 3159 return 1; 3160 } 3161 3162 static int 3163 compiler_push_fblock(struct compiler *c, enum fblocktype t, basicblock *b) 3164 { 3165 struct fblockinfo *f; 3166 if (c->u->u_nfblocks >= CO_MAXBLOCKS) { 3167 PyErr_SetString(PyExc_SystemError, 3168 "too many statically nested blocks"); 3169 return 0; 3170 } 3171 f = &c->u->u_fblock[c->u->u_nfblocks++]; 3172 f->fb_type = t; 3173 f->fb_block = b; 3174 return 1; 3175 } 3176 3177 static void 3178 compiler_pop_fblock(struct compiler *c, enum fblocktype t, basicblock *b) 3179 { 3180 struct compiler_unit *u = c->u; 3181 assert(u->u_nfblocks > 0); 3182 u->u_nfblocks--; 3183 assert(u->u_fblock[u->u_nfblocks].fb_type == t); 3184 assert(u->u_fblock[u->u_nfblocks].fb_block == b); 3185 } 3186 3187 static int 3188 compiler_in_loop(struct compiler *c) { 3189 int i; 3190 struct compiler_unit *u = c->u; 3191 for (i = 0; i < u->u_nfblocks; ++i) { 3192 if (u->u_fblock[i].fb_type == LOOP) 3193 return 1; 3194 } 3195 return 0; 3196 } 3197 /* Raises a SyntaxError and returns 0. 3198 If something goes wrong, a different exception may be raised. 3199 */ 3200 3201 static int 3202 compiler_error(struct compiler *c, const char *errstr) 3203 { 3204 PyObject *loc; 3205 PyObject *u = NULL, *v = NULL; 3206 3207 loc = PyErr_ProgramText(c->c_filename, c->u->u_lineno); 3208 if (!loc) { 3209 Py_INCREF(Py_None); 3210 loc = Py_None; 3211 } 3212 u = Py_BuildValue("(ziOO)", c->c_filename, c->u->u_lineno, 3213 Py_None, loc); 3214 if (!u) 3215 goto exit; 3216 v = Py_BuildValue("(zO)", errstr, u); 3217 if (!v) 3218 goto exit; 3219 PyErr_SetObject(PyExc_SyntaxError, v); 3220 exit: 3221 Py_DECREF(loc); 3222 Py_XDECREF(u); 3223 Py_XDECREF(v); 3224 return 0; 3225 } 3226 3227 static int 3228 compiler_handle_subscr(struct compiler *c, const char *kind, 3229 expr_context_ty ctx) 3230 { 3231 int op = 0; 3232 3233 /* XXX this code is duplicated */ 3234 switch (ctx) { 3235 case AugLoad: /* fall through to Load */ 3236 case Load: op = BINARY_SUBSCR; break; 3237 case AugStore:/* fall through to Store */ 3238 case Store: op = STORE_SUBSCR; break; 3239 case Del: op = DELETE_SUBSCR; break; 3240 case Param: 3241 PyErr_Format(PyExc_SystemError, 3242 "invalid %s kind %d in subscript\n", 3243 kind, ctx); 3244 return 0; 3245 } 3246 if (ctx == AugLoad) { 3247 ADDOP_I(c, DUP_TOPX, 2); 3248 } 3249 else if (ctx == AugStore) { 3250 ADDOP(c, ROT_THREE); 3251 } 3252 ADDOP(c, op); 3253 return 1; 3254 } 3255 3256 static int 3257 compiler_slice(struct compiler *c, slice_ty s, expr_context_ty ctx) 3258 { 3259 int n = 2; 3260 assert(s->kind == Slice_kind); 3261 3262 /* only handles the cases where BUILD_SLICE is emitted */ 3263 if (s->v.Slice.lower) { 3264 VISIT(c, expr, s->v.Slice.lower); 3265 } 3266 else { 3267 ADDOP_O(c, LOAD_CONST, Py_None, consts); 3268 } 3269 3270 if (s->v.Slice.upper) { 3271 VISIT(c, expr, s->v.Slice.upper); 3272 } 3273 else { 3274 ADDOP_O(c, LOAD_CONST, Py_None, consts); 3275 } 3276 3277 if (s->v.Slice.step) { 3278 n++; 3279 VISIT(c, expr, s->v.Slice.step); 3280 } 3281 ADDOP_I(c, BUILD_SLICE, n); 3282 return 1; 3283 } 3284 3285 static int 3286 compiler_simple_slice(struct compiler *c, slice_ty s, expr_context_ty ctx) 3287 { 3288 int op = 0, slice_offset = 0, stack_count = 0; 3289 3290 assert(s->v.Slice.step == NULL); 3291 if (s->v.Slice.lower) { 3292 slice_offset++; 3293 stack_count++; 3294 if (ctx != AugStore) 3295 VISIT(c, expr, s->v.Slice.lower); 3296 } 3297 if (s->v.Slice.upper) { 3298 slice_offset += 2; 3299 stack_count++; 3300 if (ctx != AugStore) 3301 VISIT(c, expr, s->v.Slice.upper); 3302 } 3303 3304 if (ctx == AugLoad) { 3305 switch (stack_count) { 3306 case 0: ADDOP(c, DUP_TOP); break; 3307 case 1: ADDOP_I(c, DUP_TOPX, 2); break; 3308 case 2: ADDOP_I(c, DUP_TOPX, 3); break; 3309 } 3310 } 3311 else if (ctx == AugStore) { 3312 switch (stack_count) { 3313 case 0: ADDOP(c, ROT_TWO); break; 3314 case 1: ADDOP(c, ROT_THREE); break; 3315 case 2: ADDOP(c, ROT_FOUR); break; 3316 } 3317 } 3318 3319 switch (ctx) { 3320 case AugLoad: /* fall through to Load */ 3321 case Load: op = SLICE; break; 3322 case AugStore:/* fall through to Store */ 3323 case Store: op = STORE_SLICE; break; 3324 case Del: op = DELETE_SLICE; break; 3325 case Param: 3326 default: 3327 PyErr_SetString(PyExc_SystemError, 3328 "param invalid in simple slice"); 3329 return 0; 3330 } 3331 3332 ADDOP(c, op + slice_offset); 3333 return 1; 3334 } 3335 3336 static int 3337 compiler_visit_nested_slice(struct compiler *c, slice_ty s, 3338 expr_context_ty ctx) 3339 { 3340 switch (s->kind) { 3341 case Ellipsis_kind: 3342 ADDOP_O(c, LOAD_CONST, Py_Ellipsis, consts); 3343 break; 3344 case Slice_kind: 3345 return compiler_slice(c, s, ctx); 3346 case Index_kind: 3347 VISIT(c, expr, s->v.Index.value); 3348 break; 3349 case ExtSlice_kind: 3350 default: 3351 PyErr_SetString(PyExc_SystemError, 3352 "extended slice invalid in nested slice"); 3353 return 0; 3354 } 3355 return 1; 3356 } 3357 3358 static int 3359 compiler_visit_slice(struct compiler *c, slice_ty s, expr_context_ty ctx) 3360 { 3361 char * kindname = NULL; 3362 switch (s->kind) { 3363 case Index_kind: 3364 kindname = "index"; 3365 if (ctx != AugStore) { 3366 VISIT(c, expr, s->v.Index.value); 3367 } 3368 break; 3369 case Ellipsis_kind: 3370 kindname = "ellipsis"; 3371 if (ctx != AugStore) { 3372 ADDOP_O(c, LOAD_CONST, Py_Ellipsis, consts); 3373 } 3374 break; 3375 case Slice_kind: 3376 kindname = "slice"; 3377 if (!s->v.Slice.step) 3378 return compiler_simple_slice(c, s, ctx); 3379 if (ctx != AugStore) { 3380 if (!compiler_slice(c, s, ctx)) 3381 return 0; 3382 } 3383 break; 3384 case ExtSlice_kind: 3385 kindname = "extended slice"; 3386 if (ctx != AugStore) { 3387 int i, n = asdl_seq_LEN(s->v.ExtSlice.dims); 3388 for (i = 0; i < n; i++) { 3389 slice_ty sub = (slice_ty)asdl_seq_GET( 3390 s->v.ExtSlice.dims, i); 3391 if (!compiler_visit_nested_slice(c, sub, ctx)) 3392 return 0; 3393 } 3394 ADDOP_I(c, BUILD_TUPLE, n); 3395 } 3396 break; 3397 default: 3398 PyErr_Format(PyExc_SystemError, 3399 "invalid subscript kind %d", s->kind); 3400 return 0; 3401 } 3402 return compiler_handle_subscr(c, kindname, ctx); 3403 } 3404 3405 3406 /* End of the compiler section, beginning of the assembler section */ 3407 3408 /* do depth-first search of basic block graph, starting with block. 3409 post records the block indices in post-order. 3410 3411 XXX must handle implicit jumps from one block to next 3412 */ 3413 3414 struct assembler { 3415 PyObject *a_bytecode; /* string containing bytecode */ 3416 int a_offset; /* offset into bytecode */ 3417 int a_nblocks; /* number of reachable blocks */ 3418 basicblock **a_postorder; /* list of blocks in dfs postorder */ 3419 PyObject *a_lnotab; /* string containing lnotab */ 3420 int a_lnotab_off; /* offset into lnotab */ 3421 int a_lineno; /* last lineno of emitted instruction */ 3422 int a_lineno_off; /* bytecode offset of last lineno */ 3423 }; 3424 3425 static void 3426 dfs(struct compiler *c, basicblock *b, struct assembler *a) 3427 { 3428 int i; 3429 struct instr *instr = NULL; 3430 3431 if (b->b_seen)
Access to field 'b_seen' results in a dereference of a null pointer (loaded from variable 'b')
(emitted by clang-analyzer)

TODO: a detailed trace is available in the data model (not yet rendered in this report)

Access to field 'b_seen' results in a dereference of a null pointer (loaded from variable 'b')
(emitted by clang-analyzer)

TODO: a detailed trace is available in the data model (not yet rendered in this report)

Access to field 'b_seen' results in a dereference of a null pointer (loaded from variable 'b')
(emitted by clang-analyzer)

TODO: a detailed trace is available in the data model (not yet rendered in this report)

3432 return; 3433 b->b_seen = 1; 3434 if (b->b_next != NULL) 3435 dfs(c, b->b_next, a); 3436 for (i = 0; i < b->b_iused; i++) { 3437 instr = &b->b_instr[i]; 3438 if (instr->i_jrel || instr->i_jabs) 3439 dfs(c, instr->i_target, a); 3440 } 3441 a->a_postorder[a->a_nblocks++] = b; 3442 } 3443 3444 static int 3445 stackdepth_walk(struct compiler *c, basicblock *b, int depth, int maxdepth) 3446 { 3447 int i, target_depth; 3448 struct instr *instr; 3449 if (b->b_seen || b->b_startdepth >= depth) 3450 return maxdepth; 3451 b->b_seen = 1; 3452 b->b_startdepth = depth; 3453 for (i = 0; i < b->b_iused; i++) { 3454 instr = &b->b_instr[i]; 3455 depth += opcode_stack_effect(instr->i_opcode, instr->i_oparg); 3456 if (depth > maxdepth) 3457 maxdepth = depth; 3458 assert(depth >= 0); /* invalid code or bug in stackdepth() */ 3459 if (instr->i_jrel || instr->i_jabs) { 3460 target_depth = depth; 3461 if (instr->i_opcode == FOR_ITER) { 3462 target_depth = depth-2; 3463 } else if (instr->i_opcode == SETUP_FINALLY || 3464 instr->i_opcode == SETUP_EXCEPT) { 3465 target_depth = depth+3; 3466 if (target_depth > maxdepth) 3467 maxdepth = target_depth; 3468 } 3469 maxdepth = stackdepth_walk(c, instr->i_target, 3470 target_depth, maxdepth); 3471 if (instr->i_opcode == JUMP_ABSOLUTE || 3472 instr->i_opcode == JUMP_FORWARD) { 3473 goto out; /* remaining code is dead */ 3474 } 3475 } 3476 } 3477 if (b->b_next) 3478 maxdepth = stackdepth_walk(c, b->b_next, depth, maxdepth); 3479 out: 3480 b->b_seen = 0; 3481 return maxdepth; 3482 } 3483 3484 /* Find the flow path that needs the largest stack. We assume that 3485 * cycles in the flow graph have no net effect on the stack depth. 3486 */ 3487 static int 3488 stackdepth(struct compiler *c) 3489 { 3490 basicblock *b, *entryblock; 3491 entryblock = NULL; 3492 for (b = c->u->u_blocks; b != NULL; b = b->b_list) { 3493 b->b_seen = 0; 3494 b->b_startdepth = INT_MIN; 3495 entryblock = b; 3496 } 3497 if (!entryblock) 3498 return 0; 3499 return stackdepth_walk(c, entryblock, 0, 0); 3500 } 3501 3502 static int 3503 assemble_init(struct assembler *a, int nblocks, int firstlineno) 3504 { 3505 memset(a, 0, sizeof(struct assembler)); 3506 a->a_lineno = firstlineno; 3507 a->a_bytecode = PyString_FromStringAndSize(NULL, DEFAULT_CODE_SIZE); 3508 if (!a->a_bytecode) 3509 return 0; 3510 a->a_lnotab = PyString_FromStringAndSize(NULL, DEFAULT_LNOTAB_SIZE); 3511 if (!a->a_lnotab) 3512 return 0; 3513 if (nblocks > PY_SIZE_MAX / sizeof(basicblock *)) { 3514 PyErr_NoMemory(); 3515 return 0; 3516 } 3517 a->a_postorder = (basicblock **)PyObject_Malloc( 3518 sizeof(basicblock *) * nblocks); 3519 if (!a->a_postorder) { 3520 PyErr_NoMemory(); 3521 return 0; 3522 } 3523 return 1; 3524 } 3525 3526 static void 3527 assemble_free(struct assembler *a) 3528 { 3529 Py_XDECREF(a->a_bytecode); 3530 Py_XDECREF(a->a_lnotab); 3531 if (a->a_postorder) 3532 PyObject_Free(a->a_postorder); 3533 } 3534 3535 /* Return the size of a basic block in bytes. */ 3536 3537 static int 3538 instrsize(struct instr *instr) 3539 { 3540 if (!instr->i_hasarg) 3541 return 1; /* 1 byte for the opcode*/ 3542 if (instr->i_oparg > 0xffff) 3543 return 6; /* 1 (opcode) + 1 (EXTENDED_ARG opcode) + 2 (oparg) + 2(oparg extended) */ 3544 return 3; /* 1 (opcode) + 2 (oparg) */ 3545 } 3546 3547 static int 3548 blocksize(basicblock *b) 3549 { 3550 int i; 3551 int size = 0; 3552 3553 for (i = 0; i < b->b_iused; i++) 3554 size += instrsize(&b->b_instr[i]); 3555 return size; 3556 } 3557 3558 /* Appends a pair to the end of the line number table, a_lnotab, representing 3559 the instruction's bytecode offset and line number. See 3560 Objects/lnotab_notes.txt for the description of the line number table. */ 3561 3562 static int 3563 assemble_lnotab(struct assembler *a, struct instr *i) 3564 { 3565 int d_bytecode, d_lineno; 3566 int len; 3567 unsigned char *lnotab; 3568 3569 d_bytecode = a->a_offset - a->a_lineno_off; 3570 d_lineno = i->i_lineno - a->a_lineno; 3571 3572 assert(d_bytecode >= 0); 3573 assert(d_lineno >= 0); 3574 3575 if(d_bytecode == 0 && d_lineno == 0) 3576 return 1; 3577 3578 if (d_bytecode > 255) { 3579 int j, nbytes, ncodes = d_bytecode / 255; 3580 nbytes = a->a_lnotab_off + 2 * ncodes; 3581 len = PyString_GET_SIZE(a->a_lnotab); 3582 if (nbytes >= len) { 3583 if ((len <= INT_MAX / 2) && (len * 2 < nbytes)) 3584 len = nbytes; 3585 else if (len <= INT_MAX / 2) 3586 len *= 2; 3587 else { 3588 PyErr_NoMemory(); 3589 return 0; 3590 } 3591 if (_PyString_Resize(&a->a_lnotab, len) < 0) 3592 return 0; 3593 } 3594 lnotab = (unsigned char *) 3595 PyString_AS_STRING(a->a_lnotab) + a->a_lnotab_off; 3596 for (j = 0; j < ncodes; j++) { 3597 *lnotab++ = 255; 3598 *lnotab++ = 0; 3599 } 3600 d_bytecode -= ncodes * 255; 3601 a->a_lnotab_off += ncodes * 2; 3602 } 3603 assert(d_bytecode <= 255); 3604 if (d_lineno > 255) { 3605 int j, nbytes, ncodes = d_lineno / 255; 3606 nbytes = a->a_lnotab_off + 2 * ncodes; 3607 len = PyString_GET_SIZE(a->a_lnotab); 3608 if (nbytes >= len) { 3609 if ((len <= INT_MAX / 2) && len * 2 < nbytes) 3610 len = nbytes; 3611 else if (len <= INT_MAX / 2) 3612 len *= 2; 3613 else { 3614 PyErr_NoMemory(); 3615 return 0; 3616 } 3617 if (_PyString_Resize(&a->a_lnotab, len) < 0) 3618 return 0; 3619 } 3620 lnotab = (unsigned char *) 3621 PyString_AS_STRING(a->a_lnotab) + a->a_lnotab_off; 3622 *lnotab++ = d_bytecode; 3623 *lnotab++ = 255; 3624 d_bytecode = 0; 3625 for (j = 1; j < ncodes; j++) { 3626 *lnotab++ = 0; 3627 *lnotab++ = 255; 3628 } 3629 d_lineno -= ncodes * 255; 3630 a->a_lnotab_off += ncodes * 2; 3631 } 3632 3633 len = PyString_GET_SIZE(a->a_lnotab); 3634 if (a->a_lnotab_off + 2 >= len) { 3635 if (_PyString_Resize(&a->a_lnotab, len * 2) < 0) 3636 return 0; 3637 } 3638 lnotab = (unsigned char *) 3639 PyString_AS_STRING(a->a_lnotab) + a->a_lnotab_off; 3640 3641 a->a_lnotab_off += 2; 3642 if (d_bytecode) { 3643 *lnotab++ = d_bytecode; 3644 *lnotab++ = d_lineno; 3645 } 3646 else { /* First line of a block; def stmt, etc. */ 3647 *lnotab++ = 0; 3648 *lnotab++ = d_lineno; 3649 } 3650 a->a_lineno = i->i_lineno; 3651 a->a_lineno_off = a->a_offset; 3652 return 1; 3653 } 3654 3655 /* assemble_emit() 3656 Extend the bytecode with a new instruction. 3657 Update lnotab if necessary. 3658 */ 3659 3660 static int 3661 assemble_emit(struct assembler *a, struct instr *i) 3662 { 3663 int size, arg = 0, ext = 0; 3664 Py_ssize_t len = PyString_GET_SIZE(a->a_bytecode); 3665 char *code; 3666 3667 size = instrsize(i); 3668 if (i->i_hasarg) { 3669 arg = i->i_oparg; 3670 ext = arg >> 16; 3671 } 3672 if (i->i_lineno && !assemble_lnotab(a, i)) 3673 return 0; 3674 if (a->a_offset + size >= len) { 3675 if (len > PY_SSIZE_T_MAX / 2) 3676 return 0; 3677 if (_PyString_Resize(&a->a_bytecode, len * 2) < 0) 3678 return 0; 3679 } 3680 code = PyString_AS_STRING(a->a_bytecode) + a->a_offset; 3681 a->a_offset += size; 3682 if (size == 6) { 3683 assert(i->i_hasarg); 3684 *code++ = (char)EXTENDED_ARG; 3685 *code++ = ext & 0xff; 3686 *code++ = ext >> 8; 3687 arg &= 0xffff; 3688 } 3689 *code++ = i->i_opcode; 3690 if (i->i_hasarg) { 3691 assert(size == 3 || size == 6); 3692 *code++ = arg & 0xff; 3693 *code++ = arg >> 8; 3694 } 3695 return 1; 3696 } 3697 3698 static void 3699 assemble_jump_offsets(struct assembler *a, struct compiler *c) 3700 { 3701 basicblock *b; 3702 int bsize, totsize, extended_arg_count = 0, last_extended_arg_count; 3703 int i; 3704 3705 /* Compute the size of each block and fixup jump args. 3706 Replace block pointer with position in bytecode. */ 3707 do { 3708 totsize = 0; 3709 for (i = a->a_nblocks - 1; i >= 0; i--) { 3710 b = a->a_postorder[i]; 3711 bsize = blocksize(b); 3712 b->b_offset = totsize; 3713 totsize += bsize; 3714 } 3715 last_extended_arg_count = extended_arg_count; 3716 extended_arg_count = 0; 3717 for (b = c->u->u_blocks; b != NULL; b = b->b_list) { 3718 bsize = b->b_offset; 3719 for (i = 0; i < b->b_iused; i++) { 3720 struct instr *instr = &b->b_instr[i]; 3721 /* Relative jumps are computed relative to 3722 the instruction pointer after fetching 3723 the jump instruction. 3724 */ 3725 bsize += instrsize(instr); 3726 if (instr->i_jabs) 3727 instr->i_oparg = instr->i_target->b_offset; 3728 else if (instr->i_jrel) { 3729 int delta = instr->i_target->b_offset - bsize; 3730 instr->i_oparg = delta; 3731 } 3732 else 3733 continue; 3734 if (instr->i_oparg > 0xffff) 3735 extended_arg_count++; 3736 } 3737 } 3738 3739 /* XXX: This is an awful hack that could hurt performance, but 3740 on the bright side it should work until we come up 3741 with a better solution. 3742 3743 The issue is that in the first loop blocksize() is called 3744 which calls instrsize() which requires i_oparg be set 3745 appropriately. There is a bootstrap problem because 3746 i_oparg is calculated in the second loop above. 3747 3748 So we loop until we stop seeing new EXTENDED_ARGs. 3749 The only EXTENDED_ARGs that could be popping up are 3750 ones in jump instructions. So this should converge 3751 fairly quickly. 3752 */ 3753 } while (last_extended_arg_count != extended_arg_count); 3754 } 3755 3756 static PyObject * 3757 dict_keys_inorder(PyObject *dict, int offset) 3758 { 3759 PyObject *tuple, *k, *v; 3760 Py_ssize_t i, pos = 0, size = PyDict_Size(dict); 3761 3762 tuple = PyTuple_New(size); 3763 if (tuple == NULL) 3764 return NULL; 3765 while (PyDict_Next(dict, &pos, &k, &v)) { 3766 i = PyInt_AS_LONG(v); 3767 /* The keys of the dictionary are tuples. (see compiler_add_o) 3768 The object we want is always first, though. */ 3769 k = PyTuple_GET_ITEM(k, 0); 3770 Py_INCREF(k); 3771 assert((i - offset) < size); 3772 assert((i - offset) >= 0); 3773 PyTuple_SET_ITEM(tuple, i - offset, k); 3774 } 3775 return tuple; 3776 } 3777 3778 static int 3779 compute_code_flags(struct compiler *c) 3780 { 3781 PySTEntryObject *ste = c->u->u_ste; 3782 int flags = 0, n; 3783 if (ste->ste_type != ModuleBlock) 3784 flags |= CO_NEWLOCALS; 3785 if (ste->ste_type == FunctionBlock) { 3786 if (!ste->ste_unoptimized) 3787 flags |= CO_OPTIMIZED; 3788 if (ste->ste_nested) 3789 flags |= CO_NESTED; 3790 if (ste->ste_generator) 3791 flags |= CO_GENERATOR; 3792 if (ste->ste_varargs) 3793 flags |= CO_VARARGS; 3794 if (ste->ste_varkeywords) 3795 flags |= CO_VARKEYWORDS; 3796 } 3797 3798 /* (Only) inherit compilerflags in PyCF_MASK */ 3799 flags |= (c->c_flags->cf_flags & PyCF_MASK); 3800 3801 n = PyDict_Size(c->u->u_freevars); 3802 if (n < 0) 3803 return -1; 3804 if (n == 0) { 3805 n = PyDict_Size(c->u->u_cellvars); 3806 if (n < 0) 3807 return -1; 3808 if (n == 0) { 3809 flags |= CO_NOFREE; 3810 } 3811 } 3812 3813 return flags; 3814 } 3815 3816 static PyCodeObject * 3817 makecode(struct compiler *c, struct assembler *a) 3818 { 3819 PyObject *tmp; 3820 PyCodeObject *co = NULL; 3821 PyObject *consts = NULL; 3822 PyObject *names = NULL; 3823 PyObject *varnames = NULL; 3824 PyObject *filename = NULL; 3825 PyObject *name = NULL; 3826 PyObject *freevars = NULL; 3827 PyObject *cellvars = NULL; 3828 PyObject *bytecode = NULL; 3829 int nlocals, flags; 3830 3831 tmp = dict_keys_inorder(c->u->u_consts, 0); 3832 if (!tmp) 3833 goto error; 3834 consts = PySequence_List(tmp); /* optimize_code requires a list */ 3835 Py_DECREF(tmp); 3836 3837 names = dict_keys_inorder(c->u->u_names, 0); 3838 varnames = dict_keys_inorder(c->u->u_varnames, 0); 3839 if (!consts || !names || !varnames) 3840 goto error; 3841 3842 cellvars = dict_keys_inorder(c->u->u_cellvars, 0); 3843 if (!cellvars) 3844 goto error; 3845 freevars = dict_keys_inorder(c->u->u_freevars, PyTuple_Size(cellvars)); 3846 if (!freevars) 3847 goto error; 3848 filename = PyString_FromString(c->c_filename); 3849 if (!filename) 3850 goto error; 3851 3852 nlocals = PyDict_Size(c->u->u_varnames); 3853 flags = compute_code_flags(c); 3854 if (flags < 0) 3855 goto error; 3856 3857 bytecode = PyCode_Optimize(a->a_bytecode, consts, names, a->a_lnotab); 3858 if (!bytecode) 3859 goto error; 3860 3861 tmp = PyList_AsTuple(consts); /* PyCode_New requires a tuple */ 3862 if (!tmp) 3863 goto error; 3864 Py_DECREF(consts); 3865 consts = tmp; 3866 3867 co = PyCode_New(c->u->u_argcount, nlocals, stackdepth(c), flags, 3868 bytecode, consts, names, varnames, 3869 freevars, cellvars, 3870 filename, c->u->u_name, 3871 c->u->u_firstlineno, 3872 a->a_lnotab); 3873 error: 3874 Py_XDECREF(consts); 3875 Py_XDECREF(names); 3876 Py_XDECREF(varnames); 3877 Py_XDECREF(filename); 3878 Py_XDECREF(name); 3879 Py_XDECREF(freevars); 3880 Py_XDECREF(cellvars); 3881 Py_XDECREF(bytecode); 3882 return co; 3883 } 3884 3885 3886 /* For debugging purposes only */ 3887 #if 0 3888 static void 3889 dump_instr(const struct instr *i) 3890 { 3891 const char *jrel = i->i_jrel ? "jrel " : ""; 3892 const char *jabs = i->i_jabs ? "jabs " : ""; 3893 char arg[128]; 3894 3895 *arg = '\0'; 3896 if (i->i_hasarg) 3897 sprintf(arg, "arg: %d ", i->i_oparg); 3898 3899 fprintf(stderr, "line: %d, opcode: %d %s%s%s\n", 3900 i->i_lineno, i->i_opcode, arg, jabs, jrel); 3901 } 3902 3903 static void 3904 dump_basicblock(const basicblock *b) 3905 { 3906 const char *seen = b->b_seen ? "seen " : ""; 3907 const char *b_return = b->b_return ? "return " : ""; 3908 fprintf(stderr, "used: %d, depth: %d, offset: %d %s%s\n", 3909 b->b_iused, b->b_startdepth, b->b_offset, seen, b_return); 3910 if (b->b_instr) { 3911 int i; 3912 for (i = 0; i < b->b_iused; i++) { 3913 fprintf(stderr, " [%02d] ", i); 3914 dump_instr(b->b_instr + i); 3915 } 3916 } 3917 } 3918 #endif 3919 3920 static PyCodeObject * 3921 assemble(struct compiler *c, int addNone) 3922 { 3923 basicblock *b, *entryblock; 3924 struct assembler a; 3925 int i, j, nblocks;