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