Python/ceval.c

   1
   2 /* Execute compiled code */
   3
   4 /* XXX TO DO:
   5    XXX speed up searching for keywords by using a dictionary
   6    XXX document it!
   7    */
   8
   9 /* enable more aggressive intra-module optimizations, where available */
  10 #define PY_LOCAL_AGGRESSIVE
  11
  12 #include "Python.h"
  13
  14 #include "code.h"
  15 #include "frameobject.h"
  16 #include "eval.h"
  17 #include "opcode.h"
  18 #include "structmember.h"
  19
  20 #include <ctype.h>
  21
  22 #ifndef WITH_TSC
  23
  24 #define READ_TIMESTAMP(var)
  25
  26 #else
  27
  28 typedef unsigned long long uint64;
  29
  30 #if defined(__ppc__) /* <- Don't know if this is the correct symbol; this
  31                            section should work for GCC on any PowerPC
  32                            platform, irrespective of OS.
  33                            POWER?  Who knows :-) */
  34
  35 #define READ_TIMESTAMP(var) ppc_getcounter(&var)
  36
  37 static void
  38 ppc_getcounter(uint64 *v)
  39 {
  40         register unsigned long tbu, tb, tbu2;
  41
  42   loop:
  43         asm volatile ("mftbu %0" : "=r" (tbu) );
  44         asm volatile ("mftb  %0" : "=r" (tb)  );
  45         asm volatile ("mftbu %0" : "=r" (tbu2));
  46         if (__builtin_expect(tbu != tbu2, 0)) goto loop;
  47
  48         /* The slightly peculiar way of writing the next lines is
  49            compiled better by GCC than any other way I tried. */
  50         ((long*)(v))[0] = tbu;
  51         ((long*)(v))[1] = tb;
  52 }
  53
  54 #else /* this is for linux/x86 (and probably any other GCC/x86 combo) */
  55
  56 #define READ_TIMESTAMP(val) \
  57      __asm__ __volatile__("rdtsc" : "=A" (val))
  58
  59 #endif
  60
  61 void dump_tsc(int opcode, int ticked, uint64 inst0, uint64 inst1,
  62               uint64 loop0, uint64 loop1, uint64 intr0, uint64 intr1)
  63 {
  64         uint64 intr, inst, loop;
  65         PyThreadState *tstate = PyThreadState_Get();
  66         if (!tstate->interp->tscdump)
  67                 return;
  68         intr = intr1 - intr0;
  69         inst = inst1 - inst0 - intr;
  70         loop = loop1 - loop0 - intr;
  71         fprintf(stderr, "opcode=%03d t=%d inst=%06lld loop=%06lld\n",
  72                 opcode, ticked, inst, loop);
  73 }
  74
  75 #endif
  76
  77 /* Turn this on if your compiler chokes on the big switch: */
  78 /* #define CASE_TOO_BIG 1 */
  79
  80 #ifdef Py_DEBUG
  81 /* For debugging the interpreter: */
  82 #define LLTRACE  1      /* Low-level trace feature */
  83 #define CHECKEXC 1      /* Double-check exception checking */
  84 #endif
  85
  86 typedef PyObject *(*callproc)(PyObject *, PyObject *, PyObject *);
  87
  88 /* Forward declarations */
  89 #ifdef WITH_TSC
  90 static PyObject * call_function(PyObject ***, int, uint64*, uint64*);
  91 #else
  92 static PyObject * call_function(PyObject ***, int);
  93 #endif
  94 static PyObject * fast_function(PyObject *, PyObject ***, int, int, int);
  95 static PyObject * do_call(PyObject *, PyObject ***, int, int);
  96 static PyObject * ext_do_call(PyObject *, PyObject ***, int, int, int);
  97 static PyObject * update_keyword_args(PyObject *, int, PyObject ***,
  98                                       PyObject *);
  99 static PyObject * update_star_args(int, int, PyObject *, PyObject ***);
 100 static PyObject * load_args(PyObject ***, int);
 101 #define CALL_FLAG_VAR 1
 102 #define CALL_FLAG_KW 2
 103
 104 #ifdef LLTRACE
 105 static int lltrace;
 106 static int prtrace(PyObject *, char *);
 107 #endif
 108 static int call_trace(Py_tracefunc, PyObject *, PyFrameObject *,
 109                       int, PyObject *);
 110 static int call_trace_protected(Py_tracefunc, PyObject *,
 111                                  PyFrameObject *, int, PyObject *);
 112 static void call_exc_trace(Py_tracefunc, PyObject *, PyFrameObject *);
 113 static int maybe_call_line_trace(Py_tracefunc, PyObject *,
 114                                   PyFrameObject *, int *, int *, int *);
 115
 116 static PyObject * apply_slice(PyObject *, PyObject *, PyObject *);
 117 static int assign_slice(PyObject *, PyObject *,
 118                         PyObject *, PyObject *);
 119 static PyObject * cmp_outcome(int, PyObject *, PyObject *);
 120 static PyObject * import_from(PyObject *, PyObject *);
 121 static int import_all_from(PyObject *, PyObject *);
 122 static PyObject * build_class(PyObject *, PyObject *, PyObject *);
 123 static int exec_statement(PyFrameObject *,
 124                           PyObject *, PyObject *, PyObject *);
 125 static void set_exc_info(PyThreadState *, PyObject *, PyObject *, PyObject *);
 126 static void reset_exc_info(PyThreadState *);
 127 static void format_exc_check_arg(PyObject *, char *, PyObject *);
 128 static PyObject * string_concatenate(PyObject *, PyObject *,
 129                                     PyFrameObject *, unsigned char *);
 130
 131 #define NAME_ERROR_MSG \
 132         "name '%.200s' is not defined"
 133 #define GLOBAL_NAME_ERROR_MSG \
 134         "global name '%.200s' is not defined"
 135 #define UNBOUNDLOCAL_ERROR_MSG \
 136         "local variable '%.200s' referenced before assignment"
 137 #define UNBOUNDFREE_ERROR_MSG \
 138         "free variable '%.200s' referenced before assignment" \
 139         " in enclosing scope"
 140
 141 /* Dynamic execution profile */
 142 #ifdef DYNAMIC_EXECUTION_PROFILE
 143 #ifdef DXPAIRS
 144 static long dxpairs[257][256];
 145 #define dxp dxpairs[256]
 146 #else
 147 static long dxp[256];
 148 #endif
 149 #endif
 150
 151 /* Function call profile */
 152 #ifdef CALL_PROFILE
 153 #define PCALL_NUM 11
 154 static int pcall[PCALL_NUM];
 155
 156 #define PCALL_ALL 0
 157 #define PCALL_FUNCTION 1
 158 #define PCALL_FAST_FUNCTION 2
 159 #define PCALL_FASTER_FUNCTION 3
 160 #define PCALL_METHOD 4
 161 #define PCALL_BOUND_METHOD 5
 162 #define PCALL_CFUNCTION 6
 163 #define PCALL_TYPE 7
 164 #define PCALL_GENERATOR 8
 165 #define PCALL_OTHER 9
 166 #define PCALL_POP 10
 167
 168 /* Notes about the statistics
 169
 170    PCALL_FAST stats
 171
 172    FAST_FUNCTION means no argument tuple needs to be created.
 173    FASTER_FUNCTION means that the fast-path frame setup code is used.
 174
 175    If there is a method call where the call can be optimized by changing
 176    the argument tuple and calling the function directly, it gets recorded
 177    twice.
 178
 179    As a result, the relationship among the statistics appears to be
 180    PCALL_ALL == PCALL_FUNCTION + PCALL_METHOD - PCALL_BOUND_METHOD +
 181                 PCALL_CFUNCTION + PCALL_TYPE + PCALL_GENERATOR + PCALL_OTHER
 182    PCALL_FUNCTION > PCALL_FAST_FUNCTION > PCALL_FASTER_FUNCTION
 183    PCALL_METHOD > PCALL_BOUND_METHOD
 184 */
 185
 186 #define PCALL(POS) pcall[POS]++
 187
 188 PyObject *
 189 PyEval_GetCallStats(PyObject *self)
 190 {
 191         return Py_BuildValue("iiiiiiiiiii",
 192                              pcall[0], pcall[1], pcall[2], pcall[3],
 193                              pcall[4], pcall[5], pcall[6], pcall[7],
 194                              pcall[8], pcall[9], pcall[10]);
 195 }
 196 #else
 197 #define PCALL(O)
 198
 199 PyObject *
 200 PyEval_GetCallStats(PyObject *self)
 201 {
 202         Py_INCREF(Py_None);
 203         return Py_None;
 204 }
 205 #endif
 206
 207
 208 #ifdef WITH_THREAD
 209
 210 #ifdef HAVE_ERRNO_H
 211 #include <errno.h>
 212 #endif
 213 #include "pythread.h"
 214
 215 static PyThread_type_lock interpreter_lock = 0; /* This is the GIL */
 216 static long main_thread = 0;
 217
 218 int
 219 PyEval_ThreadsInitialized(void)
 220 {
 221         return interpreter_lock != 0;
 222 }
 223
 224 void
 225 PyEval_InitThreads(void)
 226 {
 227         if (interpreter_lock)
 228                 return;
 229         interpreter_lock = PyThread_allocate_lock();
 230         PyThread_acquire_lock(interpreter_lock, 1);
 231         main_thread = PyThread_get_thread_ident();
 232 }
 233
 234 void
 235 PyEval_AcquireLock(void)
 236 {
 237         PyThread_acquire_lock(interpreter_lock, 1);
 238 }
 239
 240 void
 241 PyEval_ReleaseLock(void)
 242 {
 243         PyThread_release_lock(interpreter_lock);
 244 }
 245
 246 void
 247 PyEval_AcquireThread(PyThreadState *tstate)
 248 {
 249         if (tstate == NULL)
 250                 Py_FatalError("PyEval_AcquireThread: NULL new thread state");
 251         /* Check someone has called PyEval_InitThreads() to create the lock */
 252         assert(interpreter_lock);
 253         PyThread_acquire_lock(interpreter_lock, 1);
 254         if (PyThreadState_Swap(tstate) != NULL)
 255                 Py_FatalError(
 256                         "PyEval_AcquireThread: non-NULL old thread state");
 257 }
 258
 259 void
 260 PyEval_ReleaseThread(PyThreadState *tstate)
 261 {
 262         if (tstate == NULL)
 263                 Py_FatalError("PyEval_ReleaseThread: NULL thread state");
 264         if (PyThreadState_Swap(NULL) != tstate)
 265                 Py_FatalError("PyEval_ReleaseThread: wrong thread state");
 266         PyThread_release_lock(interpreter_lock);
 267 }
 268
 269 /* This function is called from PyOS_AfterFork to ensure that newly
 270    created child processes don't hold locks referring to threads which
 271    are not running in the child process.  (This could also be done using
 272    pthread_atfork mechanism, at least for the pthreads implementation.) */
 273
 274 void
 275 PyEval_ReInitThreads(void)
 276 {
 277         PyObject *threading, *result;
 278         PyThreadState *tstate;
 279
 280         if (!interpreter_lock)
 281                 return;
 282         /*XXX Can't use PyThread_free_lock here because it does too
 283           much error-checking.  Doing this cleanly would require
 284           adding a new function to each thread_*.h.  Instead, just
 285           create a new lock and waste a little bit of memory */
 286         interpreter_lock = PyThread_allocate_lock();
 287         PyThread_acquire_lock(interpreter_lock, 1);
 288         main_thread = PyThread_get_thread_ident();
 289
 290         /* Update the threading module with the new state.
 291          */
 292         tstate = PyThreadState_GET();
 293         threading = PyMapping_GetItemString(tstate->interp->modules,
 294                                             "threading");
 295         if (threading == NULL) {
 296                 /* threading not imported */
 297                 PyErr_Clear();
 298                 return;
 299         }
 300         result = PyObject_CallMethod(threading, "_after_fork", NULL);
 301         if (result == NULL)
 302                 PyErr_WriteUnraisable(threading);
 303         else
 304                 Py_DECREF(result);
 305         Py_DECREF(threading);
 306 }
 307 #endif
 308
 309 /* Functions save_thread and restore_thread are always defined so
 310    dynamically loaded modules needn't be compiled separately for use
 311    with and without threads: */
 312
 313 PyThreadState *
 314 PyEval_SaveThread(void)
 315 {
 316         PyThreadState *tstate = PyThreadState_Swap(NULL);
 317         if (tstate == NULL)
 318                 Py_FatalError("PyEval_SaveThread: NULL tstate");
 319 #ifdef WITH_THREAD
 320         if (interpreter_lock)
 321                 PyThread_release_lock(interpreter_lock);
 322 #endif
 323         return tstate;
 324 }
 325
 326 void
 327 PyEval_RestoreThread(PyThreadState *tstate)
 328 {
 329         if (tstate == NULL)
 330                 Py_FatalError("PyEval_RestoreThread: NULL tstate");
 331 #ifdef WITH_THREAD
 332         if (interpreter_lock) {
 333                 int err = errno;
 334                 PyThread_acquire_lock(interpreter_lock, 1);
 335                 errno = err;
 336         }
 337 #endif
 338         PyThreadState_Swap(tstate);
 339 }
 340
 341
 342 /* Mechanism whereby asynchronously executing callbacks (e.g. UNIX
 343    signal handlers or Mac I/O completion routines) can schedule calls
 344    to a function to be called synchronously.
 345    The synchronous function is called with one void* argument.
 346    It should return 0 for success or -1 for failure -- failure should
 347    be accompanied by an exception.
 348
 349    If registry succeeds, the registry function returns 0; if it fails
 350    (e.g. due to too many pending calls) it returns -1 (without setting
 351    an exception condition).
 352
 353    Note that because registry may occur from within signal handlers,
 354    or other asynchronous events, calling malloc() is unsafe!
 355
 356 #ifdef WITH_THREAD
 357    Any thread can schedule pending calls, but only the main thread
 358    will execute them.
 359 #endif
 360
 361    XXX WARNING!  ASYNCHRONOUSLY EXECUTING CODE!
 362    There are two possible race conditions:
 363    (1) nested asynchronous registry calls;
 364    (2) registry calls made while pending calls are being processed.
 365    While (1) is very unlikely, (2) is a real possibility.
 366    The current code is safe against (2), but not against (1).
 367    The safety against (2) is derived from the fact that only one
 368    thread (the main thread) ever takes things out of the queue.
 369
 370    XXX Darn!  With the advent of thread state, we should have an array
 371    of pending calls per thread in the thread state!  Later...
 372 */
 373
 374 #define NPENDINGCALLS 32
 375 static struct {
 376         int (*func)(void *);
 377         void *arg;
 378 } pendingcalls[NPENDINGCALLS];
 379 static volatile int pendingfirst = 0;
 380 static volatile int pendinglast = 0;
 381 static volatile int things_to_do = 0;
 382
 383 int
 384 Py_AddPendingCall(int (*func)(void *), void *arg)
 385 {
 386         static volatile int busy = 0;
 387         int i, j;
 388         /* XXX Begin critical section */
 389         /* XXX If you want this to be safe against nested
 390            XXX asynchronous calls, you'll have to work harder! */
 391         if (busy)
 392                 return -1;
 393         busy = 1;
 394         i = pendinglast;
 395         j = (i + 1) % NPENDINGCALLS;
 396         if (j == pendingfirst) {
 397                 busy = 0;
 398                 return -1; /* Queue full */
 399         }
 400         pendingcalls[i].func = func;
 401         pendingcalls[i].arg = arg;
 402         pendinglast = j;
 403
 404         _Py_Ticker = 0;
 405         things_to_do = 1; /* Signal main loop */
 406         busy = 0;
 407         /* XXX End critical section */
 408         return 0;
 409 }
 410
 411 int
 412 Py_MakePendingCalls(void)
 413 {
 414         static int busy = 0;
 415 #ifdef WITH_THREAD
 416         if (main_thread && PyThread_get_thread_ident() != main_thread)
 417                 return 0;
 418 #endif
 419         if (busy)
 420                 return 0;
 421         busy = 1;
 422         things_to_do = 0;
 423         for (;;) {
 424                 int i;
 425                 int (*func)(void *);
 426                 void *arg;
 427                 i = pendingfirst;
 428                 if (i == pendinglast)
 429                         break; /* Queue empty */
 430                 func = pendingcalls[i].func;
 431                 arg = pendingcalls[i].arg;
 432                 pendingfirst = (i + 1) % NPENDINGCALLS;
 433                 if (func(arg) < 0) {
 434                         busy = 0;
 435                         things_to_do = 1; /* We're not done yet */
 436                         return -1;
 437                 }
 438         }
 439         busy = 0;
 440         return 0;
 441 }
 442
 443
 444 /* The interpreter's recursion limit */
 445
 446 #ifndef Py_DEFAULT_RECURSION_LIMIT
 447 #define Py_DEFAULT_RECURSION_LIMIT 1000
 448 #endif
 449 static int recursion_limit = Py_DEFAULT_RECURSION_LIMIT;
 450 int _Py_CheckRecursionLimit = Py_DEFAULT_RECURSION_LIMIT;
 451
 452 int
 453 Py_GetRecursionLimit(void)
 454 {
 455         return recursion_limit;
 456 }
 457
 458 void
 459 Py_SetRecursionLimit(int new_limit)
 460 {
 461         recursion_limit = new_limit;
 462         _Py_CheckRecursionLimit = recursion_limit;
 463 }
 464
 465 /* the macro Py_EnterRecursiveCall() only calls _Py_CheckRecursiveCall()
 466    if the recursion_depth reaches _Py_CheckRecursionLimit.
 467    If USE_STACKCHECK, the macro decrements _Py_CheckRecursionLimit
 468    to guarantee that _Py_CheckRecursiveCall() is regularly called.
 469    Without USE_STACKCHECK, there is no need for this. */
 470 int
 471 _Py_CheckRecursiveCall(char *where)
 472 {
 473         PyThreadState *tstate = PyThreadState_GET();
 474
 475 #ifdef USE_STACKCHECK
 476         if (PyOS_CheckStack()) {
 477                 --tstate->recursion_depth;
 478                 PyErr_SetString(PyExc_MemoryError, "Stack overflow");
 479                 return -1;
 480         }
 481 #endif
 482         if (tstate->recursion_depth > recursion_limit) {
 483                 --tstate->recursion_depth;
 484                 PyErr_Format(PyExc_RuntimeError,
 485                              "maximum recursion depth exceeded%s",
 486                              where);
 487                 return -1;
 488         }
 489         _Py_CheckRecursionLimit = recursion_limit;
 490         return 0;
 491 }
 492
 493 /* Status code for main loop (reason for stack unwind) */
 494 enum why_code {
 495                 WHY_NOT =       0x0001, /* No error */
 496                 WHY_EXCEPTION = 0x0002, /* Exception occurred */
 497                 WHY_RERAISE =   0x0004, /* Exception re-raised by 'finally' */
 498                 WHY_RETURN =    0x0008, /* 'return' statement */
 499                 WHY_BREAK =     0x0010, /* 'break' statement */
 500                 WHY_CONTINUE =  0x0020, /* 'continue' statement */
 501                 WHY_YIELD =     0x0040  /* 'yield' operator */
 502 };
 503
 504 static enum why_code do_raise(PyObject *, PyObject *, PyObject *);
 505 static int unpack_iterable(PyObject *, int, PyObject **);
 506
 507 /* Records whether tracing is on for any thread.  Counts the number of
 508    threads for which tstate->c_tracefunc is non-NULL, so if the value
 509    is 0, we know we don't have to check this thread's c_tracefunc.
 510    This speeds up the if statement in PyEval_EvalFrameEx() after
 511    fast_next_opcode*/
 512 static int _Py_TracingPossible = 0;
 513
 514 /* for manipulating the thread switch and periodic "stuff" - used to be
 515    per thread, now just a pair o' globals */
 516 int _Py_CheckInterval = 100;
 517 volatile int _Py_Ticker = 100;
 518
 519 PyObject *
 520 PyEval_EvalCode(PyCodeObject *co, PyObject *globals, PyObject *locals)
 521 {
 522         return PyEval_EvalCodeEx(co,
 523                           globals, locals,
 524                           (PyObject **)NULL, 0,
 525                           (PyObject **)NULL, 0,
 526                           (PyObject **)NULL, 0,
 527                           NULL);
 528 }
 529
 530
 531 /* Interpreter main loop */
 532
 533 PyObject *
 534 PyEval_EvalFrame(PyFrameObject *f) {
 535         /* This is for backward compatibility with extension modules that
 536            used this API; core interpreter code should call
 537            PyEval_EvalFrameEx() */
 538         return PyEval_EvalFrameEx(f, 0);
 539 }
 540
 541 PyObject *
 542 PyEval_EvalFrameEx(PyFrameObject *f, int throwflag)
 543 {
 544 #ifdef DXPAIRS
 545         int lastopcode = 0;
 546 #endif
 547         register PyObject **stack_pointer;  /* Next free slot in value stack */
 548         register unsigned char *next_instr;
 549         register int opcode;    /* Current opcode */
 550         register int oparg;     /* Current opcode argument, if any */
 551         register enum why_code why; /* Reason for block stack unwind */
 552         register int err;       /* Error status -- nonzero if error */
 553         register PyObject *x;   /* Result object -- NULL if error */
 554         register PyObject *v;   /* Temporary objects popped off stack */
 555         register PyObject *w;
 556         register PyObject *u;
 557         register PyObject *t;
 558         register PyObject *stream = NULL;    /* for PRINT opcodes */
 559         register PyObject **fastlocals, **freevars;
 560         PyObject *retval = NULL;        /* Return value */
 561         PyThreadState *tstate = PyThreadState_GET();
 562         PyCodeObject *co;
 563
 564         /* when tracing we set things up so that
 565
 566                not (instr_lb <= current_bytecode_offset < instr_ub)
 567
 568            is true when the line being executed has changed.  The
 569            initial values are such as to make this false the first
 570            time it is tested. */
 571         int instr_ub = -1, instr_lb = 0, instr_prev = -1;
 572
 573         unsigned char *first_instr;
 574         PyObject *names;
 575         PyObject *consts;
 576 #if defined(Py_DEBUG) || defined(LLTRACE)
 577         /* Make it easier to find out where we are with a debugger */
 578         char *filename;
 579 #endif
 580
 581 /* Tuple access macros */
 582
 583 #ifndef Py_DEBUG
 584 #define GETITEM(v, i) PyTuple_GET_ITEM((PyTupleObject *)(v), (i))
 585 #else
 586 #define GETITEM(v, i) PyTuple_GetItem((v), (i))
 587 #endif
 588
 589 #ifdef WITH_TSC
 590 /* Use Pentium timestamp counter to mark certain events:
 591    inst0 -- beginning of switch statement for opcode dispatch
 592    inst1 -- end of switch statement (may be skipped)
 593    loop0 -- the top of the mainloop
 594    loop1 -- place where control returns again to top of mainloop
 595             (may be skipped)
 596    intr1 -- beginning of long interruption
 597    intr2 -- end of long interruption
 598
 599    Many opcodes call out to helper C functions.  In some cases, the
 600    time in those functions should be counted towards the time for the
 601    opcode, but not in all cases.  For example, a CALL_FUNCTION opcode
 602    calls another Python function; there's no point in charge all the
 603    bytecode executed by the called function to the caller.
 604
 605    It's hard to make a useful judgement statically.  In the presence
 606    of operator overloading, it's impossible to tell if a call will
 607    execute new Python code or not.
 608
 609    It's a case-by-case judgement.  I'll use intr1 for the following
 610    cases:
 611
 612    EXEC_STMT
 613    IMPORT_STAR
 614    IMPORT_FROM
 615    CALL_FUNCTION (and friends)
 616
 617  */
 618         uint64 inst0, inst1, loop0, loop1, intr0 = 0, intr1 = 0;
 619         int ticked = 0;
 620
 621         READ_TIMESTAMP(inst0);
 622         READ_TIMESTAMP(inst1);
 623         READ_TIMESTAMP(loop0);
 624         READ_TIMESTAMP(loop1);
 625
 626         /* shut up the compiler */
 627         opcode = 0;
 628 #endif
 629
 630 /* Code access macros */
 631
 632 #define INSTR_OFFSET()  ((int)(next_instr - first_instr))
 633 #define NEXTOP()        (*next_instr++)
 634 #define NEXTARG()       (next_instr += 2, (next_instr[-1]<<8) + next_instr[-2])
 635 #define PEEKARG()       ((next_instr[2]<<8) + next_instr[1])
 636 #define JUMPTO(x)       (next_instr = first_instr + (x))
 637 #define JUMPBY(x)       (next_instr += (x))
 638
 639 /* OpCode prediction macros
 640         Some opcodes tend to come in pairs thus making it possible to
 641         predict the second code when the first is run.  For example,
 642         COMPARE_OP is often followed by JUMP_IF_FALSE or JUMP_IF_TRUE.  And,
 643         those opcodes are often followed by a POP_TOP.
 644
 645         Verifying the prediction costs a single high-speed test of a register
 646         variable against a constant.  If the pairing was good, then the
 647         processor's own internal branch predication has a high likelihood of
 648         success, resulting in a nearly zero-overhead transition to the
 649         next opcode.  A successful prediction saves a trip through the eval-loop
 650         including its two unpredictable branches, the HAS_ARG test and the
 651         switch-case.  Combined with the processor's internal branch prediction,
 652         a successful PREDICT has the effect of making the two opcodes run as if
 653         they were a single new opcode with the bodies combined.
 654
 655     If collecting opcode statistics, your choices are to either keep the
 656         predictions turned-on and interpret the results as if some opcodes
 657         had been combined or turn-off predictions so that the opcode frequency
 658         counter updates for both opcodes.
 659 */
 660
 661 #ifdef DYNAMIC_EXECUTION_PROFILE
 662 #define PREDICT(op)             if (0) goto PRED_##op
 663 #else
 664 #define PREDICT(op)             if (*next_instr == op) goto PRED_##op
 665 #endif
 666
 667 #define PREDICTED(op)           PRED_##op: next_instr++
 668 #define PREDICTED_WITH_ARG(op)  PRED_##op: oparg = PEEKARG(); next_instr += 3
 669
 670 /* Stack manipulation macros */
 671
 672 /* The stack can grow at most MAXINT deep, as co_nlocals and
 673    co_stacksize are ints. */
 674 #define STACK_LEVEL()   ((int)(stack_pointer - f->f_valuestack))
 675 #define EMPTY()         (STACK_LEVEL() == 0)
 676 #define TOP()           (stack_pointer[-1])
 677 #define SECOND()        (stack_pointer[-2])
 678 #define THIRD()         (stack_pointer[-3])
 679 #define FOURTH()        (stack_pointer[-4])
 680 #define SET_TOP(v)      (stack_pointer[-1] = (v))
 681 #define SET_SECOND(v)   (stack_pointer[-2] = (v))
 682 #define SET_THIRD(v)    (stack_pointer[-3] = (v))
 683 #define SET_FOURTH(v)   (stack_pointer[-4] = (v))
 684 #define BASIC_STACKADJ(n)       (stack_pointer += n)
 685 #define BASIC_PUSH(v)   (*stack_pointer++ = (v))
 686 #define BASIC_POP()     (*--stack_pointer)
 687
 688 #ifdef LLTRACE
 689 #define PUSH(v)         { (void)(BASIC_PUSH(v), \
 690                                lltrace && prtrace(TOP(), "push")); \
 691                                assert(STACK_LEVEL() <= co->co_stacksize); }
 692 #define POP()           ((void)(lltrace && prtrace(TOP(), "pop")), \
 693                          BASIC_POP())
 694 #define STACKADJ(n)     { (void)(BASIC_STACKADJ(n), \
 695                                lltrace && prtrace(TOP(), "stackadj")); \
 696                                assert(STACK_LEVEL() <= co->co_stacksize); }
 697 #define EXT_POP(STACK_POINTER) ((void)(lltrace && \
 698                                 prtrace((STACK_POINTER)[-1], "ext_pop")), \
 699                                 *--(STACK_POINTER))
 700 #else
 701 #define PUSH(v)         BASIC_PUSH(v)
 702 #define POP()           BASIC_POP()
 703 #define STACKADJ(n)     BASIC_STACKADJ(n)
 704 #define EXT_POP(STACK_POINTER) (*--(STACK_POINTER))
 705 #endif
 706
 707 /* Local variable macros */
 708
 709 #define GETLOCAL(i)     (fastlocals[i])
 710
 711 /* The SETLOCAL() macro must not DECREF the local variable in-place and
 712    then store the new value; it must copy the old value to a temporary
 713    value, then store the new value, and then DECREF the temporary value.
 714    This is because it is possible that during the DECREF the frame is
 715    accessed by other code (e.g. a __del__ method or gc.collect()) and the
 716    variable would be pointing to already-freed memory. */
 717 #define SETLOCAL(i, value)      do { PyObject *tmp = GETLOCAL(i); \
 718                                      GETLOCAL(i) = value; \
 719                                      Py_XDECREF(tmp); } while (0)
 720
 721 /* Start of code */
 722
 723         if (f == NULL)
 724                 return NULL;
 725
 726         /* push frame */
 727         if (Py_EnterRecursiveCall(""))
 728                 return NULL;
 729
 730         tstate->frame = f;
 731
 732         if (tstate->use_tracing) {
 733                 if (tstate->c_tracefunc != NULL) {
 734                         /* tstate->c_tracefunc, if defined, is a
 735                            function that will be called on *every* entry
 736                            to a code block.  Its return value, if not
 737                            None, is a function that will be called at
 738                            the start of each executed line of code.
 739                            (Actually, the function must return itself
 740                            in order to continue tracing.)  The trace
 741                            functions are called with three arguments:
 742                            a pointer to the current frame, a string
 743                            indicating why the function is called, and
 744                            an argument which depends on the situation.
 745                            The global trace function is also called
 746                            whenever an exception is detected. */
 747                         if (call_trace_protected(tstate->c_tracefunc,
 748                                                  tstate->c_traceobj,
 749                                                  f, PyTrace_CALL, Py_None)) {
 750                                 /* Trace function raised an error */
 751                                 goto exit_eval_frame;
 752                         }
 753                 }
 754                 if (tstate->c_profilefunc != NULL) {
 755                         /* Similar for c_profilefunc, except it needn't
 756                            return itself and isn't called for "line" events */
 757                         if (call_trace_protected(tstate->c_profilefunc,
 758                                                  tstate->c_profileobj,
 759                                                  f, PyTrace_CALL, Py_None)) {
 760                                 /* Profile function raised an error */
 761                                 goto exit_eval_frame;
 762                         }
 763                 }
 764         }
 765
 766         co = f->f_code;
 767         names = co->co_names;
 768         consts = co->co_consts;
 769         fastlocals = f->f_localsplus;
 770         freevars = f->f_localsplus + co->co_nlocals;
 771         first_instr = (unsigned char*) PyString_AS_STRING(co->co_code);
 772         /* An explanation is in order for the next line.
 773
 774            f->f_lasti now refers to the index of the last instruction
 775            executed.  You might think this was obvious from the name, but
 776            this wasn't always true before 2.3!  PyFrame_New now sets
 777            f->f_lasti to -1 (i.e. the index *before* the first instruction)
 778            and YIELD_VALUE doesn't fiddle with f_lasti any more.  So this
 779            does work.  Promise.
 780
 781            When the PREDICT() macros are enabled, some opcode pairs follow in
 782            direct succession without updating f->f_lasti.  A successful
 783            prediction effectively links the two codes together as if they
 784            were a single new opcode; accordingly,f->f_lasti will point to
 785            the first code in the pair (for instance, GET_ITER followed by
 786            FOR_ITER is effectively a single opcode and f->f_lasti will point
 787            at to the beginning of the combined pair.)
 788         */
 789         next_instr = first_instr + f->f_lasti + 1;
 790         stack_pointer = f->f_stacktop;
 791         assert(stack_pointer != NULL);
 792         f->f_stacktop = NULL;   /* remains NULL unless yield suspends frame */
 793
 794 #ifdef LLTRACE
 795         lltrace = PyDict_GetItemString(f->f_globals, "__lltrace__") != NULL;
 796 #endif
 797 #if defined(Py_DEBUG) || defined(LLTRACE)
 798         filename = PyString_AsString(co->co_filename);
 799 #endif
 800
 801         why = WHY_NOT;
 802         err = 0;
 803         x = Py_None;    /* Not a reference, just anything non-NULL */
 804         w = NULL;
 805
 806         if (throwflag) { /* support for generator.throw() */
 807                 why = WHY_EXCEPTION;
 808                 goto on_error;
 809         }
 810
 811         for (;;) {
 812 #ifdef WITH_TSC
 813                 if (inst1 == 0) {
 814                         /* Almost surely, the opcode executed a break
 815                            or a continue, preventing inst1 from being set
 816                            on the way out of the loop.
 817                         */
 818                         READ_TIMESTAMP(inst1);
 819                         loop1 = inst1;
 820                 }
 821                 dump_tsc(opcode, ticked, inst0, inst1, loop0, loop1,
 822                          intr0, intr1);
 823                 ticked = 0;
 824                 inst1 = 0;
 825                 intr0 = 0;
 826                 intr1 = 0;
 827                 READ_TIMESTAMP(loop0);
 828 #endif
 829                 assert(stack_pointer >= f->f_valuestack); /* else underflow */
 830                 assert(STACK_LEVEL() <= co->co_stacksize);  /* else overflow */
 831
 832                 /* Do periodic things.  Doing this every time through
 833                    the loop would add too much overhead, so we do it
 834                    only every Nth instruction.  We also do it if
 835                    ``things_to_do'' is set, i.e. when an asynchronous
 836                    event needs attention (e.g. a signal handler or
 837                    async I/O handler); see Py_AddPendingCall() and
 838                    Py_MakePendingCalls() above. */
 839
 840                 if (--_Py_Ticker < 0) {
 841                         if (*next_instr == SETUP_FINALLY) {
 842                                 /* Make the last opcode before
 843                                    a try: finally: block uninterruptable. */
 844                                 goto fast_next_opcode;
 845                         }
 846                         _Py_Ticker = _Py_CheckInterval;
 847                         tstate->tick_counter++;
 848 #ifdef WITH_TSC
 849                         ticked = 1;
 850 #endif
 851                         if (things_to_do) {
 852                                 if (Py_MakePendingCalls() < 0) {
 853                                         why = WHY_EXCEPTION;
 854                                         goto on_error;
 855                                 }
 856                                 if (things_to_do)
 857                                         /* MakePendingCalls() didn't succeed.
 858                                            Force early re-execution of this
 859                                            "periodic" code, possibly after
 860                                            a thread switch */
 861                                         _Py_Ticker = 0;
 862                         }
 863 #ifdef WITH_THREAD
 864                         if (interpreter_lock) {
 865                                 /* Give another thread a chance */
 866
 867                                 if (PyThreadState_Swap(NULL) != tstate)
 868                                         Py_FatalError("ceval: tstate mix-up");
 869                                 PyThread_release_lock(interpreter_lock);
 870
 871                                 /* Other threads may run now */
 872
 873                                 PyThread_acquire_lock(interpreter_lock, 1);
 874                                 if (PyThreadState_Swap(tstate) != NULL)
 875                                         Py_FatalError("ceval: orphan tstate");
 876
 877                                 /* Check for thread interrupts */
 878
 879                                 if (tstate->async_exc != NULL) {
 880                                         x = tstate->async_exc;
 881                                         tstate->async_exc = NULL;
 882                                         PyErr_SetNone(x);
 883                                         Py_DECREF(x);
 884                                         why = WHY_EXCEPTION;
 885                                         goto on_error;
 886                                 }
 887                         }
 888 #endif
 889                 }
 890
 891         fast_next_opcode:
 892                 f->f_lasti = INSTR_OFFSET();
 893
 894                 /* line-by-line tracing support */
 895
 896                 if (_Py_TracingPossible &&
 897                     tstate->c_tracefunc != NULL && !tstate->tracing) {
 898                         /* see maybe_call_line_trace
 899                            for expository comments */
 900                         f->f_stacktop = stack_pointer;
 901
 902                         err = maybe_call_line_trace(tstate->c_tracefunc,
 903                                                     tstate->c_traceobj,
 904                                                     f, &instr_lb, &instr_ub,
 905                                                     &instr_prev);
 906                         /* Reload possibly changed frame fields */
 907                         JUMPTO(f->f_lasti);
 908                         if (f->f_stacktop != NULL) {
 909                                 stack_pointer = f->f_stacktop;
 910                                 f->f_stacktop = NULL;
 911                         }
 912                         if (err) {
 913                                 /* trace function raised an exception */
 914                                 goto on_error;
 915                         }
 916                 }
 917
 918                 /* Extract opcode and argument */
 919
 920                 opcode = NEXTOP();
 921                 oparg = 0;   /* allows oparg to be stored in a register because
 922                         it doesn't have to be remembered across a full loop */
 923                 if (HAS_ARG(opcode))
 924                         oparg = NEXTARG();
 925           dispatch_opcode:
 926 #ifdef DYNAMIC_EXECUTION_PROFILE
 927 #ifdef DXPAIRS
 928                 dxpairs[lastopcode][opcode]++;
 929                 lastopcode = opcode;
 930 #endif
 931                 dxp[opcode]++;
 932 #endif
 933
 934 #ifdef LLTRACE
 935                 /* Instruction tracing */
 936
 937                 if (lltrace) {
 938                         if (HAS_ARG(opcode)) {
 939                                 printf("%d: %d, %d\n",
 940                                        f->f_lasti, opcode, oparg);
 941                         }
 942                         else {
 943                                 printf("%d: %d\n",
 944                                        f->f_lasti, opcode);
 945                         }
 946                 }
 947 #endif
 948
 949                 /* Main switch on opcode */
 950                 READ_TIMESTAMP(inst0);
 951
 952                 switch (opcode) {
 953
 954                 /* BEWARE!
 955                    It is essential that any operation that fails sets either
 956                    x to NULL, err to nonzero, or why to anything but WHY_NOT,
 957                    and that no operation that succeeds does this! */
 958
 959                 /* case STOP_CODE: this is an error! */
 960
 961                 case NOP:
 962                         goto fast_next_opcode;
 963
 964                 case LOAD_FAST:
 965                         x = GETLOCAL(oparg);
 966                         if (x != NULL) {
 967                                 Py_INCREF(x);
 968                                 PUSH(x);
 969                                 goto fast_next_opcode;
 970                         }
 971                         format_exc_check_arg(PyExc_UnboundLocalError,
 972                                 UNBOUNDLOCAL_ERROR_MSG,
 973                                 PyTuple_GetItem(co->co_varnames, oparg));
 974                         break;
 975
 976                 case LOAD_CONST:
 977                         x = GETITEM(consts, oparg);
 978                         Py_INCREF(x);
 979                         PUSH(x);
 980                         goto fast_next_opcode;
 981
 982                 PREDICTED_WITH_ARG(STORE_FAST);
 983                 case STORE_FAST:
 984                         v = POP();
 985                         SETLOCAL(oparg, v);
 986                         goto fast_next_opcode;
 987
 988                 PREDICTED(POP_TOP);
 989                 case POP_TOP:
 990                         v = POP();
 991                         Py_DECREF(v);
 992                         goto fast_next_opcode;
 993
 994                 case ROT_TWO:
 995                         v = TOP();
 996                         w = SECOND();
 997                         SET_TOP(w);
 998                         SET_SECOND(v);
 999                         goto fast_next_opcode;
1000
1001                 case ROT_THREE:
1002                         v = TOP();
1003                         w = SECOND();
1004                         x = THIRD();
1005                         SET_TOP(w);
1006                         SET_SECOND(x);
1007                         SET_THIRD(v);
1008                         goto fast_next_opcode;
1009
1010                 case ROT_FOUR:
1011                         u = TOP();
1012                         v = SECOND();
1013                         w = THIRD();
1014                         x = FOURTH();
1015                         SET_TOP(v);
1016                         SET_SECOND(w);
1017                         SET_THIRD(x);
1018                         SET_FOURTH(u);
1019                         goto fast_next_opcode;
1020
1021                 case DUP_TOP:
1022                         v = TOP();
1023                         Py_INCREF(v);
1024                         PUSH(v);
1025                         goto fast_next_opcode;
1026
1027                 case DUP_TOPX:
1028                         if (oparg == 2) {
1029                                 x = TOP();
1030                                 Py_INCREF(x);
1031                                 w = SECOND();
1032                                 Py_INCREF(w);
1033                                 STACKADJ(2);
1034                                 SET_TOP(x);
1035                                 SET_SECOND(w);
1036                                 goto fast_next_opcode;
1037                         } else if (oparg == 3) {
1038                                 x = TOP();
1039                                 Py_INCREF(x);
1040                                 w = SECOND();
1041                                 Py_INCREF(w);
1042                                 v = THIRD();
1043                                 Py_INCREF(v);
1044                                 STACKADJ(3);
1045                                 SET_TOP(x);
1046                                 SET_SECOND(w);
1047                                 SET_THIRD(v);
1048                                 goto fast_next_opcode;
1049                         }
1050                         Py_FatalError("invalid argument to DUP_TOPX"
1051                                       " (bytecode corruption?)");
1052                         /* Never returns, so don't bother to set why. */
1053                         break;
1054
1055                 case UNARY_POSITIVE:
1056                         v = TOP();
1057                         x = PyNumber_Positive(v);
1058                         Py_DECREF(v);
1059                         SET_TOP(x);
1060                         if (x != NULL) continue;
1061                         break;
1062
1063                 case UNARY_NEGATIVE:
1064                         v = TOP();
1065                         x = PyNumber_Negative(v);
1066                         Py_DECREF(v);
1067                         SET_TOP(x);
1068                         if (x != NULL) continue;
1069                         break;
1070
1071                 case UNARY_NOT:
1072                         v = TOP();
1073                         err = PyObject_IsTrue(v);
1074                         Py_DECREF(v);
1075                         if (err == 0) {
1076                                 Py_INCREF(Py_True);
1077                                 SET_TOP(Py_True);
1078                                 continue;
1079                         }
1080                         else if (err > 0) {
1081                                 Py_INCREF(Py_False);
1082                                 SET_TOP(Py_False);
1083                                 err = 0;
1084                                 continue;
1085                         }
1086                         STACKADJ(-1);
1087                         break;
1088
1089                 case UNARY_CONVERT:
1090                         v = TOP();
1091                         x = PyObject_Repr(v);
1092                         Py_DECREF(v);
1093                         SET_TOP(x);
1094                         if (x != NULL) continue;
1095                         break;
1096
1097                 case UNARY_INVERT:
1098                         v = TOP();
1099                         x = PyNumber_Invert(v);
1100                         Py_DECREF(v);
1101                         SET_TOP(x);
1102                         if (x != NULL) continue;
1103                         break;
1104
1105                 case BINARY_POWER:
1106                         w = POP();
1107                         v = TOP();
1108                         x = PyNumber_Power(v, w, Py_None);
1109                         Py_DECREF(v);
1110                         Py_DECREF(w);
1111                         SET_TOP(x);
1112                         if (x != NULL) continue;
1113                         break;
1114
1115                 case BINARY_MULTIPLY:
1116                         w = POP();
1117                         v = TOP();
1118                         x = PyNumber_Multiply(v, w);
1119                         Py_DECREF(v);
1120                         Py_DECREF(w);
1121                         SET_TOP(x);
1122                         if (x != NULL) continue;
1123                         break;
1124
1125                 case BINARY_DIVIDE:
1126                         if (!_Py_QnewFlag) {
1127                                 w = POP();
1128                                 v = TOP();
1129                                 x = PyNumber_Divide(v, w);
1130                                 Py_DECREF(v);
1131                                 Py_DECREF(w);
1132                                 SET_TOP(x);
1133                                 if (x != NULL) continue;
1134                                 break;
1135                         }
1136                         /* -Qnew is in effect:  fall through to
1137                            BINARY_TRUE_DIVIDE */
1138                 case BINARY_TRUE_DIVIDE:
1139                         w = POP();
1140                         v = TOP();
1141                         x = PyNumber_TrueDivide(v, w);
1142                         Py_DECREF(v);
1143                         Py_DECREF(w);
1144                         SET_TOP(x);
1145                         if (x != NULL) continue;
1146                         break;
1147
1148                 case BINARY_FLOOR_DIVIDE:
1149                         w = POP();
1150                         v = TOP();
1151                         x = PyNumber_FloorDivide(v, w);
1152                         Py_DECREF(v);
1153                         Py_DECREF(w);
1154                         SET_TOP(x);
1155                         if (x != NULL) continue;
1156                         break;
1157
1158                 case BINARY_MODULO:
1159                         w = POP();
1160                         v = TOP();
1161                         x = PyNumber_Remainder(v, w);
1162                         Py_DECREF(v);
1163                         Py_DECREF(w);
1164                         SET_TOP(x);
1165                         if (x != NULL) continue;
1166                         break;
1167
1168                 case BINARY_ADD:
1169                         w = POP();
1170                         v = TOP();
1171                         if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
1172                                 /* INLINE: int + int */
1173                                 register long a, b, i;
1174                                 a = PyInt_AS_LONG(v);
1175                                 b = PyInt_AS_LONG(w);
1176                                 i = a + b;
1177                                 if ((i^a) < 0 && (i^b) < 0)
1178                                         goto slow_add;
1179                                 x = PyInt_FromLong(i);
1180                         }
1181                         else if (PyString_CheckExact(v) &&
1182                                  PyString_CheckExact(w)) {
1183                                 x = string_concatenate(v, w, f, next_instr);
1184                                 /* string_concatenate consumed the ref to v */
1185                                 goto skip_decref_vx;
1186                         }
1187                         else {
1188                           slow_add:
1189                                 x = PyNumber_Add(v, w);
1190                         }
1191                         Py_DECREF(v);
1192                   skip_decref_vx:
1193                         Py_DECREF(w);
1194                         SET_TOP(x);
1195                         if (x != NULL) continue;
1196                         break;
1197
1198                 case BINARY_SUBTRACT:
1199                         w = POP();
1200                         v = TOP();
1201                         if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
1202                                 /* INLINE: int - int */
1203                                 register long a, b, i;
1204                                 a = PyInt_AS_LONG(v);
1205                                 b = PyInt_AS_LONG(w);
1206                                 i = a - b;
1207                                 if ((i^a) < 0 && (i^~b) < 0)
1208                                         goto slow_sub;
1209                                 x = PyInt_FromLong(i);
1210                         }
1211                         else {
1212                           slow_sub:
1213                                 x = PyNumber_Subtract(v, w);
1214                         }
1215                         Py_DECREF(v);
1216                         Py_DECREF(w);
1217                         SET_TOP(x);
1218                         if (x != NULL) continue;
1219                         break;
1220
1221                 case BINARY_SUBSCR:
1222                         w = POP();
1223                         v = TOP();
1224                         if (PyList_CheckExact(v) && PyInt_CheckExact(w)) {
1225                                 /* INLINE: list[int] */
1226                                 Py_ssize_t i = PyInt_AsSsize_t(w);
1227                                 if (i < 0)
1228                                         i += PyList_GET_SIZE(v);
1229                                 if (i >= 0 && i < PyList_GET_SIZE(v)) {
1230                                         x = PyList_GET_ITEM(v, i);
1231                                         Py_INCREF(x);
1232                                 }
1233                                 else
1234                                         goto slow_get;
1235                         }
1236                         else
1237                           slow_get:
1238                                 x = PyObject_GetItem(v, w);
1239                         Py_DECREF(v);
1240                         Py_DECREF(w);
1241                         SET_TOP(x);
1242                         if (x != NULL) continue;
1243                         break;
1244
1245                 case BINARY_LSHIFT:
1246                         w = POP();
1247                         v = TOP();
1248                         x = PyNumber_Lshift(v, w);
1249                         Py_DECREF(v);
1250                         Py_DECREF(w);
1251                         SET_TOP(x);
1252                         if (x != NULL) continue;
1253                         break;
1254
1255                 case BINARY_RSHIFT:
1256                         w = POP();
1257                         v = TOP();
1258                         x = PyNumber_Rshift(v, w);
1259                         Py_DECREF(v);
1260                         Py_DECREF(w);
1261                         SET_TOP(x);
1262                         if (x != NULL) continue;
1263                         break;
1264
1265                 case BINARY_AND:
1266                         w = POP();
1267                         v = TOP();
1268                         x = PyNumber_And(v, w);
1269                         Py_DECREF(v);
1270                         Py_DECREF(w);
1271                         SET_TOP(x);
1272                         if (x != NULL) continue;
1273                         break;
1274
1275                 case BINARY_XOR:
1276                         w = POP();
1277                         v = TOP();
1278                         x = PyNumber_Xor(v, w);
1279                         Py_DECREF(v);
1280                         Py_DECREF(w);
1281                         SET_TOP(x);
1282                         if (x != NULL) continue;
1283                         break;
1284
1285                 case BINARY_OR:
1286                         w = POP();
1287                         v = TOP();
1288                         x = PyNumber_Or(v, w);
1289                         Py_DECREF(v);
1290                         Py_DECREF(w);
1291                         SET_TOP(x);
1292                         if (x != NULL) continue;
1293                         break;
1294
1295                 case LIST_APPEND:
1296                         w = POP();
1297                         v = stack_pointer[-oparg];
1298                         err = PyList_Append(v, w);
1299                         Py_DECREF(w);
1300                         if (err == 0) {
1301                                 PREDICT(JUMP_ABSOLUTE);
1302                                 continue;
1303                         }
1304                         break;
1305
1306                 case INPLACE_POWER:
1307                         w = POP();
1308                         v = TOP();
1309                         x = PyNumber_InPlacePower(v, w, Py_None);
1310                         Py_DECREF(v);
1311                         Py_DECREF(w);
1312                         SET_TOP(x);
1313                         if (x != NULL) continue;
1314                         break;
1315
1316                 case INPLACE_MULTIPLY:
1317                         w = POP();
1318                         v = TOP();
1319                         x = PyNumber_InPlaceMultiply(v, w);
1320                         Py_DECREF(v);
1321                         Py_DECREF(w);
1322                         SET_TOP(x);
1323                         if (x != NULL) continue;
1324                         break;
1325
1326                 case INPLACE_DIVIDE:
1327                         if (!_Py_QnewFlag) {
1328                                 w = POP();
1329                                 v = TOP();
1330                                 x = PyNumber_InPlaceDivide(v, w);
1331                                 Py_DECREF(v);
1332                                 Py_DECREF(w);
1333                                 SET_TOP(x);
1334                                 if (x != NULL) continue;
1335                                 break;
1336                         }
1337                         /* -Qnew is in effect:  fall through to
1338                            INPLACE_TRUE_DIVIDE */
1339                 case INPLACE_TRUE_DIVIDE:
1340                         w = POP();
1341                         v = TOP();
1342                         x = PyNumber_InPlaceTrueDivide(v, w);
1343                         Py_DECREF(v);
1344                         Py_DECREF(w);
1345                         SET_TOP(x);
1346                         if (x != NULL) continue;
1347                         break;
1348
1349                 case INPLACE_FLOOR_DIVIDE:
1350                         w = POP();
1351                         v = TOP();
1352                         x = PyNumber_InPlaceFloorDivide(v, w);
1353                         Py_DECREF(v);
1354                         Py_DECREF(w);
1355                         SET_TOP(x);
1356                         if (x != NULL) continue;
1357                         break;
1358
1359                 case INPLACE_MODULO:
1360                         w = POP();
1361                         v = TOP();
1362                         x = PyNumber_InPlaceRemainder(v, w);
1363                         Py_DECREF(v);
1364                         Py_DECREF(w);
1365                         SET_TOP(x);
1366                         if (x != NULL) continue;
1367                         break;
1368
1369                 case INPLACE_ADD:
1370                         w = POP();
1371                         v = TOP();
1372                         if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
1373                                 /* INLINE: int + int */
1374                                 register long a, b, i;
1375                                 a = PyInt_AS_LONG(v);
1376                                 b = PyInt_AS_LONG(w);
1377                                 i = a + b;
1378                                 if ((i^a) < 0 && (i^b) < 0)
1379                                         goto slow_iadd;
1380                                 x = PyInt_FromLong(i);
1381                         }
1382                         else if (PyString_CheckExact(v) &&
1383                                  PyString_CheckExact(w)) {
1384                                 x = string_concatenate(v, w, f, next_instr);
1385                                 /* string_concatenate consumed the ref to v */
1386                                 goto skip_decref_v;
1387                         }
1388                         else {
1389                           slow_iadd:
1390                                 x = PyNumber_InPlaceAdd(v, w);
1391                         }
1392                         Py_DECREF(v);
1393                   skip_decref_v:
1394                         Py_DECREF(w);
1395                         SET_TOP(x);
1396                         if (x != NULL) continue;
1397                         break;
1398
1399                 case INPLACE_SUBTRACT:
1400                         w = POP();
1401                         v = TOP();
1402                         if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
1403                                 /* INLINE: int - int */
1404                                 register long a, b, i;
1405                                 a = PyInt_AS_LONG(v);
1406                                 b = PyInt_AS_LONG(w);
1407                                 i = a - b;
1408                                 if ((i^a) < 0 && (i^~b) < 0)
1409                                         goto slow_isub;
1410                                 x = PyInt_FromLong(i);
1411                         }
1412                         else {
1413                           slow_isub:
1414                                 x = PyNumber_InPlaceSubtract(v, w);
1415                         }
1416                         Py_DECREF(v);
1417                         Py_DECREF(w);
1418                         SET_TOP(x);
1419                         if (x != NULL) continue;
1420                         break;
1421
1422                 case INPLACE_LSHIFT:
1423                         w = POP();
1424                         v = TOP();
1425                         x = PyNumber_InPlaceLshift(v, w);
1426                         Py_DECREF(v);
1427                         Py_DECREF(w);
1428                         SET_TOP(x);
1429                         if (x != NULL) continue;
1430                         break;
1431
1432                 case INPLACE_RSHIFT:
1433                         w = POP();
1434                         v = TOP();
1435                         x = PyNumber_InPlaceRshift(v, w);
1436                         Py_DECREF(v);
1437                         Py_DECREF(w);
1438                         SET_TOP(x);
1439                         if (x != NULL) continue;
1440                         break;
1441
1442                 case INPLACE_AND:
1443                         w = POP();
1444                         v = TOP();
1445                         x = PyNumber_InPlaceAnd(v, w);
1446                         Py_DECREF(v);
1447                         Py_DECREF(w);
1448                         SET_TOP(x);
1449                         if (x != NULL) continue;
1450                         break;
1451
1452                 case INPLACE_XOR:
1453                         w = POP();
1454                         v = TOP();
1455                         x = PyNumber_InPlaceXor(v, w);
1456                         Py_DECREF(v);
1457                         Py_DECREF(w);
1458                         SET_TOP(x);
1459                         if (x != NULL) continue;
1460                         break;
1461
1462                 case INPLACE_OR:
1463                         w = POP();
1464                         v = TOP();
1465                         x = PyNumber_InPlaceOr(v, w);
1466                         Py_DECREF(v);
1467                         Py_DECREF(w);
1468                         SET_TOP(x);
1469                         if (x != NULL) continue;
1470                         break;
1471
1472                 case SLICE+0:
1473                 case SLICE+1:
1474                 case SLICE+2:
1475                 case SLICE+3:
1476                         if ((opcode-SLICE) & 2)
1477                                 w = POP();
1478                         else
1479                                 w = NULL;
1480                         if ((opcode-SLICE) & 1)
1481                                 v = POP();
1482                         else
1483                                 v = NULL;
1484                         u = TOP();
1485                         x = apply_slice(u, v, w);
1486                         Py_DECREF(u);
1487                         Py_XDECREF(v);
1488                         Py_XDECREF(w);
1489                         SET_TOP(x);
1490                         if (x != NULL) continue;
1491                         break;
1492
1493                 case STORE_SLICE+0:
1494                 case STORE_SLICE+1:
1495                 case STORE_SLICE+2:
1496                 case STORE_SLICE+3:
1497                         if ((opcode-STORE_SLICE) & 2)
1498                                 w = POP();
1499                         else
1500                                 w = NULL;
1501                         if ((opcode-STORE_SLICE) & 1)
1502                                 v = POP();
1503                         else
1504                                 v = NULL;
1505                         u = POP();
1506                         t = POP();
1507                         err = assign_slice(u, v, w, t); /* u[v:w] = t */
1508                         Py_DECREF(t);
1509                         Py_DECREF(u);
1510                         Py_XDECREF(v);
1511                         Py_XDECREF(w);
1512                         if (err == 0) continue;
1513                         break;
1514
1515                 case DELETE_SLICE+0:
1516                 case DELETE_SLICE+1:
1517                 case DELETE_SLICE+2:
1518                 case DELETE_SLICE+3:
1519                         if ((opcode-DELETE_SLICE) & 2)
1520                                 w = POP();
1521                         else
1522                                 w = NULL;
1523                         if ((opcode-DELETE_SLICE) & 1)
1524                                 v = POP();
1525                         else
1526                                 v = NULL;
1527                         u = POP();
1528                         err = assign_slice(u, v, w, (PyObject *)NULL);
1529                                                         /* del u[v:w] */
1530                         Py_DECREF(u);
1531                         Py_XDECREF(v);
1532                         Py_XDECREF(w);
1533                         if (err == 0) continue;
1534                         break;
1535
1536                 case STORE_SUBSCR:
1537                         w = TOP();
1538                         v = SECOND();
1539                         u = THIRD();
1540                         STACKADJ(-3);
1541                         /* v[w] = u */
1542                         err = PyObject_SetItem(v, w, u);
1543                         Py_DECREF(u);
1544                         Py_DECREF(v);
1545                         Py_DECREF(w);
1546                         if (err == 0) continue;
1547                         break;
1548
1549                 case DELETE_SUBSCR:
1550                         w = TOP();
1551                         v = SECOND();
1552                         STACKADJ(-2);
1553                         /* del v[w] */
1554                         err = PyObject_DelItem(v, w);
1555                         Py_DECREF(v);
1556                         Py_DECREF(w);
1557                         if (err == 0) continue;
1558                         break;
1559
1560                 case PRINT_EXPR:
1561                         v = POP();
1562                         w = PySys_GetObject("displayhook");
1563                         if (w == NULL) {
1564                                 PyErr_SetString(PyExc_RuntimeError,
1565                                                 "lost sys.displayhook");
1566                                 err = -1;
1567                                 x = NULL;
1568                         }
1569                         if (err == 0) {
1570                                 x = PyTuple_Pack(1, v);
1571                                 if (x == NULL)
1572                                         err = -1;
1573                         }
1574                         if (err == 0) {
1575                                 w = PyEval_CallObject(w, x);
1576                                 Py_XDECREF(w);
1577                                 if (w == NULL)
1578                                         err = -1;
1579                         }
1580                         Py_DECREF(v);
1581                         Py_XDECREF(x);
1582                         break;
1583
1584                 case PRINT_ITEM_TO:
1585                         w = stream = POP();
1586                         /* fall through to PRINT_ITEM */
1587
1588                 case PRINT_ITEM:
1589                         v = POP();
1590                         if (stream == NULL || stream == Py_None) {
1591                                 w = PySys_GetObject("stdout");
1592                                 if (w == NULL) {
1593                                         PyErr_SetString(PyExc_RuntimeError,
1594                                                         "lost sys.stdout");
1595                                         err = -1;
1596                                 }
1597                         }
1598                         /* PyFile_SoftSpace() can exececute arbitrary code
1599                            if sys.stdout is an instance with a __getattr__.
1600                            If __getattr__ raises an exception, w will
1601                            be freed, so we need to prevent that temporarily. */
1602                         Py_XINCREF(w);
1603                         if (w != NULL && PyFile_SoftSpace(w, 0))
1604                                 err = PyFile_WriteString(" ", w);
1605                         if (err == 0)
1606                                 err = PyFile_WriteObject(v, w, Py_PRINT_RAW);
1607                         if (err == 0) {
1608                             /* XXX move into writeobject() ? */
1609                             if (PyString_Check(v)) {
1610                                 char *s = PyString_AS_STRING(v);
1611                                 Py_ssize_t len = PyString_GET_SIZE(v);
1612                                 if (len == 0 ||
1613                                     !isspace(Py_CHARMASK(s[len-1])) ||
1614                                     s[len-1] == ' ')
1615                                         PyFile_SoftSpace(w, 1);
1616                             }
1617 #ifdef Py_USING_UNICODE
1618                             else if (PyUnicode_Check(v)) {
1619                                 Py_UNICODE *s = PyUnicode_AS_UNICODE(v);
1620                                 Py_ssize_t len = PyUnicode_GET_SIZE(v);
1621                                 if (len == 0 ||
1622                                     !Py_UNICODE_ISSPACE(s[len-1]) ||
1623                                     s[len-1] == ' ')
1624                                     PyFile_SoftSpace(w, 1);
1625                             }
1626 #endif
1627                             else
1628                                 PyFile_SoftSpace(w, 1);
1629                         }
1630                         Py_XDECREF(w);
1631                         Py_DECREF(v);
1632                         Py_XDECREF(stream);
1633                         stream = NULL;
1634                         if (err == 0)
1635                                 continue;
1636                         break;
1637
1638                 case PRINT_NEWLINE_TO:
1639                         w = stream = POP();
1640                         /* fall through to PRINT_NEWLINE */
1641
1642                 case PRINT_NEWLINE:
1643                         if (stream == NULL || stream == Py_None) {
1644                                 w = PySys_GetObject("stdout");
1645                                 if (w == NULL) {
1646                                         PyErr_SetString(PyExc_RuntimeError,
1647                                                         "lost sys.stdout");
1648                                         why = WHY_EXCEPTION;
1649                                 }
1650                         }
1651                         if (w != NULL) {
1652                                 /* w.write() may replace sys.stdout, so we
1653                                  * have to keep our reference to it */
1654                                 Py_INCREF(w);
1655                                 err = PyFile_WriteString("\n", w);
1656                                 if (err == 0)
1657                                         PyFile_SoftSpace(w, 0);
1658                                 Py_DECREF(w);
1659                         }
1660                         Py_XDECREF(stream);
1661                         stream = NULL;
1662                         break;
1663
1664
1665 #ifdef CASE_TOO_BIG
1666                 default: switch (opcode) {
1667 #endif
1668                 case RAISE_VARARGS:
1669                         u = v = w = NULL;
1670                         switch (oparg) {
1671                         case 3:
1672                                 u = POP(); /* traceback */
1673                                 /* Fallthrough */
1674                         case 2:
1675                                 v = POP(); /* value */
1676                                 /* Fallthrough */
1677                         case 1:
1678                                 w = POP(); /* exc */
1679                         case 0: /* Fallthrough */
1680                                 why = do_raise(w, v, u);
1681                                 break;
1682                         default:
1683                                 PyErr_SetString(PyExc_SystemError,
1684                                            "bad RAISE_VARARGS oparg");
1685                                 why = WHY_EXCEPTION;
1686                                 break;
1687                         }
1688                         break;
1689
1690                 case LOAD_LOCALS:
1691                         if ((x = f->f_locals) != NULL) {
1692                                 Py_INCREF(x);
1693                                 PUSH(x);
1694                                 continue;
1695                         }
1696                         PyErr_SetString(PyExc_SystemError, "no locals");
1697                         break;
1698
1699                 case RETURN_VALUE:
1700                         retval = POP();
1701                         why = WHY_RETURN;
1702                         goto fast_block_end;
1703
1704                 case YIELD_VALUE:
1705                         retval = POP();
1706                         f->f_stacktop = stack_pointer;
1707                         why = WHY_YIELD;
1708                         goto fast_yield;
1709
1710                 case EXEC_STMT:
1711                         w = TOP();
1712                         v = SECOND();
1713                         u = THIRD();
1714                         STACKADJ(-3);
1715                         READ_TIMESTAMP(intr0);
1716                         err = exec_statement(f, u, v, w);
1717                         READ_TIMESTAMP(intr1);
1718                         Py_DECREF(u);
1719                         Py_DECREF(v);
1720                         Py_DECREF(w);
1721                         break;
1722
1723                 case POP_BLOCK:
1724                         {
1725                                 PyTryBlock *b = PyFrame_BlockPop(f);
1726                                 while (STACK_LEVEL() > b->b_level) {
1727                                         v = POP();
1728                                         Py_DECREF(v);
1729                                 }
1730                         }
1731                         continue;
1732
1733                 PREDICTED(END_FINALLY);
1734                 case END_FINALLY:
1735                         v = POP();
1736                         if (PyInt_Check(v)) {
1737                                 why = (enum why_code) PyInt_AS_LONG(v);
1738                                 assert(why != WHY_YIELD);
1739                                 if (why == WHY_RETURN ||
1740                                     why == WHY_CONTINUE)
1741                                         retval = POP();
1742                         }
1743                         else if (PyExceptionClass_Check(v) ||
1744                                  PyString_Check(v)) {
1745                                 w = POP();
1746                                 u = POP();
1747                                 PyErr_Restore(v, w, u);
1748                                 why = WHY_RERAISE;
1749                                 break;
1750                         }
1751                         else if (v != Py_None) {
1752                                 PyErr_SetString(PyExc_SystemError,
1753                                         "'finally' pops bad exception");
1754                                 why = WHY_EXCEPTION;
1755                         }
1756                         Py_DECREF(v);
1757                         break;
1758
1759                 case BUILD_CLASS:
1760                         u = TOP();
1761                         v = SECOND();
1762                         w = THIRD();
1763                         STACKADJ(-2);
1764                         x = build_class(u, v, w);
1765                         SET_TOP(x);
1766                         Py_DECREF(u);
1767                         Py_DECREF(v);
1768                         Py_DECREF(w);
1769                         break;
1770
1771                 case STORE_NAME:
1772                         w = GETITEM(names, oparg);
1773                         v = POP();
1774                         if ((x = f->f_locals) != NULL) {
1775                                 if (PyDict_CheckExact(x))
1776                                         err = PyDict_SetItem(x, w, v);
1777                                 else
1778                                         err = PyObject_SetItem(x, w, v);
1779                                 Py_DECREF(v);
1780                                 if (err == 0) continue;
1781                                 break;
1782                         }
1783                         PyErr_Format(PyExc_SystemError,
1784                                      "no locals found when storing %s",
1785                                      PyObject_REPR(w));
1786                         break;
1787
1788                 case DELETE_NAME:
1789                         w = GETITEM(names, oparg);
1790                         if ((x = f->f_locals) != NULL) {
1791                                 if ((err = PyObject_DelItem(x, w)) != 0)
1792                                         format_exc_check_arg(PyExc_NameError,
1793                                                              NAME_ERROR_MSG,
1794                                                              w);
1795                                 break;
1796                         }
1797                         PyErr_Format(PyExc_SystemError,
1798                                      "no locals when deleting %s",
1799                                      PyObject_REPR(w));
1800                         break;
1801
1802                 PREDICTED_WITH_ARG(UNPACK_SEQUENCE);
1803                 case UNPACK_SEQUENCE:
1804                         v = POP();
1805                         if (PyTuple_CheckExact(v) &&
1806                             PyTuple_GET_SIZE(v) == oparg) {
1807                                 PyObject **items = \
1808                                         ((PyTupleObject *)v)->ob_item;
1809                                 while (oparg--) {
1810                                         w = items[oparg];
1811                                         Py_INCREF(w);
1812                                         PUSH(w);
1813                                 }
1814                                 Py_DECREF(v);
1815                                 continue;
1816                         } else if (PyList_CheckExact(v) &&
1817                                    PyList_GET_SIZE(v) == oparg) {
1818                                 PyObject **items = \
1819                                         ((PyListObject *)v)->ob_item;
1820                                 while (oparg--) {
1821                                         w = items[oparg];
1822                                         Py_INCREF(w);
1823                                         PUSH(w);
1824                                 }
1825                         } else if (unpack_iterable(v, oparg,
1826                                                    stack_pointer + oparg)) {
1827                                 stack_pointer += oparg;
1828                         } else {
1829                                 /* unpack_iterable() raised an exception */
1830                                 why = WHY_EXCEPTION;
1831                         }
1832                         Py_DECREF(v);
1833                         break;
1834
1835                 case STORE_ATTR:
1836                         w = GETITEM(names, oparg);
1837                         v = TOP();
1838                         u = SECOND();
1839                         STACKADJ(-2);
1840                         err = PyObject_SetAttr(v, w, u); /* v.w = u */
1841                         Py_DECREF(v);
1842                         Py_DECREF(u);
1843                         if (err == 0) continue;
1844                         break;
1845
1846                 case DELETE_ATTR:
1847                         w = GETITEM(names, oparg);
1848                         v = POP();
1849                         err = PyObject_SetAttr(v, w, (PyObject *)NULL);
1850                                                         /* del v.w */
1851                         Py_DECREF(v);
1852                         break;
1853
1854                 case STORE_GLOBAL:
1855                         w = GETITEM(names, oparg);
1856                         v = POP();
1857                         err = PyDict_SetItem(f->f_globals, w, v);
1858                         Py_DECREF(v);
1859                         if (err == 0) continue;
1860                         break;
1861
1862                 case DELETE_GLOBAL:
1863                         w = GETITEM(names, oparg);
1864                         if ((err = PyDict_DelItem(f->f_globals, w)) != 0)
1865                                 format_exc_check_arg(
1866                                     PyExc_NameError, GLOBAL_NAME_ERROR_MSG, w);
1867                         break;
1868
1869                 case LOAD_NAME:
1870                         w = GETITEM(names, oparg);
1871                         if ((v = f->f_locals) == NULL) {
1872                                 PyErr_Format(PyExc_SystemError,
1873                                              "no locals when loading %s",
1874                                              PyObject_REPR(w));
1875                                 why = WHY_EXCEPTION;
1876                                 break;
1877                         }
1878                         if (PyDict_CheckExact(v)) {
1879                                 x = PyDict_GetItem(v, w);
1880                                 Py_XINCREF(x);
1881                         }
1882                         else {
1883                                 x = PyObject_GetItem(v, w);
1884                                 if (x == NULL && PyErr_Occurred()) {
1885                                         if (!PyErr_ExceptionMatches(
1886                                                         PyExc_KeyError))
1887                                                 break;
1888                                         PyErr_Clear();
1889                                 }
1890                         }
1891                         if (x == NULL) {
1892                                 x = PyDict_GetItem(f->f_globals, w);
1893                                 if (x == NULL) {
1894                                         x = PyDict_GetItem(f->f_builtins, w);
1895                                         if (x == NULL) {
1896                                                 format_exc_check_arg(
1897                                                             PyExc_NameError,
1898                                                             NAME_ERROR_MSG, w);
1899                                                 break;
1900                                         }
1901                                 }
1902                                 Py_INCREF(x);
1903                         }
1904                         PUSH(x);
1905                         continue;
1906
1907                 case LOAD_GLOBAL:
1908                         w = GETITEM(names, oparg);
1909                         if (PyString_CheckExact(w)) {
1910                                 /* Inline the PyDict_GetItem() calls.
1911                                    WARNING: this is an extreme speed hack.
1912                                    Do not try this at home. */
1913                                 long hash = ((PyStringObject *)w)->ob_shash;
1914                                 if (hash != -1) {
1915                                         PyDictObject *d;
1916                                         PyDictEntry *e;
1917                                         d = (PyDictObject *)(f->f_globals);
1918                                         e = d->ma_lookup(d, w, hash);
1919                                         if (e == NULL) {
1920                                                 x = NULL;
1921                                                 break;
1922                                         }
1923                                         x = e->me_value;
1924                                         if (x != NULL) {
1925                                                 Py_INCREF(x);
1926                                                 PUSH(x);
1927                                                 continue;
1928                                         }
1929                                         d = (PyDictObject *)(f->f_builtins);
1930                                         e = d->ma_lookup(d, w, hash);
1931                                         if (e == NULL) {
1932                                                 x = NULL;
1933                                                 break;
1934                                         }
1935                                         x = e->me_value;
1936                                         if (x != NULL) {
1937                                                 Py_INCREF(x);
1938                                                 PUSH(x);
1939                                                 continue;
1940                                         }
1941                                         goto load_global_error;
1942                                 }
1943                         }
1944                         /* This is the un-inlined version of the code above */
1945                         x = PyDict_GetItem(f->f_globals, w);
1946                         if (x == NULL) {
1947                                 x = PyDict_GetItem(f->f_builtins, w);
1948                                 if (x == NULL) {
1949                                   load_global_error:
1950                                         format_exc_check_arg(
1951                                                     PyExc_NameError,
1952                                                     GLOBAL_NAME_ERROR_MSG, w);
1953                                         break;
1954                                 }
1955                         }
1956                         Py_INCREF(x);
1957                         PUSH(x);
1958                         continue;
1959
1960                 case DELETE_FAST:
1961                         x = GETLOCAL(oparg);
1962                         if (x != NULL) {
1963                                 SETLOCAL(oparg, NULL);
1964                                 continue;
1965                         }
1966                         format_exc_check_arg(
1967                                 PyExc_UnboundLocalError,
1968                                 UNBOUNDLOCAL_ERROR_MSG,
1969                                 PyTuple_GetItem(co->co_varnames, oparg)
1970                                 );
1971                         break;
1972
1973                 case LOAD_CLOSURE:
1974                         x = freevars[oparg];
1975                         Py_INCREF(x);
1976                         PUSH(x);
1977                         if (x != NULL) continue;
1978                         break;
1979
1980                 case LOAD_DEREF:
1981                         x = freevars[oparg];
1982                         w = PyCell_Get(x);
1983                         if (w != NULL) {
1984                                 PUSH(w);
1985                                 continue;
1986                         }
1987                         err = -1;
1988                         /* Don't stomp existing exception */
1989                         if (PyErr_Occurred())
1990                                 break;
1991                         if (oparg < PyTuple_GET_SIZE(co->co_cellvars)) {
1992                                 v = PyTuple_GET_ITEM(co->co_cellvars,
1993                                                        oparg);
1994                                format_exc_check_arg(
1995                                        PyExc_UnboundLocalError,
1996                                        UNBOUNDLOCAL_ERROR_MSG,
1997                                        v);
1998                         } else {
1999                                 v = PyTuple_GET_ITEM(co->co_freevars, oparg -
2000                                         PyTuple_GET_SIZE(co->co_cellvars));
2001                                 format_exc_check_arg(PyExc_NameError,
2002                                                      UNBOUNDFREE_ERROR_MSG, v);
2003                         }
2004                         break;
2005
2006                 case STORE_DEREF:
2007                         w = POP();
2008                         x = freevars[oparg];
2009                         PyCell_Set(x, w);
2010                         Py_DECREF(w);
2011                         continue;
2012
2013                 case BUILD_TUPLE:
2014                         x = PyTuple_New(oparg);
2015                         if (x != NULL) {
2016                                 for (; --oparg >= 0;) {
2017                                         w = POP();
2018                                         PyTuple_SET_ITEM(x, oparg, w);
2019                                 }
2020                                 PUSH(x);
2021                                 continue;
2022                         }
2023                         break;
2024
2025                 case BUILD_LIST:
2026                         x =  PyList_New(oparg);
2027                         if (x != NULL) {
2028                                 for (; --oparg >= 0;) {
2029                                         w = POP();
2030                                         PyList_SET_ITEM(x, oparg, w);
2031                                 }
2032                                 PUSH(x);
2033                                 continue;
2034                         }
2035                         break;
2036
2037                 case BUILD_MAP:
2038                         x = _PyDict_NewPresized((Py_ssize_t)oparg);
2039                         PUSH(x);
2040                         if (x != NULL) continue;
2041                         break;
2042
2043                 case STORE_MAP:
2044                         w = TOP();     /* key */
2045                         u = SECOND();  /* value */
2046                         v = THIRD();   /* dict */
2047                         STACKADJ(-2);
2048                         assert (PyDict_CheckExact(v));
2049                         err = PyDict_SetItem(v, w, u);  /* v[w] = u */
2050                         Py_DECREF(u);
2051                         Py_DECREF(w);
2052                         if (err == 0) continue;
2053                         break;
2054
2055                 case LOAD_ATTR:
2056                         w = GETITEM(names, oparg);
2057                         v = TOP();
2058                         x = PyObject_GetAttr(v, w);
2059                         Py_DECREF(v);
2060                         SET_TOP(x);
2061                         if (x != NULL) continue;
2062                         break;
2063
2064                 case COMPARE_OP:
2065                         w = POP();
2066                         v = TOP();
2067                         if (PyInt_CheckExact(w) && PyInt_CheckExact(v)) {
2068                                 /* INLINE: cmp(int, int) */
2069                                 register long a, b;
2070                                 register int res;
2071                                 a = PyInt_AS_LONG(v);
2072                                 b = PyInt_AS_LONG(w);
2073                                 switch (oparg) {
2074                                 case PyCmp_LT: res = a <  b; break;
2075                                 case PyCmp_LE: res = a <= b; break;
2076                                 case PyCmp_EQ: res = a == b; break;
2077                                 case PyCmp_NE: res = a != b; break;
2078                                 case PyCmp_GT: res = a >  b; break;
2079                                 case PyCmp_GE: res = a >= b; break;
2080                                 case PyCmp_IS: res = v == w; break;
2081                                 case PyCmp_IS_NOT: res = v != w; break;
2082                                 default: goto slow_compare;
2083                                 }
2084                                 x = res ? Py_True : Py_False;
2085                                 Py_INCREF(x);
2086                         }
2087                         else {
2088                           slow_compare:
2089                                 x = cmp_outcome(oparg, v, w);
2090                         }
2091                         Py_DECREF(v);
2092                         Py_DECREF(w);
2093                         SET_TOP(x);
2094                         if (x == NULL) break;
2095                         PREDICT(JUMP_IF_FALSE);
2096                         PREDICT(JUMP_IF_TRUE);
2097                         continue;
2098
2099                 case IMPORT_NAME:
2100                         w = GETITEM(names, oparg);
2101                         x = PyDict_GetItemString(f->f_builtins, "__import__");
2102                         if (x == NULL) {
2103                                 PyErr_SetString(PyExc_ImportError,
2104                                                 "__import__ not found");
2105                                 break;
2106                         }
2107                         Py_INCREF(x);
2108                         v = POP();
2109                         u = TOP();
2110                         if (PyInt_AsLong(u) != -1 || PyErr_Occurred())
2111                                 w = PyTuple_Pack(5,
2112                                             w,
2113                                             f->f_globals,
2114                                             f->f_locals == NULL ?
2115                                                   Py_None : f->f_locals,
2116                                             v,
2117                                             u);
2118                         else
2119                                 w = PyTuple_Pack(4,
2120                                             w,
2121                                             f->f_globals,
2122                                             f->f_locals == NULL ?
2123                                                   Py_None : f->f_locals,
2124                                             v);
2125                         Py_DECREF(v);
2126                         Py_DECREF(u);
2127                         if (w == NULL) {
2128                                 u = POP();
2129                                 Py_DECREF(x);
2130                                 x = NULL;
2131                                 break;
2132                         }
2133                         READ_TIMESTAMP(intr0);
2134                         v = x;
2135                         x = PyEval_CallObject(v, w);
2136                         Py_DECREF(v);
2137                         READ_TIMESTAMP(intr1);
2138                         Py_DECREF(w);
2139                         SET_TOP(x);
2140                         if (x != NULL) continue;
2141                         break;
2142
2143                 case IMPORT_STAR:
2144                         v = POP();
2145                         PyFrame_FastToLocals(f);
2146                         if ((x = f->f_locals) == NULL) {
2147                                 PyErr_SetString(PyExc_SystemError,
2148                                         "no locals found during 'import *'");
2149                                 break;
2150                         }
2151                         READ_TIMESTAMP(intr0);
2152                         err = import_all_from(x, v);
2153                         READ_TIMESTAMP(intr1);
2154                         PyFrame_LocalsToFast(f, 0);
2155                         Py_DECREF(v);
2156                         if (err == 0) continue;
2157                         break;
2158
2159                 case IMPORT_FROM:
2160                         w = GETITEM(names, oparg);
2161                         v = TOP();
2162                         READ_TIMESTAMP(intr0);
2163                         x = import_from(v, w);
2164                         READ_TIMESTAMP(intr1);
2165                         PUSH(x);
2166                         if (x != NULL) continue;
2167                         break;
2168
2169                 case JUMP_FORWARD:
2170                         JUMPBY(oparg);
2171                         goto fast_next_opcode;
2172
2173                 PREDICTED_WITH_ARG(JUMP_IF_FALSE);
2174                 case JUMP_IF_FALSE:
2175                         w = TOP();
2176                         if (w == Py_True) {
2177                                 PREDICT(POP_TOP);
2178                                 goto fast_next_opcode;
2179                         }
2180                         if (w == Py_False) {
2181                                 JUMPBY(oparg);
2182                                 goto fast_next_opcode;
2183                         }
2184                         err = PyObject_IsTrue(w);
2185                         if (err > 0)
2186                                 err = 0;
2187                         else if (err == 0)
2188                                 JUMPBY(oparg);
2189                         else
2190                                 break;
2191                         continue;
2192
2193                 PREDICTED_WITH_ARG(JUMP_IF_TRUE);
2194                 case JUMP_IF_TRUE:
2195                         w = TOP();
2196                         if (w == Py_False) {
2197                                 PREDICT(POP_TOP);
2198                                 goto fast_next_opcode;
2199                         }
2200                         if (w == Py_True) {
2201                                 JUMPBY(oparg);
2202                                 goto fast_next_opcode;
2203                         }
2204                         err = PyObject_IsTrue(w);
2205                         if (err > 0) {
2206                                 err = 0;
2207                                 JUMPBY(oparg);
2208                         }
2209                         else if (err == 0)
2210                                 ;
2211                         else
2212                                 break;
2213                         continue;
2214
2215                 PREDICTED_WITH_ARG(JUMP_ABSOLUTE);
2216                 case JUMP_ABSOLUTE:
2217                         JUMPTO(oparg);
2218 #if FAST_LOOPS
2219                         /* Enabling this path speeds-up all while and for-loops by bypassing
2220                            the per-loop checks for signals.  By default, this should be turned-off
2221                            because it prevents detection of a control-break in tight loops like
2222                            "while 1: pass".  Compile with this option turned-on when you need
2223                            the speed-up and do not need break checking inside tight loops (ones
2224                            that contain only instructions ending with goto fast_next_opcode).
2225                         */
2226                         goto fast_next_opcode;
2227 #else
2228                         continue;
2229 #endif
2230
2231                 case GET_ITER:
2232                         /* before: [obj]; after [getiter(obj)] */
2233                         v = TOP();
2234                         x = PyObject_GetIter(v);
2235                         Py_DECREF(v);
2236                         if (x != NULL) {
2237                                 SET_TOP(x);
2238                                 PREDICT(FOR_ITER);
2239                                 continue;
2240                         }
2241                         STACKADJ(-1);
2242                         break;
2243
2244                 PREDICTED_WITH_ARG(FOR_ITER);
2245                 case FOR_ITER:
2246                         /* before: [iter]; after: [iter, iter()] *or* [] */
2247                         v = TOP();
2248                         x = (*v->ob_type->tp_iternext)(v);
2249                         if (x != NULL) {
2250                                 PUSH(x);
2251                                 PREDICT(STORE_FAST);
2252                                 PREDICT(UNPACK_SEQUENCE);
2253                                 continue;
2254                         }
2255                         if (PyErr_Occurred()) {
2256                                 if (!PyErr_ExceptionMatches(
2257                                                 PyExc_StopIteration))
2258                                         break;
2259                                 PyErr_Clear();
2260                         }
2261                         /* iterator ended normally */
2262                         x = v = POP();
2263                         Py_DECREF(v);
2264                         JUMPBY(oparg);
2265                         continue;
2266
2267                 case BREAK_LOOP:
2268                         why = WHY_BREAK;
2269                         goto fast_block_end;
2270
2271                 case CONTINUE_LOOP:
2272                         retval = PyInt_FromLong(oparg);
2273                         if (!retval) {
2274                                 x = NULL;
2275                                 break;
2276                         }
2277                         why = WHY_CONTINUE;
2278                         goto fast_block_end;
2279
2280                 case SETUP_LOOP:
2281                 case SETUP_EXCEPT:
2282                 case SETUP_FINALLY:
2283                         /* NOTE: If you add any new block-setup opcodes that
2284                            are not try/except/finally handlers, you may need
2285                            to update the PyGen_NeedsFinalizing() function.
2286                            */
2287
2288                         PyFrame_BlockSetup(f, opcode, INSTR_OFFSET() + oparg,
2289                                            STACK_LEVEL());
2290                         continue;
2291
2292                 case WITH_CLEANUP:
2293                 {
2294                         /* At the top of the stack are 1-3 values indicating
2295                            how/why we entered the finally clause:
2296                            - TOP = None
2297                            - (TOP, SECOND) = (WHY_{RETURN,CONTINUE}), retval
2298                            - TOP = WHY_*; no retval below it
2299                            - (TOP, SECOND, THIRD) = exc_info()
2300                            Below them is EXIT, the context.__exit__ bound method.
2301                            In the last case, we must call
2302                              EXIT(TOP, SECOND, THIRD)
2303                            otherwise we must call
2304                              EXIT(None, None, None)
2305
2306                            In all cases, we remove EXIT from the stack, leaving
2307                            the rest in the same order.
2308
2309                            In addition, if the stack represents an exception,
2310                            *and* the function call returns a 'true' value, we
2311                            "zap" this information, to prevent END_FINALLY from
2312                            re-raising the exception.  (But non-local gotos
2313                            should still be resumed.)
2314                         */
2315
2316                         PyObject *exit_func;
2317
2318                         u = POP();
2319                         if (u == Py_None) {
2320                                 exit_func = TOP();
2321                                 SET_TOP(u);
2322                                 v = w = Py_None;
2323                         }
2324                         else if (PyInt_Check(u)) {
2325                                 switch(PyInt_AS_LONG(u)) {
2326                                 case WHY_RETURN:
2327                                 case WHY_CONTINUE:
2328                                         /* Retval in TOP. */
2329                                         exit_func = SECOND();
2330                                         SET_SECOND(TOP());
2331                                         SET_TOP(u);
2332                                         break;
2333                                 default:
2334                                         exit_func = TOP();
2335                                         SET_TOP(u);
2336                                         break;
2337                                 }
2338                                 u = v = w = Py_None;
2339                         }
2340                         else {
2341                                 v = TOP();
2342                                 w = SECOND();
2343                                 exit_func = THIRD();
2344                                 SET_TOP(u);
2345                                 SET_SECOND(v);
2346                                 SET_THIRD(w);
2347                         }
2348                         /* XXX Not the fastest way to call it... */
2349                         x = PyObject_CallFunctionObjArgs(exit_func, u, v, w,
2350                                                          NULL);
2351                         Py_DECREF(exit_func);
2352                         if (x == NULL)
2353                                 break; /* Go to error exit */
2354
2355                         if (u != Py_None)
2356                                 err = PyObject_IsTrue(x);
2357                         else
2358                                 err = 0;
2359                         Py_DECREF(x);
2360
2361                         if (err < 0)
2362                                 break; /* Go to error exit */
2363                         else if (err > 0) {
2364                                 err = 0;
2365                                 /* There was an exception and a true return */
2366                                 STACKADJ(-2);
2367                                 Py_INCREF(Py_None);
2368                                 SET_TOP(Py_None);
2369                                 Py_DECREF(u);
2370                                 Py_DECREF(v);
2371                                 Py_DECREF(w);
2372                         } else {
2373                                 /* The stack was rearranged to remove EXIT
2374                                    above. Let END_FINALLY do its thing */
2375                         }
2376                         PREDICT(END_FINALLY);
2377                         break;
2378                 }
2379
2380                 case CALL_FUNCTION:
2381                 {
2382                         PyObject **sp;
2383                         PCALL(PCALL_ALL);
2384                         sp = stack_pointer;
2385 #ifdef WITH_TSC
2386                         x = call_function(&sp, oparg, &intr0, &intr1);
2387 #else
2388                         x = call_function(&sp, oparg);
2389 #endif
2390                         stack_pointer = sp;
2391                         PUSH(x);
2392                         if (x != NULL)
2393                                 continue;
2394                         break;
2395                 }
2396
2397                 case CALL_FUNCTION_VAR:
2398                 case CALL_FUNCTION_KW:
2399                 case CALL_FUNCTION_VAR_KW:
2400                 {
2401                     int na = oparg & 0xff;
2402                     int nk = (oparg>>8) & 0xff;
2403                     int flags = (opcode - CALL_FUNCTION) & 3;
2404                     int n = na + 2 * nk;
2405                     PyObject **pfunc, *func, **sp;
2406                     PCALL(PCALL_ALL);
2407                     if (flags & CALL_FLAG_VAR)
2408                             n++;
2409                     if (flags & CALL_FLAG_KW)
2410                             n++;
2411                     pfunc = stack_pointer - n - 1;
2412                     func = *pfunc;
2413
2414                     if (PyMethod_Check(func)
2415                         && PyMethod_GET_SELF(func) != NULL) {
2416                             PyObject *self = PyMethod_GET_SELF(func);
2417                             Py_INCREF(self);
2418                             func = PyMethod_GET_FUNCTION(func);
2419                             Py_INCREF(func);
2420                             Py_DECREF(*pfunc);
2421                             *pfunc = self;
2422                             na++;
2423                             n++;
2424                     } else
2425                             Py_INCREF(func);
2426                     sp = stack_pointer;
2427                     READ_TIMESTAMP(intr0);
2428                     x = ext_do_call(func, &sp, flags, na, nk);
2429                     READ_TIMESTAMP(intr1);
2430                     stack_pointer = sp;
2431                     Py_DECREF(func);
2432
2433                     while (stack_pointer > pfunc) {
2434                             w = POP();
2435                             Py_DECREF(w);
2436                     }
2437                     PUSH(x);
2438                     if (x != NULL)
2439                             continue;
2440                     break;
2441                 }
2442
2443                 case MAKE_FUNCTION:
2444                         v = POP(); /* code object */
2445                         x = PyFunction_New(v, f->f_globals);
2446                         Py_DECREF(v);
2447                         /* XXX Maybe this should be a separate opcode? */
2448                         if (x != NULL && oparg > 0) {
2449                                 v = PyTuple_New(oparg);
2450                                 if (v == NULL) {
2451                                         Py_DECREF(x);
2452                                         x = NULL;
2453                                         break;
2454                                 }
2455                                 while (--oparg >= 0) {
2456                                         w = POP();
2457                                         PyTuple_SET_ITEM(v, oparg, w);
2458                                 }
2459                                 err = PyFunction_SetDefaults(x, v);
2460                                 Py_DECREF(v);
2461                         }
2462                         PUSH(x);
2463                         break;
2464
2465                 case MAKE_CLOSURE:
2466                 {
2467                         v = POP(); /* code object */
2468                         x = PyFunction_New(v, f->f_globals);
2469                         Py_DECREF(v);
2470                         if (x != NULL) {
2471                                 v = POP();
2472                                 if (PyFunction_SetClosure(x, v) != 0) {
2473                                         /* Can't happen unless bytecode is corrupt. */
2474                                         why = WHY_EXCEPTION;
2475                                 }
2476                                 Py_DECREF(v);
2477                         }
2478                         if (x != NULL && oparg > 0) {
2479                                 v = PyTuple_New(oparg);
2480                                 if (v == NULL) {
2481                                         Py_DECREF(x);
2482                                         x = NULL;
2483                                         break;
2484                                 }
2485                                 while (--oparg >= 0) {
2486                                         w = POP();
2487                                         PyTuple_SET_ITEM(v, oparg, w);
2488                                 }
2489                                 if (PyFunction_SetDefaults(x, v) != 0) {
2490                                         /* Can't happen unless
2491                                            PyFunction_SetDefaults changes. */
2492                                         why = WHY_EXCEPTION;
2493                                 }
2494                                 Py_DECREF(v);
2495                         }
2496                         PUSH(x);
2497                         break;
2498                 }
2499
2500                 case BUILD_SLICE:
2501                         if (oparg == 3)
2502                                 w = POP();
2503                         else
2504                                 w = NULL;
2505                         v = POP();
2506                         u = TOP();
2507                         x = PySlice_New(u, v, w);
2508                         Py_DECREF(u);
2509                         Py_DECREF(v);
2510                         Py_XDECREF(w);
2511                         SET_TOP(x);
2512                         if (x != NULL) continue;
2513                         break;
2514
2515                 case EXTENDED_ARG:
2516                         opcode = NEXTOP();
2517                         oparg = oparg<<16 | NEXTARG();
2518                         goto dispatch_opcode;
2519
2520                 default:
2521                         fprintf(stderr,
2522                                 "XXX lineno: %d, opcode: %d\n",
2523                                 PyCode_Addr2Line(f->f_code, f->f_lasti),
2524                                 opcode);
2525                         PyErr_SetString(PyExc_SystemError, "unknown opcode");
2526                         why = WHY_EXCEPTION;
2527                         break;
2528
2529 #ifdef CASE_TOO_BIG
2530                 }
2531 #endif
2532
2533                 } /* switch */
2534
2535             on_error:
2536
2537                 READ_TIMESTAMP(inst1);
2538
2539                 /* Quickly continue if no error occurred */
2540
2541                 if (why == WHY_NOT) {
2542                         if (err == 0 && x != NULL) {
2543 #ifdef CHECKEXC
2544                                 /* This check is expensive! */
2545                                 if (PyErr_Occurred())
2546                                         fprintf(stderr,
2547                                                 "XXX undetected error\n");
2548                                 else {
2549 #endif
2550                                         READ_TIMESTAMP(loop1);
2551                                         continue; /* Normal, fast path */
2552 #ifdef CHECKEXC
2553                                 }
2554 #endif
2555                         }
2556                         why = WHY_EXCEPTION;
2557                         x = Py_None;
2558                         err = 0;
2559                 }
2560
2561                 /* Double-check exception status */
2562
2563                 if (why == WHY_EXCEPTION || why == WHY_RERAISE) {
2564                         if (!PyErr_Occurred()) {
2565                                 PyErr_SetString(PyExc_SystemError,
2566                                         "error return without exception set");
2567                                 why = WHY_EXCEPTION;
2568                         }
2569                 }
2570 #ifdef CHECKEXC
2571                 else {
2572                         /* This check is expensive! */
2573                         if (PyErr_Occurred()) {
2574                                 char buf[128];
2575                                 sprintf(buf, "Stack unwind with exception "
2576                                         "set and why=%d", why);
2577                                 Py_FatalError(buf);
2578                         }
2579                 }
2580 #endif
2581
2582                 /* Log traceback info if this is a real exception */
2583
2584                 if (why == WHY_EXCEPTION) {
2585                         PyTraceBack_Here(f);
2586
2587                         if (tstate->c_tracefunc != NULL)
2588                                 call_exc_trace(tstate->c_tracefunc,
2589                                                tstate->c_traceobj, f);
2590                 }
2591
2592                 /* For the rest, treat WHY_RERAISE as WHY_EXCEPTION */
2593
2594                 if (why == WHY_RERAISE)
2595                         why = WHY_EXCEPTION;
2596
2597                 /* Unwind stacks if a (pseudo) exception occurred */
2598
2599 fast_block_end:
2600                 while (why != WHY_NOT && f->f_iblock > 0) {
2601                         PyTryBlock *b = PyFrame_BlockPop(f);
2602
2603                         assert(why != WHY_YIELD);
2604                         if (b->b_type == SETUP_LOOP && why == WHY_CONTINUE) {
2605                                 /* For a continue inside a try block,
2606                                    don't pop the block for the loop. */
2607                                 PyFrame_BlockSetup(f, b->b_type, b->b_handler,
2608                                                    b->b_level);
2609                                 why = WHY_NOT;
2610                                 JUMPTO(PyInt_AS_LONG(retval));
2611                                 Py_DECREF(retval);
2612                                 break;
2613                         }
2614
2615                         while (STACK_LEVEL() > b->b_level) {
2616                                 v = POP();
2617                                 Py_XDECREF(v);
2618                         }
2619                         if (b->b_type == SETUP_LOOP && why == WHY_BREAK) {
2620                                 why = WHY_NOT;
2621                                 JUMPTO(b->b_handler);
2622                                 break;
2623                         }
2624                         if (b->b_type == SETUP_FINALLY ||
2625                             (b->b_type == SETUP_EXCEPT &&
2626                              why == WHY_EXCEPTION)) {
2627                                 if (why == WHY_EXCEPTION) {
2628                                         PyObject *exc, *val, *tb;
2629                                         PyErr_Fetch(&exc, &val, &tb);
2630                                         if (val == NULL) {
2631                                                 val = Py_None;
2632                                                 Py_INCREF(val);
2633                                         }
2634                                         /* Make the raw exception data
2635                                            available to the handler,
2636                                            so a program can emulate the
2637                                            Python main loop.  Don't do
2638                                            this for 'finally'. */
2639                                         if (b->b_type == SETUP_EXCEPT) {
2640                                                 PyErr_NormalizeException(
2641                                                         &exc, &val, &tb);
2642                                                 set_exc_info(tstate,
2643                                                              exc, val, tb);
2644                                         }
2645                                         if (tb == NULL) {
2646                                                 Py_INCREF(Py_None);
2647                                                 PUSH(Py_None);
2648                                         } else
2649                                                 PUSH(tb);
2650                                         PUSH(val);
2651                                         PUSH(exc);
2652                                 }
2653                                 else {
2654                                         if (why & (WHY_RETURN | WHY_CONTINUE))
2655                                                 PUSH(retval);
2656                                         v = PyInt_FromLong((long)why);
2657                                         PUSH(v);
2658                                 }
2659                                 why = WHY_NOT;
2660                                 JUMPTO(b->b_handler);
2661                                 break;
2662                         }
2663                 } /* unwind stack */
2664
2665                 /* End the loop if we still have an error (or return) */
2666
2667                 if (why != WHY_NOT)
2668                         break;
2669                 READ_TIMESTAMP(loop1);
2670
2671         } /* main loop */
2672
2673         assert(why != WHY_YIELD);
2674         /* Pop remaining stack entries. */
2675         while (!EMPTY()) {
2676                 v = POP();
2677                 Py_XDECREF(v);
2678         }
2679
2680         if (why != WHY_RETURN)
2681                 retval = NULL;
2682
2683 fast_yield:
2684         if (tstate->use_tracing) {
2685                 if (tstate->c_tracefunc) {
2686                         if (why == WHY_RETURN || why == WHY_YIELD) {
2687                                 if (call_trace(tstate->c_tracefunc,
2688                                                tstate->c_traceobj, f,
2689                                                PyTrace_RETURN, retval)) {
2690                                         Py_XDECREF(retval);
2691                                         retval = NULL;
2692                                         why = WHY_EXCEPTION;
2693                                 }
2694                         }
2695                         else if (why == WHY_EXCEPTION) {
2696                                 call_trace_protected(tstate->c_tracefunc,
2697                                                      tstate->c_traceobj, f,
2698                                                      PyTrace_RETURN, NULL);
2699                         }
2700                 }
2701                 if (tstate->c_profilefunc) {
2702                         if (why == WHY_EXCEPTION)
2703                                 call_trace_protected(tstate->c_profilefunc,
2704                                                      tstate->c_profileobj, f,
2705                                                      PyTrace_RETURN, NULL);
2706                         else if (call_trace(tstate->c_profilefunc,
2707                                             tstate->c_profileobj, f,
2708                                             PyTrace_RETURN, retval)) {
2709                                 Py_XDECREF(retval);
2710                                 retval = NULL;
2711                                 why = WHY_EXCEPTION;
2712                         }
2713                 }
2714         }
2715
2716         if (tstate->frame->f_exc_type != NULL)
2717                 reset_exc_info(tstate);
2718         else {
2719                 assert(tstate->frame->f_exc_value == NULL);
2720                 assert(tstate->frame->f_exc_traceback == NULL);
2721         }
2722
2723         /* pop frame */
2724 exit_eval_frame:
2725         Py_LeaveRecursiveCall();
2726         tstate->frame = f->f_back;
2727
2728         return retval;
2729 }
2730
2731 /* This is gonna seem *real weird*, but if you put some other code between
2732    PyEval_EvalFrame() and PyEval_EvalCodeEx() you will need to adjust
2733    the test in the if statements in Misc/gdbinit (pystack and pystackv). */
2734
2735 PyObject *
2736 PyEval_EvalCodeEx(PyCodeObject *co, PyObject *globals, PyObject *locals,
2737            PyObject **args, int argcount, PyObject **kws, int kwcount,
2738            PyObject **defs, int defcount, PyObject *closure)
2739 {
2740         register PyFrameObject *f;
2741         register PyObject *retval = NULL;
2742         register PyObject **fastlocals, **freevars;
2743         PyThreadState *tstate = PyThreadState_GET();
2744         PyObject *x, *u;
2745
2746         if (globals == NULL) {
2747                 PyErr_SetString(PyExc_SystemError,
2748                                 "PyEval_EvalCodeEx: NULL globals");
2749                 return NULL;
2750         }
2751
2752         assert(tstate != NULL);
2753         assert(globals != NULL);
2754         f = PyFrame_New(tstate, co, globals, locals);
2755         if (f == NULL)
2756                 return NULL;
2757
2758         fastlocals = f->f_localsplus;
2759         freevars = f->f_localsplus + co->co_nlocals;
2760
2761         if (co->co_argcount > 0 ||
2762             co->co_flags & (CO_VARARGS | CO_VARKEYWORDS)) {
2763                 int i;
2764                 int n = argcount;
2765                 PyObject *kwdict = NULL;
2766                 if (co->co_flags & CO_VARKEYWORDS) {
2767                         kwdict = PyDict_New();
2768                         if (kwdict == NULL)
2769                                 goto fail;
2770                         i = co->co_argcount;
2771                         if (co->co_flags & CO_VARARGS)
2772                                 i++;
2773                         SETLOCAL(i, kwdict);
2774                 }
2775                 if (argcount > co->co_argcount) {
2776                         if (!(co->co_flags & CO_VARARGS)) {
2777                                 PyErr_Format(PyExc_TypeError,
2778                                     "%.200s() takes %s %d "
2779                                     "%sargument%s (%d given)",
2780                                     PyString_AsString(co->co_name),
2781                                     defcount ? "at most" : "exactly",
2782                                     co->co_argcount,
2783                                     kwcount ? "non-keyword " : "",
2784                                     co->co_argcount == 1 ? "" : "s",
2785                                     argcount);
2786                                 goto fail;
2787                         }
2788                         n = co->co_argcount;
2789                 }
2790                 for (i = 0; i < n; i++) {
2791                         x = args[i];
2792                         Py_INCREF(x);
2793                         SETLOCAL(i, x);
2794                 }
2795                 if (co->co_flags & CO_VARARGS) {
2796                         u = PyTuple_New(argcount - n);
2797                         if (u == NULL)
2798                                 goto fail;
2799                         SETLOCAL(co->co_argcount, u);
2800                         for (i = n; i < argcount; i++) {
2801                                 x = args[i];
2802                                 Py_INCREF(x);
2803                                 PyTuple_SET_ITEM(u, i-n, x);
2804                         }
2805                 }
2806                 for (i = 0; i < kwcount; i++) {
2807                         PyObject **co_varnames;
2808                         PyObject *keyword = kws[2*i];
2809                         PyObject *value = kws[2*i + 1];
2810                         int j;
2811                         if (keyword == NULL || !PyString_Check(keyword)) {
2812                                 PyErr_Format(PyExc_TypeError,
2813                                     "%.200s() keywords must be strings",
2814                                     PyString_AsString(co->co_name));
2815                                 goto fail;
2816                         }
2817                         /* Speed hack: do raw pointer compares. As names are
2818                            normally interned this should almost always hit. */
2819                         co_varnames = PySequence_Fast_ITEMS(co->co_varnames);
2820                         for (j = 0; j < co->co_argcount; j++) {
2821                                 PyObject *nm = co_varnames[j];
2822                                 if (nm == keyword)
2823                                         goto kw_found;
2824                         }
2825                         /* Slow fallback, just in case */
2826                         for (j = 0; j < co->co_argcount; j++) {
2827                                 PyObject *nm = co_varnames[j];
2828                                 int cmp = PyObject_RichCompareBool(
2829                                         keyword, nm, Py_EQ);
2830                                 if (cmp > 0)
2831                                         goto kw_found;
2832                                 else if (cmp < 0)
2833                                         goto fail;
2834                         }
2835                         /* Check errors from Compare */
2836                         if (PyErr_Occurred())
2837                                 goto fail;
2838                         if (j >= co->co_argcount) {
2839                                 if (kwdict == NULL) {
2840                                         PyErr_Format(PyExc_TypeError,
2841                                             "%.200s() got an unexpected "
2842                                             "keyword argument '%.400s'",
2843                                             PyString_AsString(co->co_name),
2844                                             PyString_AsString(keyword));
2845                                         goto fail;
2846                                 }
2847                                 PyDict_SetItem(kwdict, keyword, value);
2848                                 continue;
2849                         }
2850 kw_found:
2851                         if (GETLOCAL(j) != NULL) {
2852                                 PyErr_Format(PyExc_TypeError,
2853                                                 "%.200s() got multiple "
2854                                                 "values for keyword "
2855                                                 "argument '%.400s'",
2856                                                 PyString_AsString(co->co_name),
2857                                                 PyString_AsString(keyword));
2858                                 goto fail;
2859                         }
2860                         Py_INCREF(value);
2861                         SETLOCAL(j, value);
2862                 }
2863                 if (argcount < co->co_argcount) {
2864                         int m = co->co_argcount - defcount;
2865                         for (i = argcount; i < m; i++) {
2866                                 if (GETLOCAL(i) == NULL) {
2867                                         PyErr_Format(PyExc_TypeError,
2868                                             "%.200s() takes %s %d "
2869                                             "%sargument%s (%d given)",
2870                                             PyString_AsString(co->co_name),
2871                                             ((co->co_flags & CO_VARARGS) ||
2872                                              defcount) ? "at least"
2873                                                        : "exactly",
2874                                             m, kwcount ? "non-keyword " : "",
2875                                             m == 1 ? "" : "s", i);
2876                                         goto fail;
2877                                 }
2878                         }
2879                         if (n > m)
2880                                 i = n - m;
2881                         else
2882                                 i = 0;
2883                         for (; i < defcount; i++) {
2884                                 if (GETLOCAL(m+i) == NULL) {
2885                                         PyObject *def = defs[i];
2886                                         Py_INCREF(def);
2887                                         SETLOCAL(m+i, def);
2888                                 }
2889                         }
2890                 }
2891         }
2892         else {
2893                 if (argcount > 0 || kwcount > 0) {
2894                         PyErr_Format(PyExc_TypeError,
2895                                      "%.200s() takes no arguments (%d given)",
2896                                      PyString_AsString(co->co_name),
2897                                      argcount + kwcount);
2898                         goto fail;
2899                 }
2900         }
2901         /* Allocate and initialize storage for cell vars, and copy free
2902            vars into frame.  This isn't too efficient right now. */
2903         if (PyTuple_GET_SIZE(co->co_cellvars)) {
2904                 int i, j, nargs, found;
2905                 char *cellname, *argname;
2906                 PyObject *c;
2907
2908                 nargs = co->co_argcount;
2909                 if (co->co_flags & CO_VARARGS)
2910                         nargs++;
2911                 if (co->co_flags & CO_VARKEYWORDS)
2912                         nargs++;
2913
2914                 /* Initialize each cell var, taking into account
2915                    cell vars that are initialized from arguments.
2916
2917                    Should arrange for the compiler to put cellvars
2918                    that are arguments at the beginning of the cellvars
2919                    list so that we can march over it more efficiently?
2920                 */
2921                 for (i = 0; i < PyTuple_GET_SIZE(co->co_cellvars); ++i) {
2922                         cellname = PyString_AS_STRING(
2923                                 PyTuple_GET_ITEM(co->co_cellvars, i));
2924                         found = 0;
2925                         for (j = 0; j < nargs; j++) {
2926                                 argname = PyString_AS_STRING(
2927                                         PyTuple_GET_ITEM(co->co_varnames, j));
2928                                 if (strcmp(cellname, argname) == 0) {
2929                                         c = PyCell_New(GETLOCAL(j));
2930                                         if (c == NULL)
2931                                                 goto fail;
2932                                         GETLOCAL(co->co_nlocals + i) = c;
2933                                         found = 1;
2934                                         break;
2935                                 }
2936                         }
2937                         if (found == 0) {
2938                                 c = PyCell_New(NULL);
2939                                 if (c == NULL)
2940                                         goto fail;
2941                                 SETLOCAL(co->co_nlocals + i, c);
2942                         }
2943                 }
2944         }
2945         if (PyTuple_GET_SIZE(co->co_freevars)) {
2946                 int i;
2947                 for (i = 0; i < PyTuple_GET_SIZE(co->co_freevars); ++i) {
2948                         PyObject *o = PyTuple_GET_ITEM(closure, i);
2949                         Py_INCREF(o);
2950                         freevars[PyTuple_GET_SIZE(co->co_cellvars) + i] = o;
2951                 }
2952         }
2953
2954         if (co->co_flags & CO_GENERATOR) {
2955                 /* Don't need to keep the reference to f_back, it will be set
2956                  * when the generator is resumed. */
2957                 Py_XDECREF(f->f_back);
2958                 f->f_back = NULL;
2959
2960                 PCALL(PCALL_GENERATOR);
2961
2962                 /* Create a new generator that owns the ready to run frame
2963                  * and return that as the value. */
2964                 return PyGen_New(f);
2965         }
2966
2967         retval = PyEval_EvalFrameEx(f,0);
2968
2969 fail: /* Jump here from prelude on failure */
2970
2971         /* decref'ing the frame can cause __del__ methods to get invoked,
2972            which can call back into Python.  While we're done with the
2973            current Python frame (f), the associated C stack is still in use,
2974            so recursion_depth must be boosted for the duration.
2975         */
2976         assert(tstate != NULL);
2977         ++tstate->recursion_depth;
2978         Py_DECREF(f);
2979         --tstate->recursion_depth;
2980         return retval;
2981 }
2982
2983
2984 /* Implementation notes for set_exc_info() and reset_exc_info():
2985
2986 - Below, 'exc_ZZZ' stands for 'exc_type', 'exc_value' and
2987   'exc_traceback'.  These always travel together.
2988
2989 - tstate->curexc_ZZZ is the "hot" exception that is set by
2990   PyErr_SetString(), cleared by PyErr_Clear(), and so on.
2991
2992 - Once an exception is caught by an except clause, it is transferred
2993   from tstate->curexc_ZZZ to tstate->exc_ZZZ, from which sys.exc_info()
2994   can pick it up.  This is the primary task of set_exc_info().
2995   XXX That can't be right:  set_exc_info() doesn't look at tstate->curexc_ZZZ.
2996
2997 - Now let me explain the complicated dance with frame->f_exc_ZZZ.
2998
2999   Long ago, when none of this existed, there were just a few globals:
3000   one set corresponding to the "hot" exception, and one set
3001   corresponding to sys.exc_ZZZ.  (Actually, the latter weren't C
3002   globals; they were simply stored as sys.exc_ZZZ.  For backwards
3003   compatibility, they still are!)  The problem was that in code like
3004   this:
3005
3006      try:
3007         "something that may fail"
3008      except "some exception":
3009         "do something else first"
3010         "print the exception from sys.exc_ZZZ."
3011
3012   if "do something else first" invoked something that raised and caught
3013   an exception, sys.exc_ZZZ were overwritten.  That was a frequent
3014   cause of subtle bugs.  I fixed this by changing the semantics as
3015   follows:
3016
3017     - Within one frame, sys.exc_ZZZ will hold the last exception caught
3018       *in that frame*.
3019
3020     - But initially, and as long as no exception is caught in a given
3021       frame, sys.exc_ZZZ will hold the last exception caught in the
3022       previous frame (or the frame before that, etc.).
3023
3024   The first bullet fixed the bug in the above example.  The second
3025   bullet was for backwards compatibility: it was (and is) common to
3026   have a function that is called when an exception is caught, and to
3027   have that function access the caught exception via sys.exc_ZZZ.
3028   (Example: traceback.print_exc()).
3029
3030   At the same time I fixed the problem that sys.exc_ZZZ weren't
3031   thread-safe, by introducing sys.exc_info() which gets it from tstate;
3032   but that's really a separate improvement.
3033
3034   The reset_exc_info() function in ceval.c restores the tstate->exc_ZZZ
3035   variables to what they were before the current frame was called.  The
3036   set_exc_info() function saves them on the frame so that
3037   reset_exc_info() can restore them.  The invariant is that
3038   frame->f_exc_ZZZ is NULL iff the current frame never caught an
3039   exception (where "catching" an exception applies only to successful
3040   except clauses); and if the current frame ever caught an exception,
3041   frame->f_exc_ZZZ is the exception that was stored in tstate->exc_ZZZ
3042   at the start of the current frame.
3043
3044 */
3045
3046 static void
3047 set_exc_info(PyThreadState *tstate,
3048              PyObject *type, PyObject *value, PyObject *tb)
3049 {
3050         PyFrameObject *frame = tstate->frame;
3051         PyObject *tmp_type, *tmp_value, *tmp_tb;
3052
3053         assert(type != NULL);
3054         assert(frame != NULL);
3055         if (frame->f_exc_type == NULL) {
3056                 assert(frame->f_exc_value == NULL);
3057                 assert(frame->f_exc_traceback == NULL);
3058                 /* This frame didn't catch an exception before. */
3059                 /* Save previous exception of this thread in this frame. */
3060                 if (tstate->exc_type == NULL) {
3061                         /* XXX Why is this set to Py_None? */
3062                         Py_INCREF(Py_None);
3063                         tstate->exc_type = Py_None;
3064                 }
3065                 Py_INCREF(tstate->exc_type);
3066                 Py_XINCREF(tstate->exc_value);
3067                 Py_XINCREF(tstate->exc_traceback);
3068                 frame->f_exc_type = tstate->exc_type;
3069                 frame->f_exc_value = tstate->exc_value;
3070                 frame->f_exc_traceback = tstate->exc_traceback;
3071         }
3072         /* Set new exception for this thread. */
3073         tmp_type = tstate->exc_type;
3074         tmp_value = tstate->exc_value;
3075         tmp_tb = tstate->exc_traceback;
3076         Py_INCREF(type);
3077         Py_XINCREF(value);
3078         Py_XINCREF(tb);
3079         tstate->exc_type = type;
3080         tstate->exc_value = value;
3081         tstate->exc_traceback = tb;
3082         Py_XDECREF(tmp_type);
3083         Py_XDECREF(tmp_value);
3084         Py_XDECREF(tmp_tb);
3085         /* For b/w compatibility */
3086         PySys_SetObject("exc_type", type);
3087         PySys_SetObject("exc_value", value);
3088         PySys_SetObject("exc_traceback", tb);
3089 }
3090
3091 static void
3092 reset_exc_info(PyThreadState *tstate)
3093 {
3094         PyFrameObject *frame;
3095         PyObject *tmp_type, *tmp_value, *tmp_tb;
3096
3097         /* It's a precondition that the thread state's frame caught an
3098          * exception -- verify in a debug build.
3099          */
3100         assert(tstate != NULL);
3101         frame = tstate->frame;
3102         assert(frame != NULL);
3103         assert(frame->f_exc_type != NULL);
3104
3105         /* Copy the frame's exception info back to the thread state. */
3106         tmp_type = tstate->exc_type;
3107         tmp_value = tstate->exc_value;
3108         tmp_tb = tstate->exc_traceback;
3109         Py_INCREF(frame->f_exc_type);
3110         Py_XINCREF(frame->f_exc_value);
3111         Py_XINCREF(frame->f_exc_traceback);
3112         tstate->exc_type = frame->f_exc_type;
3113         tstate->exc_value = frame->f_exc_value;
3114         tstate->exc_traceback = frame->f_exc_traceback;
3115         Py_XDECREF(tmp_type);
3116         Py_XDECREF(tmp_value);
3117         Py_XDECREF(tmp_tb);
3118
3119         /* For b/w compatibility */
3120         PySys_SetObject("exc_type", frame->f_exc_type);
3121         PySys_SetObject("exc_value", frame->f_exc_value);
3122         PySys_SetObject("exc_traceback", frame->f_exc_traceback);
3123
3124         /* Clear the frame's exception info. */
3125         tmp_type = frame->f_exc_type;
3126         tmp_value = frame->f_exc_value;
3127         tmp_tb = frame->f_exc_traceback;
3128         frame->f_exc_type = NULL;
3129         frame->f_exc_value = NULL;
3130         frame->f_exc_traceback = NULL;
3131         Py_DECREF(tmp_type);
3132         Py_XDECREF(tmp_value);
3133         Py_XDECREF(tmp_tb);
3134 }
3135
3136 /* Logic for the raise statement (too complicated for inlining).
3137    This *consumes* a reference count to each of its arguments. */
3138 static enum why_code
3139 do_raise(PyObject *type, PyObject *value, PyObject *tb)
3140 {
3141         if (type == NULL) {
3142                 /* Reraise */
3143                 PyThreadState *tstate = PyThreadState_GET();
3144                 type = tstate->exc_type == NULL ? Py_None : tstate->exc_type;
3145                 value = tstate->exc_value;
3146                 tb = tstate->exc_traceback;
3147                 Py_XINCREF(type);
3148                 Py_XINCREF(value);
3149                 Py_XINCREF(tb);
3150         }
3151
3152         /* We support the following forms of raise:
3153            raise <class>, <classinstance>
3154            raise <class>, <argument tuple>
3155            raise <class>, None
3156            raise <class>, <argument>
3157            raise <classinstance>, None
3158            raise <string>, <object>
3159            raise <string>, None
3160
3161            An omitted second argument is the same as None.
3162
3163            In addition, raise <tuple>, <anything> is the same as
3164            raising the tuple's first item (and it better have one!);
3165            this rule is applied recursively.
3166
3167            Finally, an optional third argument can be supplied, which
3168            gives the traceback to be substituted (useful when
3169            re-raising an exception after examining it).  */
3170
3171         /* First, check the traceback argument, replacing None with
3172            NULL. */
3173         if (tb == Py_None) {
3174                 Py_DECREF(tb);
3175                 tb = NULL;
3176         }
3177         else if (tb != NULL && !PyTraceBack_Check(tb)) {
3178                 PyErr_SetString(PyExc_TypeError,
3179                            "raise: arg 3 must be a traceback or None");
3180                 goto raise_error;
3181         }
3182
3183         /* Next, replace a missing value with None */
3184         if (value == NULL) {
3185                 value = Py_None;
3186                 Py_INCREF(value);
3187         }
3188
3189         /* Next, repeatedly, replace a tuple exception with its first item */
3190         while (PyTuple_Check(type) && PyTuple_Size(type) > 0) {
3191                 PyObject *tmp = type;
3192                 type = PyTuple_GET_ITEM(type, 0);
3193                 Py_INCREF(type);
3194                 Py_DECREF(tmp);
3195         }
3196
3197         if (PyExceptionClass_Check(type))
3198                 PyErr_NormalizeException(&type, &value, &tb);
3199
3200         else if (PyExceptionInstance_Check(type)) {
3201                 /* Raising an instance.  The value should be a dummy. */
3202                 if (value != Py_None) {
3203                         PyErr_SetString(PyExc_TypeError,
3204                           "instance exception may not have a separate value");
3205                         goto raise_error;
3206                 }
3207                 else {
3208                         /* Normalize to raise <class>, <instance> */
3209                         Py_DECREF(value);
3210                         value = type;
3211                         type = PyExceptionInstance_Class(type);
3212                         Py_INCREF(type);
3213                 }
3214         }
3215         else {
3216                 /* Not something you can raise.  You get an exception
3217                    anyway, just not what you specified :-) */
3218                 PyErr_Format(PyExc_TypeError,
3219                         "exceptions must be classes or instances, not %s",
3220                         type->ob_type->tp_name);
3221                 goto raise_error;
3222         }
3223
3224         assert(PyExceptionClass_Check(type));
3225         if (Py_Py3kWarningFlag && PyClass_Check(type)) {
3226                 if (PyErr_WarnEx(PyExc_DeprecationWarning,
3227                                 "exceptions must derive from BaseException "
3228                                 "in 3.x", 1) < 0)
3229                         goto raise_error;
3230         }
3231
3232         PyErr_Restore(type, value, tb);
3233         if (tb == NULL)
3234                 return WHY_EXCEPTION;
3235         else
3236                 return WHY_RERAISE;
3237  raise_error:
3238         Py_XDECREF(value);
3239         Py_XDECREF(type);
3240         Py_XDECREF(tb);
3241         return WHY_EXCEPTION;
3242 }
3243
3244 /* Iterate v argcnt times and store the results on the stack (via decreasing
3245    sp).  Return 1 for success, 0 if error. */
3246
3247 static int
3248 unpack_iterable(PyObject *v, int argcnt, PyObject **sp)
3249 {
3250         int i = 0;
3251         PyObject *it;  /* iter(v) */
3252         PyObject *w;
3253
3254         assert(v != NULL);
3255
3256         it = PyObject_GetIter(v);
3257         if (it == NULL)
3258                 goto Error;
3259
3260         for (; i < argcnt; i++) {
3261                 w = PyIter_Next(it);
3262                 if (w == NULL) {
3263                         /* Iterator done, via error or exhaustion. */
3264                         if (!PyErr_Occurred()) {
3265                                 PyErr_Format(PyExc_ValueError,
3266                                         "need more than %d value%s to unpack",
3267                                         i, i == 1 ? "" : "s");
3268                         }
3269                         goto Error;
3270                 }
3271                 *--sp = w;
3272         }
3273
3274         /* We better have exhausted the iterator now. */
3275         w = PyIter_Next(it);
3276         if (w == NULL) {
3277                 if (PyErr_Occurred())
3278                         goto Error;
3279                 Py_DECREF(it);
3280                 return 1;
3281         }
3282         Py_DECREF(w);
3283         PyErr_SetString(PyExc_ValueError, "too many values to unpack");
3284         /* fall through */
3285 Error:
3286         for (; i > 0; i--, sp++)
3287                 Py_DECREF(*sp);
3288         Py_XDECREF(it);
3289         return 0;
3290 }
3291
3292
3293 #ifdef LLTRACE
3294 static int
3295 prtrace(PyObject *v, char *str)
3296 {
3297         printf("%s ", str);
3298         if (PyObject_Print(v, stdout, 0) != 0)
3299                 PyErr_Clear(); /* Don't know what else to do */
3300         printf("\n");
3301         return 1;
3302 }
3303 #endif
3304
3305 static void
3306 call_exc_trace(Py_tracefunc func, PyObject *self, PyFrameObject *f)
3307 {
3308         PyObject *type, *value, *traceback, *arg;
3309         int err;
3310         PyErr_Fetch(&type, &value, &traceback);
3311         if (value == NULL) {
3312                 value = Py_None;
3313                 Py_INCREF(value);
3314         }
3315         arg = PyTuple_Pack(3, type, value, traceback);
3316         if (arg == NULL) {
3317                 PyErr_Restore(type, value, traceback);
3318                 return;
3319         }
3320         err = call_trace(func, self, f, PyTrace_EXCEPTION, arg);
3321         Py_DECREF(arg);
3322         if (err == 0)
3323                 PyErr_Restore(type, value, traceback);
3324         else {
3325                 Py_XDECREF(type);
3326                 Py_XDECREF(value);
3327                 Py_XDECREF(traceback);
3328         }
3329 }
3330
3331 static int
3332 call_trace_protected(Py_tracefunc func, PyObject *obj, PyFrameObject *frame,
3333                      int what, PyObject *arg)
3334 {
3335         PyObject *type, *value, *traceback;
3336         int err;
3337         PyErr_Fetch(&type, &value, &traceback);
3338         err = call_trace(func, obj, frame, what, arg);
3339         if (err == 0)
3340         {
3341                 PyErr_Restore(type, value, traceback);
3342                 return 0;
3343         }
3344         else {
3345                 Py_XDECREF(type);
3346                 Py_XDECREF(value);
3347                 Py_XDECREF(traceback);
3348                 return -1;
3349         }
3350 }
3351
3352 static int
3353 call_trace(Py_tracefunc func, PyObject *obj, PyFrameObject *frame,
3354            int what, PyObject *arg)
3355 {
3356         register PyThreadState *tstate = frame->f_tstate;
3357         int result;
3358         if (tstate->tracing)
3359                 return 0;
3360         tstate->tracing++;
3361         tstate->use_tracing = 0;
3362         result = func(obj, frame, what, arg);
3363         tstate->use_tracing = ((tstate->c_tracefunc != NULL)
3364                                || (tstate->c_profilefunc != NULL));
3365         tstate->tracing--;
3366         return result;
3367 }
3368
3369 PyObject *
3370 _PyEval_CallTracing(PyObject *func, PyObject *args)
3371 {
3372         PyFrameObject *frame = PyEval_GetFrame();
3373         PyThreadState *tstate = frame->f_tstate;
3374         int save_tracing = tstate->tracing;
3375         int save_use_tracing = tstate->use_tracing;
3376         PyObject *result;
3377
3378         tstate->tracing = 0;
3379         tstate->use_tracing = ((tstate->c_tracefunc != NULL)
3380                                || (tstate->c_profilefunc != NULL));
3381         result = PyObject_Call(func, args, NULL);
3382         tstate->tracing = save_tracing;
3383         tstate->use_tracing = save_use_tracing;
3384         return result;
3385 }
3386
3387 static int
3388 maybe_call_line_trace(Py_tracefunc func, PyObject *obj,
3389                       PyFrameObject *frame, int *instr_lb, int *instr_ub,
3390                       int *instr_prev)
3391 {
3392         int result = 0;
3393
3394         /* If the last instruction executed isn't in the current
3395            instruction window, reset the window.  If the last
3396            instruction happens to fall at the start of a line or if it
3397            represents a jump backwards, call the trace function.
3398         */
3399         if ((frame->f_lasti < *instr_lb || frame->f_lasti >= *instr_ub)) {
3400                 int line;
3401                 PyAddrPair bounds;
3402
3403                 line = PyCode_CheckLineNumber(frame->f_code, frame->f_lasti,
3404                                               &bounds);
3405                 if (line >= 0) {
3406                         frame->f_lineno = line;
3407                         result = call_trace(func, obj, frame,
3408                                             PyTrace_LINE, Py_None);
3409                 }
3410                 *instr_lb = bounds.ap_lower;
3411                 *instr_ub = bounds.ap_upper;
3412         }
3413         else if (frame->f_lasti <= *instr_prev) {
3414                 result = call_trace(func, obj, frame, PyTrace_LINE, Py_None);
3415         }
3416         *instr_prev = frame->f_lasti;
3417         return result;
3418 }
3419
3420 void
3421 PyEval_SetProfile(Py_tracefunc func, PyObject *arg)
3422 {
3423         PyThreadState *tstate = PyThreadState_GET();
3424         PyObject *temp = tstate->c_profileobj;
3425         Py_XINCREF(arg);
3426         tstate->c_profilefunc = NULL;
3427         tstate->c_profileobj = NULL;
3428         /* Must make sure that tracing is not ignored if 'temp' is freed */
3429         tstate->use_tracing = tstate->c_tracefunc != NULL;
3430         Py_XDECREF(temp);
3431         tstate->c_profilefunc = func;
3432         tstate->c_profileobj = arg;
3433         /* Flag that tracing or profiling is turned on */
3434         tstate->use_tracing = (func != NULL) || (tstate->c_tracefunc != NULL);
3435 }
3436
3437 void
3438 PyEval_SetTrace(Py_tracefunc func, PyObject *arg)
3439 {
3440         PyThreadState *tstate = PyThreadState_GET();
3441         PyObject *temp = tstate->c_traceobj;
3442         _Py_TracingPossible += (func != NULL) - (tstate->c_tracefunc != NULL);
3443         Py_XINCREF(arg);
3444         tstate->c_tracefunc = NULL;
3445         tstate->c_traceobj = NULL;
3446         /* Must make sure that profiling is not ignored if 'temp' is freed */
3447         tstate->use_tracing = tstate->c_profilefunc != NULL;
3448         Py_XDECREF(temp);
3449         tstate->c_tracefunc = func;
3450         tstate->c_traceobj = arg;
3451         /* Flag that tracing or profiling is turned on */
3452         tstate->use_tracing = ((func != NULL)
3453                                || (tstate->c_profilefunc != NULL));
3454 }
3455
3456 PyObject *
3457 PyEval_GetBuiltins(void)
3458 {
3459         PyFrameObject *current_frame = PyEval_GetFrame();
3460         if (current_frame == NULL)
3461                 return PyThreadState_GET()->interp->builtins;
3462         else
3463                 return current_frame->f_builtins;
3464 }
3465
3466 PyObject *
3467 PyEval_GetLocals(void)
3468 {
3469         PyFrameObject *current_frame = PyEval_GetFrame();
3470         if (current_frame == NULL)
3471                 return NULL;
3472         PyFrame_FastToLocals(current_frame);
3473         return current_frame->f_locals;
3474 }
3475
3476 PyObject *
3477 PyEval_GetGlobals(void)
3478 {
3479         PyFrameObject *current_frame = PyEval_GetFrame();
3480         if (current_frame == NULL)
3481                 return NULL;
3482         else
3483                 return current_frame->f_globals;
3484 }
3485
3486 PyFrameObject *
3487 PyEval_GetFrame(void)
3488 {
3489         PyThreadState *tstate = PyThreadState_GET();
3490         return _PyThreadState_GetFrame(tstate);
3491 }
3492
3493 int
3494 PyEval_GetRestricted(void)
3495 {
3496         PyFrameObject *current_frame = PyEval_GetFrame();
3497         return current_frame == NULL ? 0 : PyFrame_IsRestricted(current_frame);
3498 }
3499
3500 int
3501 PyEval_MergeCompilerFlags(PyCompilerFlags *cf)
3502 {
3503         PyFrameObject *current_frame = PyEval_GetFrame();
3504         int result = cf->cf_flags != 0;
3505
3506         if (current_frame != NULL) {
3507                 const int codeflags = current_frame->f_code->co_flags;
3508                 const int compilerflags = codeflags & PyCF_MASK;
3509                 if (compilerflags) {
3510                         result = 1;
3511                         cf->cf_flags |= compilerflags;
3512                 }
3513 #if 0 /* future keyword */
3514                 if (codeflags & CO_GENERATOR_ALLOWED) {
3515                         result = 1;
3516                         cf->cf_flags |= CO_GENERATOR_ALLOWED;
3517                 }
3518 #endif
3519         }
3520         return result;
3521 }
3522
3523 int
3524 Py_FlushLine(void)
3525 {
3526         PyObject *f = PySys_GetObject("stdout");
3527         if (f == NULL)
3528                 return 0;
3529         if (!PyFile_SoftSpace(f, 0))
3530                 return 0;
3531         return PyFile_WriteString("\n", f);
3532 }
3533
3534
3535 /* External interface to call any callable object.
3536    The arg must be a tuple or NULL. */
3537
3538 #undef PyEval_CallObject
3539 /* for backward compatibility: export this interface */
3540
3541 PyObject *
3542 PyEval_CallObject(PyObject *func, PyObject *arg)
3543 {
3544         return PyEval_CallObjectWithKeywords(func, arg, (PyObject *)NULL);
3545 }
3546 #define PyEval_CallObject(func,arg) \
3547         PyEval_CallObjectWithKeywords(func, arg, (PyObject *)NULL)
3548
3549 PyObject *
3550 PyEval_CallObjectWithKeywords(PyObject *func, PyObject *arg, PyObject *kw)
3551 {
3552         PyObject *result;
3553
3554         if (arg == NULL) {
3555                 arg = PyTuple_New(0);
3556                 if (arg == NULL)
3557                         return NULL;
3558         }
3559         else if (!PyTuple_Check(arg)) {
3560                 PyErr_SetString(PyExc_TypeError,
3561                                 "argument list must be a tuple");
3562                 return NULL;
3563         }
3564         else
3565                 Py_INCREF(arg);
3566
3567         if (kw != NULL && !PyDict_Check(kw)) {
3568                 PyErr_SetString(PyExc_TypeError,
3569                                 "keyword list must be a dictionary");
3570                 Py_DECREF(arg);
3571                 return NULL;
3572         }
3573
3574         result = PyObject_Call(func, arg, kw);
3575         Py_DECREF(arg);
3576         return result;
3577 }
3578
3579 const char *
3580 PyEval_GetFuncName(PyObject *func)
3581 {
3582         if (PyMethod_Check(func))
3583                 return PyEval_GetFuncName(PyMethod_GET_FUNCTION(func));
3584         else if (PyFunction_Check(func))
3585                 return PyString_AsString(((PyFunctionObject*)func)->func_name);
3586         else if (PyCFunction_Check(func))
3587                 return ((PyCFunctionObject*)func)->m_ml->ml_name;
3588         else if (PyClass_Check(func))
3589                 return PyString_AsString(((PyClassObject*)func)->cl_name);
3590         else if (PyInstance_Check(func)) {
3591                 return PyString_AsString(
3592                         ((PyInstanceObject*)func)->in_class->cl_name);
3593         } else {
3594                 return func->ob_type->tp_name;
3595         }
3596 }
3597
3598 const char *
3599 PyEval_GetFuncDesc(PyObject *func)
3600 {
3601         if (PyMethod_Check(func))
3602                 return "()";
3603         else if (PyFunction_Check(func))
3604                 return "()";
3605         else if (PyCFunction_Check(func))
3606                 return "()";
3607         else if (PyClass_Check(func))
3608                 return " constructor";
3609         else if (PyInstance_Check(func)) {
3610                 return " instance";
3611         } else {
3612                 return " object";
3613         }
3614 }
3615
3616 static void
3617 err_args(PyObject *func, int flags, int nargs)
3618 {
3619         if (flags & METH_NOARGS)
3620                 PyErr_Format(PyExc_TypeError,
3621                              "%.200s() takes no arguments (%d given)",
3622                              ((PyCFunctionObject *)func)->m_ml->ml_name,
3623                              nargs);
3624         else
3625                 PyErr_Format(PyExc_TypeError,
3626                              "%.200s() takes exactly one argument (%d given)",
3627                              ((PyCFunctionObject *)func)->m_ml->ml_name,
3628                              nargs);
3629 }
3630
3631 #define C_TRACE(x, call) \
3632 if (tstate->use_tracing && tstate->c_profilefunc) { \
3633         if (call_trace(tstate->c_profilefunc, \
3634                 tstate->c_profileobj, \
3635                 tstate->frame, PyTrace_C_CALL, \
3636                 func)) { \
3637                 x = NULL; \
3638         } \
3639         else { \
3640                 x = call; \
3641                 if (tstate->c_profilefunc != NULL) { \
3642                         if (x == NULL) { \
3643                                 call_trace_protected(tstate->c_profilefunc, \
3644                                         tstate->c_profileobj, \
3645                                         tstate->frame, PyTrace_C_EXCEPTION, \
3646                                         func); \
3647                                 /* XXX should pass (type, value, tb) */ \
3648                         } else { \
3649                                 if (call_trace(tstate->c_profilefunc, \
3650                                         tstate->c_profileobj, \
3651                                         tstate->frame, PyTrace_C_RETURN, \
3652                                         func)) { \
3653                                         Py_DECREF(x); \
3654                                         x = NULL; \
3655                                 } \
3656                         } \
3657                 } \
3658         } \
3659 } else { \
3660         x = call; \
3661         }
3662
3663 static PyObject *
3664 call_function(PyObject ***pp_stack, int oparg
3665 #ifdef WITH_TSC
3666                 , uint64* pintr0, uint64* pintr1
3667 #endif
3668                 )
3669 {
3670         int na = oparg & 0xff;
3671         int nk = (oparg>>8) & 0xff;
3672         int n = na + 2 * nk;
3673         PyObject **pfunc = (*pp_stack) - n - 1;
3674         PyObject *func = *pfunc;
3675         PyObject *x, *w;
3676
3677         /* Always dispatch PyCFunction first, because these are
3678            presumed to be the most frequent callable object.
3679         */
3680         if (PyCFunction_Check(func) && nk == 0) {
3681                 int flags = PyCFunction_GET_FLAGS(func);
3682                 PyThreadState *tstate = PyThreadState_GET();
3683
3684                 PCALL(PCALL_CFUNCTION);
3685                 if (flags & (METH_NOARGS | METH_O)) {
3686                         PyCFunction meth = PyCFunction_GET_FUNCTION(func);
3687                         PyObject *self = PyCFunction_GET_SELF(func);
3688                         if (flags & METH_NOARGS && na == 0) {
3689                                 C_TRACE(x, (*meth)(self,NULL));
3690                         }
3691                         else if (flags & METH_O && na == 1) {
3692                                 PyObject *arg = EXT_POP(*pp_stack);
3693                                 C_TRACE(x, (*meth)(self,arg));
3694                                 Py_DECREF(arg);
3695                         }
3696                         else {
3697                                 err_args(func, flags, na);
3698                                 x = NULL;
3699                         }
3700                 }
3701                 else {
3702                         PyObject *callargs;
3703                         callargs = load_args(pp_stack, na);
3704                         READ_TIMESTAMP(*pintr0);
3705                         C_TRACE(x, PyCFunction_Call(func,callargs,NULL));
3706                         READ_TIMESTAMP(*pintr1);
3707                         Py_XDECREF(callargs);
3708                 }
3709         } else {
3710                 if (PyMethod_Check(func) && PyMethod_GET_SELF(func) != NULL) {
3711                         /* optimize access to bound methods */
3712                         PyObject *self = PyMethod_GET_SELF(func);
3713                         PCALL(PCALL_METHOD);
3714                         PCALL(PCALL_BOUND_METHOD);
3715                         Py_INCREF(self);
3716                         func = PyMethod_GET_FUNCTION(func);
3717                         Py_INCREF(func);
3718                         Py_DECREF(*pfunc);
3719                         *pfunc = self;
3720                         na++;
3721                         n++;
3722                 } else
3723                         Py_INCREF(func);
3724                 READ_TIMESTAMP(*pintr0);
3725                 if (PyFunction_Check(func))
3726                         x = fast_function(func, pp_stack, n, na, nk);
3727                 else
3728                         x = do_call(func, pp_stack, na, nk);
3729                 READ_TIMESTAMP(*pintr1);
3730                 Py_DECREF(func);
3731         }
3732
3733         /* Clear the stack of the function object.  Also removes
3734            the arguments in case they weren't consumed already
3735            (fast_function() and err_args() leave them on the stack).
3736          */
3737         while ((*pp_stack) > pfunc) {
3738                 w = EXT_POP(*pp_stack);
3739                 Py_DECREF(w);
3740                 PCALL(PCALL_POP);
3741         }
3742         return x;
3743 }
3744
3745 /* The fast_function() function optimize calls for which no argument
3746    tuple is necessary; the objects are passed directly from the stack.
3747    For the simplest case -- a function that takes only positional
3748    arguments and is called with only positional arguments -- it
3749    inlines the most primitive frame setup code from
3750    PyEval_EvalCodeEx(), which vastly reduces the checks that must be
3751    done before evaluating the frame.
3752 */
3753
3754 static PyObject *
3755 fast_function(PyObject *func, PyObject ***pp_stack, int n, int na, int nk)
3756 {
3757         PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
3758         PyObject *globals = PyFunction_GET_GLOBALS(func);
3759         PyObject *argdefs = PyFunction_GET_DEFAULTS(func);
3760         PyObject **d = NULL;
3761         int nd = 0;
3762
3763         PCALL(PCALL_FUNCTION);
3764         PCALL(PCALL_FAST_FUNCTION);
3765         if (argdefs == NULL && co->co_argcount == n && nk==0 &&
3766             co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) {
3767                 PyFrameObject *f;
3768                 PyObject *retval = NULL;
3769                 PyThreadState *tstate = PyThreadState_GET();
3770                 PyObject **fastlocals, **stack;
3771                 int i;
3772
3773                 PCALL(PCALL_FASTER_FUNCTION);
3774                 assert(globals != NULL);
3775                 /* XXX Perhaps we should create a specialized
3776                    PyFrame_New() that doesn't take locals, but does
3777                    take builtins without sanity checking them.
3778                 */
3779                 assert(tstate != NULL);
3780                 f = PyFrame_New(tstate, co, globals, NULL);
3781                 if (f == NULL)
3782                         return NULL;
3783
3784                 fastlocals = f->f_localsplus;
3785                 stack = (*pp_stack) - n;
3786
3787                 for (i = 0; i < n; i++) {
3788                         Py_INCREF(*stack);
3789                         fastlocals[i] = *stack++;
3790                 }
3791                 retval = PyEval_EvalFrameEx(f,0);
3792                 ++tstate->recursion_depth;
3793                 Py_DECREF(f);
3794                 --tstate->recursion_depth;
3795                 return retval;
3796         }
3797         if (argdefs != NULL) {
3798                 d = &PyTuple_GET_ITEM(argdefs, 0);
3799                 nd = Py_SIZE(argdefs);
3800         }
3801         return PyEval_EvalCodeEx(co, globals,
3802                                  (PyObject *)NULL, (*pp_stack)-n, na,
3803                                  (*pp_stack)-2*nk, nk, d, nd,
3804                                  PyFunction_GET_CLOSURE(func));
3805 }
3806
3807 static PyObject *
3808 update_keyword_args(PyObject *orig_kwdict, int nk, PyObject ***pp_stack,
3809                     PyObject *func)
3810 {
3811         PyObject *kwdict = NULL;
3812         if (orig_kwdict == NULL)
3813                 kwdict = PyDict_New();
3814         else {
3815                 kwdict = PyDict_Copy(orig_kwdict);
3816                 Py_DECREF(orig_kwdict);
3817         }
3818         if (kwdict == NULL)
3819                 return NULL;
3820         while (--nk >= 0) {
3821                 int err;
3822                 PyObject *value = EXT_POP(*pp_stack);
3823                 PyObject *key = EXT_POP(*pp_stack);
3824                 if (PyDict_GetItem(kwdict, key) != NULL) {
3825                         PyErr_Format(PyExc_TypeError,
3826                                      "%.200s%s got multiple values "
3827                                      "for keyword argument '%.200s'",
3828                                      PyEval_GetFuncName(func),
3829                                      PyEval_GetFuncDesc(func),
3830                                      PyString_AsString(key));
3831                         Py_DECREF(key);
3832                         Py_DECREF(value);
3833                         Py_DECREF(kwdict);
3834                         return NULL;
3835                 }
3836                 err = PyDict_SetItem(kwdict, key, value);
3837                 Py_DECREF(key);
3838                 Py_DECREF(value);
3839                 if (err) {
3840                         Py_DECREF(kwdict);
3841                         return NULL;
3842                 }
3843         }
3844         return kwdict;
3845 }
3846
3847 static PyObject *
3848 update_star_args(int nstack, int nstar, PyObject *stararg,
3849                  PyObject ***pp_stack)
3850 {
3851         PyObject *callargs, *w;
3852
3853         callargs = PyTuple_New(nstack + nstar);
3854         if (callargs == NULL) {
3855                 return NULL;
3856         }
3857         if (nstar) {
3858                 int i;
3859                 for (i = 0; i < nstar; i++) {
3860                         PyObject *a = PyTuple_GET_ITEM(stararg, i);
3861                         Py_INCREF(a);
3862                         PyTuple_SET_ITEM(callargs, nstack + i, a);
3863                 }
3864         }
3865         while (--nstack >= 0) {
3866                 w = EXT_POP(*pp_stack);
3867                 PyTuple_SET_ITEM(callargs, nstack, w);
3868         }
3869         return callargs;
3870 }
3871
3872 static PyObject *
3873 load_args(PyObject ***pp_stack, int na)
3874 {
3875         PyObject *args = PyTuple_New(na);
3876         PyObject *w;
3877
3878         if (args == NULL)
3879                 return NULL;
3880         while (--na >= 0) {
3881                 w = EXT_POP(*pp_stack);
3882                 PyTuple_SET_ITEM(args, na, w);
3883         }
3884         return args;
3885 }
3886
3887 static PyObject *
3888 do_call(PyObject *func, PyObject ***pp_stack, int na, int nk)
3889 {
3890         PyObject *callargs = NULL;
3891         PyObject *kwdict = NULL;
3892         PyObject *result = NULL;
3893
3894         if (nk > 0) {
3895                 kwdict = update_keyword_args(NULL, nk, pp_stack, func);
3896                 if (kwdict == NULL)
3897                         goto call_fail;
3898         }
3899         callargs = load_args(pp_stack, na);
3900         if (callargs == NULL)
3901                 goto call_fail;
3902 #ifdef CALL_PROFILE
3903         /* At this point, we have to look at the type of func to
3904            update the call stats properly.  Do it here so as to avoid
3905            exposing the call stats machinery outside ceval.c
3906         */
3907         if (PyFunction_Check(func))
3908                 PCALL(PCALL_FUNCTION);
3909         else if (PyMethod_Check(func))
3910                 PCALL(PCALL_METHOD);
3911         else if (PyType_Check(func))
3912                 PCALL(PCALL_TYPE);
3913         else
3914                 PCALL(PCALL_OTHER);
3915 #endif
3916         result = PyObject_Call(func, callargs, kwdict);
3917  call_fail:
3918         Py_XDECREF(callargs);
3919         Py_XDECREF(kwdict);
3920         return result;
3921 }
3922
3923 static PyObject *
3924 ext_do_call(PyObject *func, PyObject ***pp_stack, int flags, int na, int nk)
3925 {
3926         int nstar = 0;
3927         PyObject *callargs = NULL;
3928         PyObject *stararg = NULL;
3929         PyObject *kwdict = NULL;
3930         PyObject *result = NULL;
3931
3932         if (flags & CALL_FLAG_KW) {
3933                 kwdict = EXT_POP(*pp_stack);
3934                 if (!PyDict_Check(kwdict)) {
3935                         PyObject *d;
3936                         d = PyDict_New();
3937                         if (d == NULL)
3938                                 goto ext_call_fail;
3939                         if (PyDict_Update(d, kwdict) != 0) {
3940                                 Py_DECREF(d);
3941                                 /* PyDict_Update raises attribute
3942                                  * error (percolated from an attempt
3943                                  * to get 'keys' attribute) instead of
3944                                  * a type error if its second argument
3945                                  * is not a mapping.
3946                                  */
3947                                 if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
3948                                         PyErr_Format(PyExc_TypeError,
3949                                                      "%.200s%.200s argument after ** "
3950                                                      "must be a mapping, not %.200s",
3951                                                      PyEval_GetFuncName(func),
3952                                                      PyEval_GetFuncDesc(func),
3953                                                      kwdict->ob_type->tp_name);
3954                                 }
3955                                 goto ext_call_fail;
3956                         }
3957                         Py_DECREF(kwdict);
3958                         kwdict = d;
3959                 }
3960         }
3961         if (flags & CALL_FLAG_VAR) {
3962                 stararg = EXT_POP(*pp_stack);
3963                 if (!PyTuple_Check(stararg)) {
3964                         PyObject *t = NULL;
3965                         t = PySequence_Tuple(stararg);
3966                         if (t == NULL) {
3967                                 if (PyErr_ExceptionMatches(PyExc_TypeError)) {
3968                                         PyErr_Format(PyExc_TypeError,
3969                                                      "%.200s%.200s argument after * "
3970                                                      "must be a sequence, not %200s",
3971                                                      PyEval_GetFuncName(func),
3972                                                      PyEval_GetFuncDesc(func),
3973                                                      stararg->ob_type->tp_name);
3974                                 }
3975                                 goto ext_call_fail;
3976                         }
3977                         Py_DECREF(stararg);
3978                         stararg = t;
3979                 }
3980                 nstar = PyTuple_GET_SIZE(stararg);
3981         }
3982         if (nk > 0) {
3983                 kwdict = update_keyword_args(kwdict, nk, pp_stack, func);
3984                 if (kwdict == NULL)
3985                         goto ext_call_fail;
3986         }
3987         callargs = update_star_args(na, nstar, stararg, pp_stack);
3988         if (callargs == NULL)
3989                 goto ext_call_fail;
3990 #ifdef CALL_PROFILE
3991         /* At this point, we have to look at the type of func to
3992            update the call stats properly.  Do it here so as to avoid
3993            exposing the call stats machinery outside ceval.c
3994         */
3995         if (PyFunction_Check(func))
3996                 PCALL(PCALL_FUNCTION);
3997         else if (PyMethod_Check(func))
3998                 PCALL(PCALL_METHOD);
3999         else if (PyType_Check(func))
4000                 PCALL(PCALL_TYPE);
4001         else
4002                 PCALL(PCALL_OTHER);
4003 #endif
4004         result = PyObject_Call(func, callargs, kwdict);
4005 ext_call_fail:
4006         Py_XDECREF(callargs);
4007         Py_XDECREF(kwdict);
4008         Py_XDECREF(stararg);
4009         return result;
4010 }
4011
4012 /* Extract a slice index from a PyInt or PyLong or an object with the
4013    nb_index slot defined, and store in *pi.
4014    Silently reduce values larger than PY_SSIZE_T_MAX to PY_SSIZE_T_MAX,
4015    and silently boost values less than -PY_SSIZE_T_MAX-1 to -PY_SSIZE_T_MAX-1.
4016    Return 0 on error, 1 on success.
4017 */
4018 /* Note:  If v is NULL, return success without storing into *pi.  This
4019    is because_PyEval_SliceIndex() is called by apply_slice(), which can be
4020    called by the SLICE opcode with v and/or w equal to NULL.
4021 */
4022 int
4023 _PyEval_SliceIndex(PyObject *v, Py_ssize_t *pi)
4024 {
4025         if (v != NULL) {
4026                 Py_ssize_t x;
4027                 if (PyInt_Check(v)) {
4028                         /* XXX(nnorwitz): I think PyInt_AS_LONG is correct,
4029                            however, it looks like it should be AsSsize_t.
4030                            There should be a comment here explaining why.
4031                         */
4032                         x = PyInt_AS_LONG(v);
4033                 }
4034                 else if (PyIndex_Check(v)) {
4035                         x = PyNumber_AsSsize_t(v, NULL);
4036                         if (x == -1 && PyErr_Occurred())
4037                                 return 0;
4038                 }
4039                 else {
4040                         PyErr_SetString(PyExc_TypeError,
4041                                         "slice indices must be integers or "
4042                                         "None or have an __index__ method");
4043                         return 0;
4044                 }
4045                 *pi = x;
4046         }
4047         return 1;
4048 }
4049
4050 #undef ISINDEX
4051 #define ISINDEX(x) ((x) == NULL || \
4052                     PyInt_Check(x) || PyLong_Check(x) || PyIndex_Check(x))
4053
4054 static PyObject *
4055 apply_slice(PyObject *u, PyObject *v, PyObject *w) /* return u[v:w] */
4056 {
4057         PyTypeObject *tp = u->ob_type;
4058         PySequenceMethods *sq = tp->tp_as_sequence;
4059
4060         if (sq && sq->sq_slice && ISINDEX(v) && ISINDEX(w)) {
4061                 Py_ssize_t ilow = 0, ihigh = PY_SSIZE_T_MAX;
4062                 if (!_PyEval_SliceIndex(v, &ilow))
4063                         return NULL;
4064                 if (!_PyEval_SliceIndex(w, &ihigh))
4065                         return NULL;
4066                 return PySequence_GetSlice(u, ilow, ihigh);
4067         }
4068         else {
4069                 PyObject *slice = PySlice_New(v, w, NULL);
4070                 if (slice != NULL) {
4071                         PyObject *res = PyObject_GetItem(u, slice);
4072                         Py_DECREF(slice);
4073                         return res;
4074                 }
4075                 else
4076                         return NULL;
4077         }
4078 }
4079
4080 static int
4081 assign_slice(PyObject *u, PyObject *v, PyObject *w, PyObject *x)
4082         /* u[v:w] = x */
4083 {
4084         PyTypeObject *tp = u->ob_type;
4085         PySequenceMethods *sq = tp->tp_as_sequence;
4086
4087         if (sq && sq->sq_ass_slice && ISINDEX(v) && ISINDEX(w)) {
4088                 Py_ssize_t ilow = 0, ihigh = PY_SSIZE_T_MAX;
4089                 if (!_PyEval_SliceIndex(v, &ilow))
4090                         return -1;
4091                 if (!_PyEval_SliceIndex(w, &ihigh))
4092                         return -1;
4093                 if (x == NULL)
4094                         return PySequence_DelSlice(u, ilow, ihigh);
4095                 else
4096                         return PySequence_SetSlice(u, ilow, ihigh, x);
4097         }
4098         else {
4099                 PyObject *slice = PySlice_New(v, w, NULL);
4100                 if (slice != NULL) {
4101                         int res;
4102                         if (x != NULL)
4103                                 res = PyObject_SetItem(u, slice, x);
4104                         else
4105                                 res = PyObject_DelItem(u, slice);
4106                         Py_DECREF(slice);
4107                         return res;
4108                 }
4109                 else
4110                         return -1;
4111         }
4112 }
4113
4114 #define Py3kExceptionClass_Check(x)     \
4115     (PyType_Check((x)) &&               \
4116      PyType_FastSubclass((PyTypeObject*)(x), Py_TPFLAGS_BASE_EXC_SUBCLASS))
4117
4118 #define CANNOT_CATCH_MSG "catching classes that don't inherit from " \
4119                          "BaseException is not allowed in 3.x"
4120
4121 static PyObject *
4122 cmp_outcome(int op, register PyObject *v, register PyObject *w)
4123 {
4124         int res = 0;
4125         switch (op) {
4126         case PyCmp_IS:
4127                 res = (v == w);
4128                 break;
4129         case PyCmp_IS_NOT:
4130                 res = (v != w);
4131                 break;
4132         case PyCmp_IN:
4133                 res = PySequence_Contains(w, v);
4134                 if (res < 0)
4135                         return NULL;
4136                 break;
4137         case PyCmp_NOT_IN:
4138                 res = PySequence_Contains(w, v);
4139                 if (res < 0)
4140                         return NULL;
4141                 res = !res;
4142                 break;
4143         case PyCmp_EXC_MATCH:
4144                 if (PyTuple_Check(w)) {
4145                         Py_ssize_t i, length;
4146                         length = PyTuple_Size(w);
4147                         for (i = 0; i < length; i += 1) {
4148                                 PyObject *exc = PyTuple_GET_ITEM(w, i);
4149                                 if (PyString_Check(exc)) {
4150                                         int ret_val;
4151                                         ret_val = PyErr_WarnEx(
4152                                                 PyExc_DeprecationWarning,
4153                                                 "catching of string "
4154                                                 "exceptions is deprecated", 1);
4155                                         if (ret_val < 0)
4156                                                 return NULL;
4157                                 }
4158                                 else if (Py_Py3kWarningFlag  &&
4159                                          !PyTuple_Check(exc) &&
4160                                          !Py3kExceptionClass_Check(exc))
4161                                 {
4162                                         int ret_val;
4163                                         ret_val = PyErr_WarnEx(
4164                                                 PyExc_DeprecationWarning,
4165                                                 CANNOT_CATCH_MSG, 1);
4166                                         if (ret_val < 0)
4167                                                 return NULL;
4168                                 }
4169                         }
4170                 }
4171                 else {
4172                         if (PyString_Check(w)) {
4173                                 int ret_val;
4174                                 ret_val = PyErr_WarnEx(
4175                                                 PyExc_DeprecationWarning,
4176                                                 "catching of string "
4177                                                 "exceptions is deprecated", 1);
4178                                 if (ret_val < 0)
4179                                         return NULL;
4180                         }
4181                         else if (Py_Py3kWarningFlag  &&
4182                                  !PyTuple_Check(w) &&
4183                                  !Py3kExceptionClass_Check(w))
4184                         {
4185                                 int ret_val;
4186                                 ret_val = PyErr_WarnEx(
4187                                         PyExc_DeprecationWarning,
4188                                         CANNOT_CATCH_MSG, 1);
4189                                 if (ret_val < 0)
4190                                         return NULL;
4191                         }
4192                 }
4193                 res = PyErr_GivenExceptionMatches(v, w);
4194                 break;
4195         default:
4196                 return PyObject_RichCompare(v, w, op);
4197         }
4198         v = res ? Py_True : Py_False;
4199         Py_INCREF(v);
4200         return v;
4201 }
4202
4203 static PyObject *
4204 import_from(PyObject *v, PyObject *name)
4205 {
4206         PyObject *x;
4207
4208         x = PyObject_GetAttr(v, name);
4209         if (x == NULL && PyErr_ExceptionMatches(PyExc_AttributeError)) {
4210                 PyErr_Format(PyExc_ImportError,
4211                              "cannot import name %.230s",
4212                              PyString_AsString(name));
4213         }
4214         return x;
4215 }
4216
4217 static int
4218 import_all_from(PyObject *locals, PyObject *v)
4219 {
4220         PyObject *all = PyObject_GetAttrString(v, "__all__");
4221         PyObject *dict, *name, *value;
4222         int skip_leading_underscores = 0;
4223         int pos, err;
4224
4225         if (all == NULL) {
4226                 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
4227                         return -1; /* Unexpected error */
4228                 PyErr_Clear();
4229                 dict = PyObject_GetAttrString(v, "__dict__");
4230                 if (dict == NULL) {
4231                         if (!PyErr_ExceptionMatches(PyExc_AttributeError))
4232                                 return -1;
4233                         PyErr_SetString(PyExc_ImportError,
4234                         "from-import-* object has no __dict__ and no __all__");
4235                         return -1;
4236                 }
4237                 all = PyMapping_Keys(dict);
4238                 Py_DECREF(dict);
4239                 if (all == NULL)
4240                         return -1;
4241                 skip_leading_underscores = 1;
4242         }
4243
4244         for (pos = 0, err = 0; ; pos++) {
4245                 name = PySequence_GetItem(all, pos);
4246                 if (name == NULL) {
4247                         if (!PyErr_ExceptionMatches(PyExc_IndexError))
4248                                 err = -1;
4249                         else
4250                                 PyErr_Clear();
4251                         break;
4252                 }
4253                 if (skip_leading_underscores &&
4254                     PyString_Check(name) &&
4255                     PyString_AS_STRING(name)[0] == '_')
4256                 {
4257                         Py_DECREF(name);
4258                         continue;
4259                 }
4260                 value = PyObject_GetAttr(v, name);
4261                 if (value == NULL)
4262                         err = -1;
4263                 else if (PyDict_CheckExact(locals))
4264                         err = PyDict_SetItem(locals, name, value);
4265                 else
4266                         err = PyObject_SetItem(locals, name, value);
4267                 Py_DECREF(name);
4268                 Py_XDECREF(value);
4269                 if (err != 0)
4270                         break;
4271         }
4272         Py_DECREF(all);
4273         return err;
4274 }
4275
4276 static PyObject *
4277 build_class(PyObject *methods, PyObject *bases, PyObject *name)
4278 {
4279         PyObject *metaclass = NULL, *result, *base;
4280
4281         if (PyDict_Check(methods))
4282                 metaclass = PyDict_GetItemString(methods, "__metaclass__");
4283         if (metaclass != NULL)
4284                 Py_INCREF(metaclass);
4285         else if (PyTuple_Check(bases) && PyTuple_GET_SIZE(bases) > 0) {
4286                 base = PyTuple_GET_ITEM(bases, 0);
4287                 metaclass = PyObject_GetAttrString(base, "__class__");
4288                 if (metaclass == NULL) {
4289                         PyErr_Clear();
4290                         metaclass = (PyObject *)base->ob_type;
4291                         Py_INCREF(metaclass);
4292                 }
4293         }
4294         else {
4295                 PyObject *g = PyEval_GetGlobals();
4296                 if (g != NULL && PyDict_Check(g))
4297                         metaclass = PyDict_GetItemString(g, "__metaclass__");
4298                 if (metaclass == NULL)
4299                         metaclass = (PyObject *) &PyClass_Type;
4300                 Py_INCREF(metaclass);
4301         }
4302         result = PyObject_CallFunctionObjArgs(metaclass, name, bases, methods,
4303                                               NULL);
4304         Py_DECREF(metaclass);
4305         if (result == NULL && PyErr_ExceptionMatches(PyExc_TypeError)) {
4306                 /* A type error here likely means that the user passed
4307                    in a base that was not a class (such the random module
4308                    instead of the random.random type).  Help them out with
4309                    by augmenting the error message with more information.*/
4310
4311                 PyObject *ptype, *pvalue, *ptraceback;
4312
4313                 PyErr_Fetch(&ptype, &pvalue, &ptraceback);
4314                 if (PyString_Check(pvalue)) {
4315                         PyObject *newmsg;
4316                         newmsg = PyString_FromFormat(
4317                                 "Error when calling the metaclass bases\n"
4318                                 "    %s",
4319                                 PyString_AS_STRING(pvalue));
4320                         if (newmsg != NULL) {
4321                                 Py_DECREF(pvalue);
4322                                 pvalue = newmsg;
4323                         }
4324                 }
4325                 PyErr_Restore(ptype, pvalue, ptraceback);
4326         }
4327         return result;
4328 }
4329
4330 static int
4331 exec_statement(PyFrameObject *f, PyObject *prog, PyObject *globals,
4332                PyObject *locals)
4333 {
4334         int n;
4335         PyObject *v;
4336         int plain = 0;
4337
4338         if (PyTuple_Check(prog) && globals == Py_None && locals == Py_None &&
4339             ((n = PyTuple_Size(prog)) == 2 || n == 3)) {
4340                 /* Backward compatibility hack */
4341                 globals = PyTuple_GetItem(prog, 1);
4342                 if (n == 3)
4343                         locals = PyTuple_GetItem(prog, 2);
4344                 prog = PyTuple_GetItem(prog, 0);
4345         }
4346         if (globals == Py_None) {
4347                 globals = PyEval_GetGlobals();
4348                 if (locals == Py_None) {
4349                         locals = PyEval_GetLocals();
4350                         plain = 1;
4351                 }
4352                 if (!globals || !locals) {
4353                         PyErr_SetString(PyExc_SystemError,
4354                                         "globals and locals cannot be NULL");
4355                         return -1;
4356                 }
4357         }
4358         else if (locals == Py_None)
4359                 locals = globals;
4360         if (!PyString_Check(prog) &&
4361             !PyUnicode_Check(prog) &&
4362             !PyCode_Check(prog) &&
4363             !PyFile_Check(prog)) {
4364                 PyErr_SetString(PyExc_TypeError,
4365                         "exec: arg 1 must be a string, file, or code object");
4366                 return -1;
4367         }
4368         if (!PyDict_Check(globals)) {
4369                 PyErr_SetString(PyExc_TypeError,
4370                     "exec: arg 2 must be a dictionary or None");
4371                 return -1;
4372         }
4373         if (!PyMapping_Check(locals)) {
4374                 PyErr_SetString(PyExc_TypeError,
4375                     "exec: arg 3 must be a mapping or None");
4376                 return -1;
4377         }
4378         if (PyDict_GetItemString(globals, "__builtins__") == NULL)
4379                 PyDict_SetItemString(globals, "__builtins__", f->f_builtins);
4380         if (PyCode_Check(prog)) {
4381                 if (PyCode_GetNumFree((PyCodeObject *)prog) > 0) {
4382                         PyErr_SetString(PyExc_TypeError,
4383                 "code object passed to exec may not contain free variables");
4384                         return -1;
4385                 }
4386                 v = PyEval_EvalCode((PyCodeObject *) prog, globals, locals);
4387         }
4388         else if (PyFile_Check(prog)) {
4389                 FILE *fp = PyFile_AsFile(prog);
4390                 char *name = PyString_AsString(PyFile_Name(prog));
4391                 PyCompilerFlags cf;
4392                 if (name == NULL)
4393                         return -1;
4394                 cf.cf_flags = 0;
4395                 if (PyEval_MergeCompilerFlags(&cf))
4396                         v = PyRun_FileFlags(fp, name, Py_file_input, globals,
4397                                             locals, &cf);
4398                 else
4399                         v = PyRun_File(fp, name, Py_file_input, globals,
4400                                        locals);
4401         }
4402         else {
4403                 PyObject *tmp = NULL;
4404                 char *str;
4405                 PyCompilerFlags cf;
4406                 cf.cf_flags = 0;
4407 #ifdef Py_USING_UNICODE
4408                 if (PyUnicode_Check(prog)) {
4409                         tmp = PyUnicode_AsUTF8String(prog);
4410                         if (tmp == NULL)
4411                                 return -1;
4412                         prog = tmp;
4413                         cf.cf_flags |= PyCF_SOURCE_IS_UTF8;
4414                 }
4415 #endif
4416                 if (PyString_AsStringAndSize(prog, &str, NULL))
4417                         return -1;
4418                 if (PyEval_MergeCompilerFlags(&cf))
4419                         v = PyRun_StringFlags(str, Py_file_input, globals,
4420                                               locals, &cf);
4421                 else
4422                         v = PyRun_String(str, Py_file_input, globals, locals);
4423                 Py_XDECREF(tmp);
4424         }
4425         if (plain)
4426                 PyFrame_LocalsToFast(f, 0);
4427         if (v == NULL)
4428                 return -1;
4429         Py_DECREF(v);
4430         return 0;
4431 }
4432
4433 static void
4434 format_exc_check_arg(PyObject *exc, char *format_str, PyObject *obj)
4435 {
4436         char *obj_str;
4437
4438         if (!obj)
4439                 return;
4440
4441         obj_str = PyString_AsString(obj);
4442         if (!obj_str)
4443                 return;
4444
4445         PyErr_Format(exc, format_str, obj_str);
4446 }
4447
4448 static PyObject *
4449 string_concatenate(PyObject *v, PyObject *w,
4450                    PyFrameObject *f, unsigned char *next_instr)
4451 {
4452         /* This function implements 'variable += expr' when both arguments
4453            are strings. */
4454         Py_ssize_t v_len = PyString_GET_SIZE(v);
4455         Py_ssize_t w_len = PyString_GET_SIZE(w);
4456         Py_ssize_t new_len = v_len + w_len;
4457         if (new_len < 0) {
4458                 PyErr_SetString(PyExc_OverflowError,
4459                                 "strings are too large to concat");
4460                 return NULL;
4461         }
4462
4463         if (v->ob_refcnt == 2) {
4464                 /* In the common case, there are 2 references to the value
4465                  * stored in 'variable' when the += is performed: one on the
4466                  * value stack (in 'v') and one still stored in the
4467                  * 'variable'.  We try to delete the variable now to reduce
4468                  * the refcnt to 1.
4469                  */
4470                 switch (*next_instr) {
4471                 case STORE_FAST:
4472                 {
4473                         int oparg = PEEKARG();
4474                         PyObject **fastlocals = f->f_localsplus;
4475                         if (GETLOCAL(oparg) == v)
4476                                 SETLOCAL(oparg, NULL);
4477                         break;
4478                 }
4479                 case STORE_DEREF:
4480                 {
4481                         PyObject **freevars = (f->f_localsplus +
4482                                                f->f_code->co_nlocals);
4483                         PyObject *c = freevars[PEEKARG()];
4484                         if (PyCell_GET(c) == v)
4485                                 PyCell_Set(c, NULL);
4486                         break;
4487                 }
4488                 case STORE_NAME:
4489                 {
4490                         PyObject *names = f->f_code->co_names;
4491                         PyObject *name = GETITEM(names, PEEKARG());
4492                         PyObject *locals = f->f_locals;
4493                         if (PyDict_CheckExact(locals) &&
4494                             PyDict_GetItem(locals, name) == v) {
4495                                 if (PyDict_DelItem(locals, name) != 0) {
4496                                         PyErr_Clear();
4497                                 }
4498                         }
4499                         break;
4500                 }
4501                 }
4502         }
4503
4504         if (v->ob_refcnt == 1 && !PyString_CHECK_INTERNED(v)) {
4505                 /* Now we own the last reference to 'v', so we can resize it
4506                  * in-place.
4507                  */
4508                 if (_PyString_Resize(&v, new_len) != 0) {
4509                         /* XXX if _PyString_Resize() fails, 'v' has been
4510                          * deallocated so it cannot be put back into
4511                          * 'variable'.  The MemoryError is raised when there
4512                          * is no value in 'variable', which might (very
4513                          * remotely) be a cause of incompatibilities.
4514                          */
4515                         return NULL;
4516                 }
4517                 /* copy 'w' into the newly allocated area of 'v' */
4518                 memcpy(PyString_AS_STRING(v) + v_len,
4519                        PyString_AS_STRING(w), w_len);
4520                 return v;
4521         }
4522         else {
4523                 /* When in-place resizing is not an option. */
4524                 PyString_Concat(&v, w);
4525                 return v;
4526         }
4527 }
4528
4529 #ifdef DYNAMIC_EXECUTION_PROFILE
4530
4531 static PyObject *
4532 getarray(long a[256])
4533 {
4534         int i;
4535         PyObject *l = PyList_New(256);
4536         if (l == NULL) return NULL;
4537         for (i = 0; i < 256; i++) {
4538                 PyObject *x = PyInt_FromLong(a[i]);
4539                 if (x == NULL) {
4540                         Py_DECREF(l);
4541                         return NULL;
4542                 }
4543                 PyList_SetItem(l, i, x);
4544         }
4545         for (i = 0; i < 256; i++)
4546                 a[i] = 0;
4547         return l;
4548 }
4549
4550 PyObject *
4551 _Py_GetDXProfile(PyObject *self, PyObject *args)
4552 {
4553 #ifndef DXPAIRS
4554         return getarray(dxp);
4555 #else
4556         int i;
4557         PyObject *l = PyList_New(257);
4558         if (l == NULL) return NULL;
4559         for (i = 0; i < 257; i++) {
4560                 PyObject *x = getarray(dxpairs[i]);
4561                 if (x == NULL) {
4562                         Py_DECREF(l);
4563                         return NULL;
4564                 }
4565                 PyList_SetItem(l, i, x);
4566         }
4567         return l;
4568 #endif
4569 }
4570
4571 #endif