Line data Source code
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
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 :
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 *
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 *
223 0 : PyEval_GetCallStats(PyObject *self)
224 : {
225 0 : Py_INCREF(Py_None);
226 0 : 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
243 : PyEval_ThreadsInitialized(void)
244 : {
245 : return interpreter_lock != 0;
246 : }
247 :
248 : 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
259 : PyEval_AcquireLock(void)
260 : {
261 : PyThread_acquire_lock(interpreter_lock, 1);
262 : }
263 :
264 : void
265 : PyEval_ReleaseLock(void)
266 : {
267 : PyThread_release_lock(interpreter_lock);
268 : }
269 :
270 : void
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
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
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 *
339 0 : PyEval_SaveThread(void)
340 : {
341 0 : PyThreadState *tstate = PyThreadState_Swap(NULL);
342 0 : if (tstate == NULL)
343 0 : Py_FatalError("PyEval_SaveThread: NULL tstate");
344 : #ifdef WITH_THREAD
345 : if (interpreter_lock)
346 : PyThread_release_lock(interpreter_lock);
347 : #endif
348 0 : return tstate;
349 : }
350 :
351 : void
352 0 : PyEval_RestoreThread(PyThreadState *tstate)
353 : {
354 0 : if (tstate == NULL)
355 0 : 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 0 : PyThreadState_Swap(tstate);
364 0 : }
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
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
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
535 0 : Py_AddPendingCall(int (*func)(void *), void *arg)
536 : {
537 : static volatile int busy = 0;
538 : int i, j;
539 : /* XXX Begin critical section */
540 0 : if (busy)
541 0 : return -1;
542 0 : busy = 1;
543 0 : i = pendinglast;
544 0 : j = (i + 1) % NPENDINGCALLS;
545 0 : if (j == pendingfirst) {
546 0 : busy = 0;
547 0 : return -1; /* Queue full */
548 : }
549 0 : pendingcalls[i].func = func;
550 0 : pendingcalls[i].arg = arg;
551 0 : pendinglast = j;
552 :
553 0 : _Py_Ticker = 0;
554 0 : pendingcalls_to_do = 1; /* Signal main loop */
555 0 : busy = 0;
556 : /* XXX End critical section */
557 0 : return 0;
558 : }
559 :
560 : int
561 3 : Py_MakePendingCalls(void)
562 : {
563 : static int busy = 0;
564 3 : if (busy)
565 0 : return 0;
566 3 : busy = 1;
567 3 : pendingcalls_to_do = 0;
568 : for (;;) {
569 : int i;
570 : int (*func)(void *);
571 : void *arg;
572 3 : i = pendingfirst;
573 3 : if (i == pendinglast)
574 3 : break; /* Queue empty */
575 0 : func = pendingcalls[i].func;
576 0 : arg = pendingcalls[i].arg;
577 0 : pendingfirst = (i + 1) % NPENDINGCALLS;
578 0 : if (func(arg) < 0) {
579 0 : busy = 0;
580 0 : pendingcalls_to_do = 1; /* We're not done yet */
581 0 : return -1;
582 : }
583 0 : }
584 3 : busy = 0;
585 3 : 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
600 9893 : Py_GetRecursionLimit(void)
601 : {
602 9893 : return recursion_limit;
603 : }
604 :
605 : void
606 19786 : Py_SetRecursionLimit(int new_limit)
607 : {
608 19786 : recursion_limit = new_limit;
609 19786 : _Py_CheckRecursionLimit = recursion_limit;
610 19786 : }
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
618 0 : _Py_CheckRecursiveCall(const char *where)
619 : {
620 0 : 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 0 : if (tstate->recursion_depth > recursion_limit) {
630 0 : --tstate->recursion_depth;
631 0 : PyErr_Format(PyExc_RuntimeError,
632 : "maximum recursion depth exceeded%s",
633 : where);
634 0 : return -1;
635 : }
636 0 : _Py_CheckRecursionLimit = recursion_limit;
637 0 : 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 *
667 294 : PyEval_EvalCode(PyCodeObject *co, PyObject *globals, PyObject *locals)
668 : {
669 294 : 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 *
681 0 : 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 0 : return PyEval_EvalFrameEx(f, 0);
686 : }
687 :
688 : PyObject *
689 91550 : 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 91550 : register PyObject *stream = NULL; /* for PRINT opcodes */
800 : register PyObject **fastlocals, **freevars;
801 91550 : PyObject *retval = NULL; /* Return value */
802 91550 : 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 91550 : 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 91550 : if (f == NULL)
970 0 : return NULL;
971 :
972 : /* push frame */
973 91550 : if (Py_EnterRecursiveCall(""))
974 0 : return NULL;
975 :
976 91550 : tstate->frame = f;
977 :
978 91550 : if (tstate->use_tracing) {
979 0 : 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 0 : if (call_trace_protected(tstate->c_tracefunc,
994 : tstate->c_traceobj,
995 : f, PyTrace_CALL, Py_None)) {
996 : /* Trace function raised an error */
997 0 : goto exit_eval_frame;
998 : }
999 : }
1000 0 : 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 0 : if (call_trace_protected(tstate->c_profilefunc,
1004 : tstate->c_profileobj,
1005 : f, PyTrace_CALL, Py_None)) {
1006 : /* Profile function raised an error */
1007 0 : goto exit_eval_frame;
1008 : }
1009 : }
1010 : }
1011 :
1012 91550 : co = f->f_code;
1013 91550 : names = co->co_names;
1014 91550 : consts = co->co_consts;
1015 91550 : fastlocals = f->f_localsplus;
1016 91550 : freevars = f->f_localsplus + co->co_nlocals;
1017 91550 : 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 91550 : next_instr = first_instr + f->f_lasti + 1;
1036 91550 : stack_pointer = f->f_stacktop;
1037 : assert(stack_pointer != NULL);
1038 91550 : 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 91550 : why = WHY_NOT;
1048 91550 : err = 0;
1049 91550 : x = Py_None; /* Not a reference, just anything non-NULL */
1050 91550 : w = NULL;
1051 :
1052 91550 : if (throwflag) { /* support for generator.throw() */
1053 3 : why = WHY_EXCEPTION;
1054 3 : 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 121955 : if (--_Py_Ticker < 0) {
1087 15687 : if (*next_instr == SETUP_FINALLY) {
1088 : /* Make the last opcode before
1089 : a try: finally: block uninterruptible. */
1090 0 : goto fast_next_opcode;
1091 : }
1092 15687 : _Py_Ticker = _Py_CheckInterval;
1093 15687 : tstate->tick_counter++;
1094 : #ifdef WITH_TSC
1095 : ticked = 1;
1096 : #endif
1097 15687 : if (pendingcalls_to_do) {
1098 0 : if (Py_MakePendingCalls() < 0) {
1099 0 : why = WHY_EXCEPTION;
1100 0 : goto on_error;
1101 : }
1102 0 : 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 0 : _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 121955 : f->f_lasti = INSTR_OFFSET();
1140 :
1141 : /* line-by-line tracing support */
1142 :
1143 121955 : if (_Py_TracingPossible &&
1144 0 : tstate->c_tracefunc != NULL && !tstate->tracing) {
1145 : /* see maybe_call_line_trace
1146 : for expository comments */
1147 0 : f->f_stacktop = stack_pointer;
1148 :
1149 0 : 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 0 : JUMPTO(f->f_lasti);
1155 0 : if (f->f_stacktop != NULL) {
1156 0 : stack_pointer = f->f_stacktop;
1157 0 : f->f_stacktop = NULL;
1158 : }
1159 0 : if (err) {
1160 : /* trace function raised an exception */
1161 0 : goto on_error;
1162 : }
1163 : }
1164 :
1165 : /* Extract opcode and argument */
1166 :
1167 121955 : opcode = NEXTOP();
1168 121955 : oparg = 0; /* allows oparg to be stored in a register because
1169 : it doesn't have to be remembered across a full loop */
1170 121955 : if (HAS_ARG(opcode))
1171 112761 : 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 121955 : 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 0 : TARGET_NOARG(NOP)
1209 : {
1210 0 : FAST_DISPATCH();
1211 : }
1212 :
1213 763610 : TARGET(LOAD_FAST)
1214 : {
1215 823823 : x = GETLOCAL(oparg);
1216 823823 : if (x != NULL) {
1217 823823 : Py_INCREF(x);
1218 823823 : PUSH(x);
1219 823823 : FAST_DISPATCH();
1220 : }
1221 0 : format_exc_check_arg(PyExc_UnboundLocalError,
1222 : UNBOUNDLOCAL_ERROR_MSG,
1223 : PyTuple_GetItem(co->co_varnames, oparg));
1224 0 : break;
1225 : }
1226 :
1227 255680 : TARGET(LOAD_CONST)
1228 : {
1229 258621 : x = GETITEM(consts, oparg);
1230 258621 : Py_INCREF(x);
1231 258621 : PUSH(x);
1232 258621 : FAST_DISPATCH();
1233 : }
1234 :
1235 : PREDICTED_WITH_ARG(STORE_FAST);
1236 233512 : TARGET(STORE_FAST)
1237 : {
1238 235665 : v = POP();
1239 235665 : SETLOCAL(oparg, v);
1240 235665 : FAST_DISPATCH();
1241 : }
1242 :
1243 64086 : TARGET_NOARG(POP_TOP)
1244 : {
1245 70823 : v = POP();
1246 70823 : Py_DECREF(v);
1247 70823 : FAST_DISPATCH();
1248 : }
1249 :
1250 1909 : TARGET_NOARG(ROT_TWO)
1251 : {
1252 1927 : v = TOP();
1253 1927 : w = SECOND();
1254 1927 : SET_TOP(w);
1255 1927 : SET_SECOND(v);
1256 1927 : FAST_DISPATCH();
1257 : }
1258 :
1259 1641 : TARGET_NOARG(ROT_THREE)
1260 : {
1261 1641 : v = TOP();
1262 1641 : w = SECOND();
1263 1641 : x = THIRD();
1264 1641 : SET_TOP(w);
1265 1641 : SET_SECOND(x);
1266 1641 : SET_THIRD(v);
1267 1641 : FAST_DISPATCH();
1268 : }
1269 :
1270 0 : TARGET_NOARG(ROT_FOUR)
1271 : {
1272 0 : u = TOP();
1273 0 : v = SECOND();
1274 0 : w = THIRD();
1275 0 : x = FOURTH();
1276 0 : SET_TOP(v);
1277 0 : SET_SECOND(w);
1278 0 : SET_THIRD(x);
1279 0 : SET_FOURTH(u);
1280 0 : FAST_DISPATCH();
1281 : }
1282 :
1283 :
1284 4564 : TARGET_NOARG(DUP_TOP)
1285 : {
1286 5536 : v = TOP();
1287 5536 : Py_INCREF(v);
1288 5536 : PUSH(v);
1289 5536 : FAST_DISPATCH();
1290 : }
1291 :
1292 :
1293 18 : TARGET(DUP_TOPX)
1294 : {
1295 18 : if (oparg == 2) {
1296 18 : x = TOP();
1297 18 : Py_INCREF(x);
1298 18 : w = SECOND();
1299 18 : Py_INCREF(w);
1300 18 : STACKADJ(2);
1301 18 : SET_TOP(x);
1302 18 : SET_SECOND(w);
1303 18 : FAST_DISPATCH();
1304 0 : } else if (oparg == 3) {
1305 0 : x = TOP();
1306 0 : Py_INCREF(x);
1307 0 : w = SECOND();
1308 0 : Py_INCREF(w);
1309 0 : v = THIRD();
1310 0 : Py_INCREF(v);
1311 0 : STACKADJ(3);
1312 0 : SET_TOP(x);
1313 0 : SET_SECOND(w);
1314 0 : SET_THIRD(v);
1315 0 : FAST_DISPATCH();
1316 : }
1317 0 : Py_FatalError("invalid argument to DUP_TOPX"
1318 : " (bytecode corruption?)");
1319 : /* Never returns, so don't bother to set why. */
1320 0 : break;
1321 : }
1322 :
1323 0 : TARGET_NOARG(UNARY_POSITIVE)
1324 : {
1325 0 : v = TOP();
1326 0 : x = PyNumber_Positive(v);
1327 0 : Py_DECREF(v);
1328 0 : SET_TOP(x);
1329 0 : if (x != NULL) DISPATCH();
1330 0 : break;
1331 : }
1332 :
1333 204 : TARGET_NOARG( UNARY_NEGATIVE)
1334 : {
1335 204 : v = TOP();
1336 204 : x = PyNumber_Negative(v);
1337 204 : Py_DECREF(v);
1338 204 : SET_TOP(x);
1339 204 : if (x != NULL) DISPATCH();
1340 0 : break;
1341 : }
1342 :
1343 3249 : TARGET_NOARG(UNARY_NOT)
1344 : {
1345 3270 : v = TOP();
1346 3270 : err = PyObject_IsTrue(v);
1347 3270 : Py_DECREF(v);
1348 3270 : if (err == 0) {
1349 1553 : Py_INCREF(Py_True);
1350 1553 : SET_TOP(Py_True);
1351 1553 : DISPATCH();
1352 : }
1353 1717 : else if (err > 0) {
1354 1717 : Py_INCREF(Py_False);
1355 1717 : SET_TOP(Py_False);
1356 1717 : err = 0;
1357 1717 : DISPATCH();
1358 : }
1359 0 : STACKADJ(-1);
1360 0 : break;
1361 : }
1362 :
1363 0 : TARGET_NOARG(UNARY_CONVERT)
1364 : {
1365 0 : v = TOP();
1366 0 : x = PyObject_Repr(v);
1367 0 : Py_DECREF(v);
1368 0 : SET_TOP(x);
1369 0 : if (x != NULL) DISPATCH();
1370 0 : break;
1371 : }
1372 :
1373 90 : TARGET_NOARG(UNARY_INVERT)
1374 : {
1375 90 : v = TOP();
1376 90 : x = PyNumber_Invert(v);
1377 90 : Py_DECREF(v);
1378 90 : SET_TOP(x);
1379 90 : if (x != NULL) DISPATCH();
1380 0 : break;
1381 : }
1382 :
1383 3 : TARGET_NOARG(BINARY_POWER)
1384 : {
1385 3 : w = POP();
1386 3 : v = TOP();
1387 3 : x = PyNumber_Power(v, w, Py_None);
1388 3 : Py_DECREF(v);
1389 3 : Py_DECREF(w);
1390 3 : SET_TOP(x);
1391 3 : if (x != NULL) DISPATCH();
1392 0 : break;
1393 : }
1394 :
1395 3009 : TARGET_NOARG(BINARY_MULTIPLY)
1396 : {
1397 3048 : w = POP();
1398 3048 : v = TOP();
1399 3048 : x = PyNumber_Multiply(v, w);
1400 3048 : Py_DECREF(v);
1401 3048 : Py_DECREF(w);
1402 3048 : SET_TOP(x);
1403 3048 : if(x!=NULL) DISPATCH();
1404 0 : break;
1405 : }
1406 :
1407 0 : TARGET_NOARG(BINARY_DIVIDE)
1408 : {
1409 0 : if (!_Py_QnewFlag) {
1410 0 : w = POP();
1411 0 : v = TOP();
1412 0 : x = PyNumber_Divide(v, w);
1413 0 : Py_DECREF(v);
1414 0 : Py_DECREF(w);
1415 0 : SET_TOP(x);
1416 0 : if (x != NULL) DISPATCH();
1417 0 : break;
1418 : }
1419 : }
1420 : /* -Qnew is in effect: fall through to BINARY_TRUE_DIVIDE */
1421 3 : TARGET_NOARG(BINARY_TRUE_DIVIDE)
1422 : {
1423 3 : w = POP();
1424 3 : v = TOP();
1425 3 : x = PyNumber_TrueDivide(v, w);
1426 3 : Py_DECREF(v);
1427 3 : Py_DECREF(w);
1428 3 : SET_TOP(x);
1429 3 : if (x != NULL) DISPATCH();
1430 0 : break;
1431 : }
1432 :
1433 0 : TARGET_NOARG(BINARY_FLOOR_DIVIDE)
1434 : {
1435 0 : w = POP();
1436 0 : v = TOP();
1437 0 : x = PyNumber_FloorDivide(v, w);
1438 0 : Py_DECREF(v);
1439 0 : Py_DECREF(w);
1440 0 : SET_TOP(x);
1441 0 : if (x != NULL) DISPATCH();
1442 0 : break;
1443 : }
1444 :
1445 1530 : TARGET_NOARG(BINARY_MODULO)
1446 : {
1447 1542 : w = POP();
1448 1542 : v = TOP();
1449 1542 : if (PyString_CheckExact(v))
1450 1542 : x = PyString_Format(v, w);
1451 : else
1452 0 : x = PyNumber_Remainder(v, w);
1453 1542 : Py_DECREF(v);
1454 1542 : Py_DECREF(w);
1455 1542 : SET_TOP(x);
1456 1542 : if (x != NULL) DISPATCH();
1457 0 : break;
1458 : }
1459 :
1460 36939 : TARGET_NOARG(BINARY_ADD)
1461 : {
1462 37038 : w = POP();
1463 37038 : v = TOP();
1464 63621 : if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
1465 : /* INLINE: int + int */
1466 : register long a, b, i;
1467 26583 : a = PyInt_AS_LONG(v);
1468 26583 : b = PyInt_AS_LONG(w);
1469 : /* cast to avoid undefined behaviour
1470 : on overflow */
1471 26583 : i = (long)((unsigned long)a + b);
1472 26583 : if ((i^a) < 0 && (i^b) < 0)
1473 0 : goto slow_add;
1474 26583 : x = PyInt_FromLong(i);
1475 : }
1476 17142 : else if (PyString_CheckExact(v) &&
1477 6687 : PyString_CheckExact(w)) {
1478 6687 : x = string_concatenate(v, w, f, next_instr);
1479 : /* string_concatenate consumed the ref to v */
1480 6687 : goto skip_decref_vx;
1481 : }
1482 : else {
1483 : slow_add:
1484 3768 : x = PyNumber_Add(v, w);
1485 : }
1486 30351 : Py_DECREF(v);
1487 : skip_decref_vx:
1488 37038 : Py_DECREF(w);
1489 37038 : SET_TOP(x);
1490 37038 : if (x != NULL) DISPATCH();
1491 0 : break;
1492 : }
1493 :
1494 9514 : TARGET_NOARG(BINARY_SUBTRACT)
1495 : {
1496 9514 : w = POP();
1497 9514 : v = TOP();
1498 16919 : if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
1499 : /* INLINE: int - int */
1500 : register long a, b, i;
1501 7405 : a = PyInt_AS_LONG(v);
1502 7405 : b = PyInt_AS_LONG(w);
1503 : /* cast to avoid undefined behaviour
1504 : on overflow */
1505 7405 : i = (long)((unsigned long)a - b);
1506 7405 : if ((i^a) < 0 && (i^~b) < 0)
1507 0 : goto slow_sub;
1508 7405 : x = PyInt_FromLong(i);
1509 : }
1510 : else {
1511 : slow_sub:
1512 2109 : x = PyNumber_Subtract(v, w);
1513 : }
1514 9514 : Py_DECREF(v);
1515 9514 : Py_DECREF(w);
1516 9514 : SET_TOP(x);
1517 9514 : if (x != NULL) DISPATCH();
1518 0 : break;
1519 : }
1520 :
1521 76483 : TARGET_NOARG(BINARY_SUBSCR)
1522 : {
1523 76642 : w = POP();
1524 76642 : v = TOP();
1525 88433 : if (PyList_CheckExact(v) && PyInt_CheckExact(w)) {
1526 : /* INLINE: list[int] */
1527 12949 : Py_ssize_t i = PyInt_AsSsize_t(w);
1528 12949 : if (i < 0)
1529 34 : i += PyList_GET_SIZE(v);
1530 12949 : if (i >= 0 && i < PyList_GET_SIZE(v)) {
1531 11791 : x = PyList_GET_ITEM(v, i);
1532 11791 : Py_INCREF(x);
1533 : }
1534 : else
1535 : goto slow_get;
1536 : }
1537 : else
1538 : slow_get:
1539 64851 : x = PyObject_GetItem(v, w);
1540 76642 : Py_DECREF(v);
1541 76642 : Py_DECREF(w);
1542 76642 : SET_TOP(x);
1543 76642 : if (x != NULL) DISPATCH();
1544 2007 : break;
1545 : }
1546 :
1547 6 : TARGET_NOARG(BINARY_LSHIFT)
1548 : {
1549 6 : w = POP();
1550 6 : v = TOP();
1551 6 : x = PyNumber_Lshift(v, w);
1552 6 : Py_DECREF(v);
1553 6 : Py_DECREF(w);
1554 6 : SET_TOP(x);
1555 6 : if (x != NULL) DISPATCH();
1556 0 : break;
1557 : }
1558 :
1559 0 : TARGET_NOARG(BINARY_RSHIFT)
1560 : {
1561 0 : w = POP();
1562 0 : v = TOP();
1563 0 : x = PyNumber_Rshift(v, w);
1564 0 : Py_DECREF(v);
1565 0 : Py_DECREF(w);
1566 0 : SET_TOP(x);
1567 0 : if (x != NULL) DISPATCH();
1568 0 : break;
1569 : }
1570 :
1571 17385 : TARGET_NOARG(BINARY_AND)
1572 : {
1573 17580 : w = POP();
1574 17580 : v = TOP();
1575 17580 : x = PyNumber_And(v, w);
1576 17580 : Py_DECREF(v);
1577 17580 : Py_DECREF(w);
1578 17580 : SET_TOP(x);
1579 17580 : if (x != NULL) DISPATCH();
1580 0 : break;
1581 : }
1582 :
1583 0 : TARGET_NOARG(BINARY_XOR)
1584 : {
1585 0 : w = POP();
1586 0 : v = TOP();
1587 0 : x = PyNumber_Xor(v, w);
1588 0 : Py_DECREF(v);
1589 0 : Py_DECREF(w);
1590 0 : SET_TOP(x);
1591 0 : if (x != NULL) DISPATCH();
1592 0 : break;
1593 : }
1594 :
1595 1707 : TARGET_NOARG(BINARY_OR)
1596 : {
1597 1722 : w = POP();
1598 1722 : v = TOP();
1599 1722 : x = PyNumber_Or(v, w);
1600 1722 : Py_DECREF(v);
1601 1722 : Py_DECREF(w);
1602 1722 : SET_TOP(x);
1603 1722 : if (x != NULL) DISPATCH();
1604 0 : break;
1605 : }
1606 :
1607 2860 : TARGET(LIST_APPEND)
1608 : {
1609 2872 : w = POP();
1610 2872 : v = PEEK(oparg);
1611 2872 : err = PyList_Append(v, w);
1612 2872 : Py_DECREF(w);
1613 2872 : if (err == 0) {
1614 : PREDICT(JUMP_ABSOLUTE);
1615 2872 : DISPATCH();
1616 : }
1617 0 : break;
1618 : }
1619 :
1620 0 : TARGET(SET_ADD)
1621 : {
1622 0 : w = POP();
1623 0 : v = stack_pointer[-oparg];
1624 0 : err = PySet_Add(v, w);
1625 0 : Py_DECREF(w);
1626 0 : if (err == 0) {
1627 : PREDICT(JUMP_ABSOLUTE);
1628 0 : DISPATCH();
1629 : }
1630 0 : break;
1631 : }
1632 :
1633 0 : TARGET_NOARG(INPLACE_POWER)
1634 : {
1635 0 : w = POP();
1636 0 : v = TOP();
1637 0 : x = PyNumber_InPlacePower(v, w, Py_None);
1638 0 : Py_DECREF(v);
1639 0 : Py_DECREF(w);
1640 0 : SET_TOP(x);
1641 0 : if (x != NULL) DISPATCH();
1642 0 : break;
1643 : }
1644 :
1645 0 : TARGET_NOARG(INPLACE_MULTIPLY)
1646 : {
1647 0 : w = POP();
1648 0 : v = TOP();
1649 0 : x = PyNumber_InPlaceMultiply(v, w);
1650 0 : Py_DECREF(v);
1651 0 : Py_DECREF(w);
1652 0 : SET_TOP(x);
1653 0 : if (x != NULL) DISPATCH();
1654 0 : break;
1655 : }
1656 :
1657 0 : TARGET_NOARG(INPLACE_DIVIDE)
1658 : {
1659 0 : if (!_Py_QnewFlag) {
1660 0 : w = POP();
1661 0 : v = TOP();
1662 0 : x = PyNumber_InPlaceDivide(v, w);
1663 0 : Py_DECREF(v);
1664 0 : Py_DECREF(w);
1665 0 : SET_TOP(x);
1666 0 : if (x != NULL) DISPATCH();
1667 0 : break;
1668 : }
1669 : }
1670 : /* -Qnew is in effect: fall through to
1671 : INPLACE_TRUE_DIVIDE */
1672 0 : TARGET_NOARG(INPLACE_TRUE_DIVIDE)
1673 : {
1674 0 : w = POP();
1675 0 : v = TOP();
1676 0 : x = PyNumber_InPlaceTrueDivide(v, w);
1677 0 : Py_DECREF(v);
1678 0 : Py_DECREF(w);
1679 0 : SET_TOP(x);
1680 0 : if (x != NULL) DISPATCH();
1681 0 : break;
1682 : }
1683 :
1684 0 : TARGET_NOARG(INPLACE_FLOOR_DIVIDE)
1685 : {
1686 0 : w = POP();
1687 0 : v = TOP();
1688 0 : x = PyNumber_InPlaceFloorDivide(v, w);
1689 0 : Py_DECREF(v);
1690 0 : Py_DECREF(w);
1691 0 : SET_TOP(x);
1692 0 : if (x != NULL) DISPATCH();
1693 0 : break;
1694 : }
1695 :
1696 0 : TARGET_NOARG(INPLACE_MODULO)
1697 : {
1698 0 : w = POP();
1699 0 : v = TOP();
1700 0 : x = PyNumber_InPlaceRemainder(v, w);
1701 0 : Py_DECREF(v);
1702 0 : Py_DECREF(w);
1703 0 : SET_TOP(x);
1704 0 : if (x != NULL) DISPATCH();
1705 0 : break;
1706 : }
1707 :
1708 2057 : TARGET_NOARG(INPLACE_ADD)
1709 : {
1710 2063 : w = POP();
1711 2063 : v = TOP();
1712 3132 : if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
1713 : /* INLINE: int + int */
1714 : register long a, b, i;
1715 1069 : a = PyInt_AS_LONG(v);
1716 1069 : b = PyInt_AS_LONG(w);
1717 1069 : i = a + b;
1718 1069 : if ((i^a) < 0 && (i^b) < 0)
1719 0 : goto slow_iadd;
1720 1069 : x = PyInt_FromLong(i);
1721 : }
1722 1340 : else if (PyString_CheckExact(v) &&
1723 346 : PyString_CheckExact(w)) {
1724 346 : x = string_concatenate(v, w, f, next_instr);
1725 : /* string_concatenate consumed the ref to v */
1726 346 : goto skip_decref_v;
1727 : }
1728 : else {
1729 : slow_iadd:
1730 648 : x = PyNumber_InPlaceAdd(v, w);
1731 : }
1732 1717 : Py_DECREF(v);
1733 : skip_decref_v:
1734 2063 : Py_DECREF(w);
1735 2063 : SET_TOP(x);
1736 2063 : if (x != NULL) DISPATCH();
1737 0 : break;
1738 : }
1739 :
1740 6 : TARGET_NOARG(INPLACE_SUBTRACT)
1741 : {
1742 6 : w = POP();
1743 6 : v = TOP();
1744 12 : if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
1745 : /* INLINE: int - int */
1746 : register long a, b, i;
1747 6 : a = PyInt_AS_LONG(v);
1748 6 : b = PyInt_AS_LONG(w);
1749 6 : i = a - b;
1750 6 : if ((i^a) < 0 && (i^~b) < 0)
1751 0 : goto slow_isub;
1752 6 : x = PyInt_FromLong(i);
1753 : }
1754 : else {
1755 : slow_isub:
1756 0 : x = PyNumber_InPlaceSubtract(v, w);
1757 : }
1758 6 : Py_DECREF(v);
1759 6 : Py_DECREF(w);
1760 6 : SET_TOP(x);
1761 6 : if (x != NULL) DISPATCH();
1762 0 : break;
1763 : }
1764 :
1765 0 : TARGET_NOARG(INPLACE_LSHIFT)
1766 : {
1767 0 : w = POP();
1768 0 : v = TOP();
1769 0 : x = PyNumber_InPlaceLshift(v, w);
1770 0 : Py_DECREF(v);
1771 0 : Py_DECREF(w);
1772 0 : SET_TOP(x);
1773 0 : if (x != NULL) DISPATCH();
1774 0 : break;
1775 : }
1776 :
1777 0 : TARGET_NOARG(INPLACE_RSHIFT)
1778 : {
1779 0 : w = POP();
1780 0 : v = TOP();
1781 0 : x = PyNumber_InPlaceRshift(v, w);
1782 0 : Py_DECREF(v);
1783 0 : Py_DECREF(w);
1784 0 : SET_TOP(x);
1785 0 : if (x != NULL) DISPATCH();
1786 0 : break;
1787 : }
1788 :
1789 0 : TARGET_NOARG(INPLACE_AND)
1790 : {
1791 0 : w = POP();
1792 0 : v = TOP();
1793 0 : x = PyNumber_InPlaceAnd(v, w);
1794 0 : Py_DECREF(v);
1795 0 : Py_DECREF(w);
1796 0 : SET_TOP(x);
1797 0 : if (x != NULL) DISPATCH();
1798 0 : break;
1799 : }
1800 :
1801 0 : TARGET_NOARG(INPLACE_XOR)
1802 : {
1803 0 : w = POP();
1804 0 : v = TOP();
1805 0 : x = PyNumber_InPlaceXor(v, w);
1806 0 : Py_DECREF(v);
1807 0 : Py_DECREF(w);
1808 0 : SET_TOP(x);
1809 0 : if (x != NULL) DISPATCH();
1810 0 : break;
1811 : }
1812 :
1813 39 : TARGET_NOARG(INPLACE_OR)
1814 : {
1815 39 : w = POP();
1816 39 : v = TOP();
1817 39 : x = PyNumber_InPlaceOr(v, w);
1818 39 : Py_DECREF(v);
1819 39 : Py_DECREF(w);
1820 39 : SET_TOP(x);
1821 39 : if (x != NULL) DISPATCH();
1822 0 : break;
1823 : }
1824 :
1825 :
1826 :
1827 519 : TARGET_WITH_IMPL_NOARG(SLICE, _slice)
1828 1359 : TARGET_WITH_IMPL_NOARG(SLICE_1, _slice)
1829 2664 : TARGET_WITH_IMPL_NOARG(SLICE_2, _slice)
1830 2652 : TARGET_WITH_IMPL_NOARG(SLICE_3, _slice)
1831 : _slice:
1832 : {
1833 7194 : if ((opcode-SLICE) & 2)
1834 5316 : w = POP();
1835 : else
1836 1878 : w = NULL;
1837 7194 : if ((opcode-SLICE) & 1)
1838 4011 : v = POP();
1839 : else
1840 3183 : v = NULL;
1841 7194 : u = TOP();
1842 7194 : x = apply_slice(u, v, w);
1843 7194 : Py_DECREF(u);
1844 7194 : Py_XDECREF(v);
1845 7194 : Py_XDECREF(w);
1846 7194 : SET_TOP(x);
1847 7194 : if (x != NULL) DISPATCH();
1848 0 : break;
1849 : }
1850 :
1851 :
1852 0 : TARGET_WITH_IMPL_NOARG(STORE_SLICE, _store_slice)
1853 0 : TARGET_WITH_IMPL_NOARG(STORE_SLICE_1, _store_slice)
1854 0 : TARGET_WITH_IMPL_NOARG(STORE_SLICE_2, _store_slice)
1855 0 : TARGET_WITH_IMPL_NOARG(STORE_SLICE_3, _store_slice)
1856 : _store_slice:
1857 : {
1858 0 : if ((opcode-STORE_SLICE) & 2)
1859 0 : w = POP();
1860 : else
1861 0 : w = NULL;
1862 0 : if ((opcode-STORE_SLICE) & 1)
1863 0 : v = POP();
1864 : else
1865 0 : v = NULL;
1866 0 : u = POP();
1867 0 : t = POP();
1868 0 : err = assign_slice(u, v, w, t); /* u[v:w] = t */
1869 0 : Py_DECREF(t);
1870 0 : Py_DECREF(u);
1871 0 : Py_XDECREF(v);
1872 0 : Py_XDECREF(w);
1873 0 : if (err == 0) DISPATCH();
1874 0 : break;
1875 : }
1876 :
1877 :
1878 0 : TARGET_WITH_IMPL_NOARG(DELETE_SLICE, _delete_slice)
1879 0 : TARGET_WITH_IMPL_NOARG(DELETE_SLICE_1, _delete_slice)
1880 0 : TARGET_WITH_IMPL_NOARG(DELETE_SLICE_2, _delete_slice)
1881 0 : TARGET_WITH_IMPL_NOARG(DELETE_SLICE_3, _delete_slice)
1882 : _delete_slice:
1883 : {
1884 0 : if ((opcode-DELETE_SLICE) & 2)
1885 0 : w = POP();
1886 : else
1887 0 : w = NULL;
1888 0 : if ((opcode-DELETE_SLICE) & 1)
1889 0 : v = POP();
1890 : else
1891 0 : v = NULL;
1892 0 : u = POP();
1893 0 : err = assign_slice(u, v, w, (PyObject *)NULL);
1894 : /* del u[v:w] */
1895 0 : Py_DECREF(u);
1896 0 : Py_XDECREF(v);
1897 0 : Py_XDECREF(w);
1898 0 : if (err == 0) DISPATCH();
1899 0 : break;
1900 : }
1901 :
1902 23562 : TARGET_NOARG(STORE_SUBSCR)
1903 : {
1904 23613 : w = TOP();
1905 23613 : v = SECOND();
1906 23613 : u = THIRD();
1907 23613 : STACKADJ(-3);
1908 : /* v[w] = u */
1909 23613 : err = PyObject_SetItem(v, w, u);
1910 23613 : Py_DECREF(u);
1911 23613 : Py_DECREF(v);
1912 23613 : Py_DECREF(w);
1913 23613 : if (err == 0) DISPATCH();
1914 0 : break;
1915 : }
1916 :
1917 117 : TARGET_NOARG(DELETE_SUBSCR)
1918 : {
1919 117 : w = TOP();
1920 117 : v = SECOND();
1921 117 : STACKADJ(-2);
1922 : /* del v[w] */
1923 117 : err = PyObject_DelItem(v, w);
1924 117 : Py_DECREF(v);
1925 117 : Py_DECREF(w);
1926 117 : if (err == 0) DISPATCH();
1927 0 : break;
1928 : }
1929 :
1930 0 : TARGET_NOARG(PRINT_EXPR)
1931 : {
1932 0 : v = POP();
1933 0 : w = PySys_GetObject("displayhook");
1934 0 : if (w == NULL) {
1935 0 : PyErr_SetString(PyExc_RuntimeError,
1936 : "lost sys.displayhook");
1937 0 : err = -1;
1938 0 : x = NULL;
1939 : }
1940 0 : if (err == 0) {
1941 0 : x = PyTuple_Pack(1, v);
1942 0 : if (x == NULL)
1943 0 : err = -1;
1944 : }
1945 0 : if (err == 0) {
1946 0 : w = PyEval_CallObject(w, x);
1947 0 : Py_XDECREF(w);
1948 0 : if (w == NULL)
1949 0 : err = -1;
1950 : }
1951 0 : Py_DECREF(v);
1952 0 : Py_XDECREF(x);
1953 0 : break;
1954 : }
1955 :
1956 0 : TARGET_NOARG(PRINT_ITEM_TO)
1957 : {
1958 0 : w = stream = POP();
1959 : /* fall through to PRINT_ITEM */
1960 : }
1961 :
1962 0 : TARGET_NOARG(PRINT_ITEM)
1963 : {
1964 0 : v = POP();
1965 0 : if (stream == NULL || stream == Py_None) {
1966 0 : w = PySys_GetObject("stdout");
1967 0 : if (w == NULL) {
1968 0 : PyErr_SetString(PyExc_RuntimeError,
1969 : "lost sys.stdout");
1970 0 : 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 0 : Py_XINCREF(w);
1978 0 : if (w != NULL && PyFile_SoftSpace(w, 0))
1979 0 : err = PyFile_WriteString(" ", w);
1980 0 : if (err == 0)
1981 0 : err = PyFile_WriteObject(v, w, Py_PRINT_RAW);
1982 0 : if (err == 0) {
1983 : /* XXX move into writeobject() ? */
1984 0 : if (PyString_Check(v)) {
1985 0 : char *s = PyString_AS_STRING(v);
1986 0 : Py_ssize_t len = PyString_GET_SIZE(v);
1987 0 : if (len == 0 ||
1988 0 : !isspace(Py_CHARMASK(s[len-1])) ||
1989 0 : s[len-1] == ' ')
1990 0 : PyFile_SoftSpace(w, 1);
1991 : }
1992 : #ifdef Py_USING_UNICODE
1993 0 : else if (PyUnicode_Check(v)) {
1994 0 : Py_UNICODE *s = PyUnicode_AS_UNICODE(v);
1995 0 : Py_ssize_t len = PyUnicode_GET_SIZE(v);
1996 0 : if (len == 0 ||
1997 0 : !Py_UNICODE_ISSPACE(s[len-1]) ||
1998 0 : s[len-1] == ' ')
1999 0 : PyFile_SoftSpace(w, 1);
2000 : }
2001 : #endif
2002 : else
2003 0 : PyFile_SoftSpace(w, 1);
2004 : }
2005 0 : Py_XDECREF(w);
2006 0 : Py_DECREF(v);
2007 0 : Py_XDECREF(stream);
2008 0 : stream = NULL;
2009 0 : if (err == 0) DISPATCH();
2010 0 : break;
2011 : }
2012 :
2013 0 : TARGET_NOARG(PRINT_NEWLINE_TO)
2014 : {
2015 0 : w = stream = POP();
2016 : /* fall through to PRINT_NEWLINE */
2017 : }
2018 :
2019 0 : TARGET_NOARG(PRINT_NEWLINE)
2020 : {
2021 0 : if (stream == NULL || stream == Py_None)
2022 : {
2023 0 : w = PySys_GetObject("stdout");
2024 0 : if (w == NULL) {
2025 0 : PyErr_SetString(PyExc_RuntimeError,
2026 : "lost sys.stdout");
2027 0 : why = WHY_EXCEPTION;
2028 : }
2029 : }
2030 0 : if (w != NULL) {
2031 : /* w.write() may replace sys.stdout, so we
2032 : * have to keep our reference to it */
2033 0 : Py_INCREF(w);
2034 0 : err = PyFile_WriteString("\n", w);
2035 0 : if (err == 0)
2036 0 : PyFile_SoftSpace(w, 0);
2037 0 : Py_DECREF(w);
2038 : }
2039 0 : Py_XDECREF(stream);
2040 0 : stream = NULL;
2041 0 : break;
2042 : }
2043 :
2044 : #ifdef CASE_TOO_BIG
2045 : default: switch (opcode) {
2046 : #endif
2047 :
2048 24 : TARGET(RAISE_VARARGS)
2049 : {
2050 24 : u = v = w = NULL;
2051 24 : switch (oparg) {
2052 : case 3:
2053 0 : u = POP(); /* traceback */
2054 : /* Fallthrough */
2055 : case 2:
2056 0 : v = POP(); /* value */
2057 : /* Fallthrough */
2058 : case 1:
2059 24 : w = POP(); /* exc */
2060 : case 0: /* Fallthrough */
2061 24 : why = do_raise(w, v, u);
2062 24 : break;
2063 : default:
2064 0 : PyErr_SetString(PyExc_SystemError,
2065 : "bad RAISE_VARARGS oparg");
2066 0 : why = WHY_EXCEPTION;
2067 0 : break;
2068 : }
2069 24 : break;
2070 : }
2071 :
2072 693 : TARGET_NOARG(LOAD_LOCALS)
2073 : {
2074 702 : if ((x = f->f_locals) != NULL)
2075 : {
2076 702 : Py_INCREF(x);
2077 702 : PUSH(x);
2078 702 : DISPATCH();
2079 : }
2080 0 : PyErr_SetString(PyExc_SystemError, "no locals");
2081 0 : break;
2082 : }
2083 :
2084 83902 : TARGET_NOARG(RETURN_VALUE)
2085 : {
2086 84176 : retval = POP();
2087 84176 : why = WHY_RETURN;
2088 84176 : goto fast_block_end;
2089 : }
2090 :
2091 6138 : TARGET_NOARG(YIELD_VALUE)
2092 : {
2093 6189 : retval = POP();
2094 6189 : f->f_stacktop = stack_pointer;
2095 6189 : why = WHY_YIELD;
2096 6189 : goto fast_yield;
2097 : }
2098 :
2099 27 : TARGET_NOARG(EXEC_STMT)
2100 : {
2101 27 : w = TOP();
2102 27 : v = SECOND();
2103 27 : u = THIRD();
2104 27 : STACKADJ(-3);
2105 : READ_TIMESTAMP(intr0);
2106 27 : err = exec_statement(f, u, v, w);
2107 : READ_TIMESTAMP(intr1);
2108 27 : Py_DECREF(u);
2109 27 : Py_DECREF(v);
2110 27 : Py_DECREF(w);
2111 27 : break;
2112 : }
2113 :
2114 23422 : TARGET_NOARG(POP_BLOCK)
2115 : {
2116 : {
2117 23629 : PyTryBlock *b = PyFrame_BlockPop(f);
2118 47258 : while (STACK_LEVEL() > b->b_level) {
2119 0 : v = POP();
2120 0 : Py_DECREF(v);
2121 : }
2122 : }
2123 23629 : DISPATCH();
2124 : }
2125 :
2126 : PREDICTED(END_FINALLY);
2127 3 : TARGET_NOARG(END_FINALLY)
2128 : {
2129 78 : v = POP();
2130 78 : if (PyInt_Check(v)) {
2131 6 : why = (enum why_code) PyInt_AS_LONG(v);
2132 : assert(why != WHY_YIELD);
2133 6 : if (why == WHY_RETURN ||
2134 : why == WHY_CONTINUE)
2135 6 : retval = POP();
2136 : }
2137 141 : else if (PyExceptionClass_Check(v) ||
2138 69 : PyString_Check(v)) {
2139 3 : w = POP();
2140 3 : u = POP();
2141 3 : PyErr_Restore(v, w, u);
2142 3 : why = WHY_RERAISE;
2143 3 : break;
2144 : }
2145 69 : else if (v != Py_None) {
2146 0 : PyErr_SetString(PyExc_SystemError,
2147 : "'finally' pops bad exception");
2148 0 : why = WHY_EXCEPTION;
2149 : }
2150 75 : Py_DECREF(v);
2151 75 : break;
2152 : }
2153 :
2154 681 : TARGET_NOARG(BUILD_CLASS)
2155 : {
2156 702 : u = TOP();
2157 702 : v = SECOND();
2158 702 : w = THIRD();
2159 702 : STACKADJ(-2);
2160 702 : x = build_class(u, v, w);
2161 702 : SET_TOP(x);
2162 702 : Py_DECREF(u);
2163 702 : Py_DECREF(v);
2164 702 : Py_DECREF(w);
2165 702 : break;
2166 : }
2167 :
2168 7230 : TARGET(STORE_NAME)
2169 : {
2170 13425 : w = GETITEM(names, oparg);
2171 13425 : v = POP();
2172 13425 : if ((x = f->f_locals) != NULL) {
2173 13425 : if (PyDict_CheckExact(x))
2174 13425 : err = PyDict_SetItem(x, w, v);
2175 : else
2176 0 : err = PyObject_SetItem(x, w, v);
2177 13425 : Py_DECREF(v);
2178 13425 : if (err == 0) DISPATCH();
2179 0 : break;
2180 : }
2181 0 : t = PyObject_Repr(w);
2182 0 : if (t == NULL)
2183 0 : break;
2184 0 : PyErr_Format(PyExc_SystemError,
2185 : "no locals found when storing %s",
2186 0 : PyString_AS_STRING(t));
2187 0 : Py_DECREF(t);
2188 0 : break;
2189 : }
2190 :
2191 48 : TARGET(DELETE_NAME)
2192 : {
2193 93 : w = GETITEM(names, oparg);
2194 93 : if ((x = f->f_locals) != NULL) {
2195 93 : if ((err = PyObject_DelItem(x, w)) != 0)
2196 0 : format_exc_check_arg(PyExc_NameError,
2197 : NAME_ERROR_MSG,
2198 : w);
2199 93 : break;
2200 : }
2201 0 : t = PyObject_Repr(w);
2202 0 : if (t == NULL)
2203 0 : break;
2204 0 : PyErr_Format(PyExc_SystemError,
2205 : "no locals when deleting %s",
2206 0 : PyString_AS_STRING(w));
2207 0 : Py_DECREF(t);
2208 0 : break;
2209 : }
2210 :
2211 : PREDICTED_WITH_ARG(UNPACK_SEQUENCE);
2212 25887 : TARGET(UNPACK_SEQUENCE)
2213 : {
2214 26107 : v = POP();
2215 52205 : if (PyTuple_CheckExact(v) &&
2216 26098 : PyTuple_GET_SIZE(v) == oparg) {
2217 26098 : PyObject **items = \
2218 : ((PyTupleObject *)v)->ob_item;
2219 105697 : while (oparg--) {
2220 53501 : w = items[oparg];
2221 53501 : Py_INCREF(w);
2222 53501 : PUSH(w);
2223 : }
2224 26098 : Py_DECREF(v);
2225 26098 : DISPATCH();
2226 18 : } else if (PyList_CheckExact(v) &&
2227 18 : PyList_GET_SIZE(v) == oparg) {
2228 9 : PyObject **items = \
2229 : ((PyListObject *)v)->ob_item;
2230 78 : while (oparg--) {
2231 60 : w = items[oparg];
2232 60 : Py_INCREF(w);
2233 60 : PUSH(w);
2234 : }
2235 0 : } else if (unpack_iterable(v, oparg,
2236 0 : stack_pointer + oparg)) {
2237 0 : STACKADJ(oparg);
2238 : } else {
2239 : /* unpack_iterable() raised an exception */
2240 0 : why = WHY_EXCEPTION;
2241 : }
2242 9 : Py_DECREF(v);
2243 9 : break;
2244 : }
2245 :
2246 :
2247 48504 : TARGET(STORE_ATTR)
2248 : {
2249 48504 : w = GETITEM(names, oparg);
2250 48504 : v = TOP();
2251 48504 : u = SECOND();
2252 48504 : STACKADJ(-2);
2253 48504 : err = PyObject_SetAttr(v, w, u); /* v.w = u */
2254 48504 : Py_DECREF(v);
2255 48504 : Py_DECREF(u);
2256 48504 : if (err == 0) DISPATCH();
2257 0 : break;
2258 : }
2259 :
2260 0 : TARGET(DELETE_ATTR)
2261 : {
2262 0 : w = GETITEM(names, oparg);
2263 0 : v = POP();
2264 0 : err = PyObject_SetAttr(v, w, (PyObject *)NULL);
2265 : /* del v.w */
2266 0 : Py_DECREF(v);
2267 0 : break;
2268 : }
2269 :
2270 :
2271 48 : TARGET(STORE_GLOBAL)
2272 : {
2273 48 : w = GETITEM(names, oparg);
2274 48 : v = POP();
2275 48 : err = PyDict_SetItem(f->f_globals, w, v);
2276 48 : Py_DECREF(v);
2277 48 : if (err == 0) DISPATCH();
2278 0 : break;
2279 : }
2280 :
2281 0 : TARGET(DELETE_GLOBAL)
2282 : {
2283 0 : w = GETITEM(names, oparg);
2284 0 : if ((err = PyDict_DelItem(f->f_globals, w)) != 0)
2285 0 : format_exc_check_arg(
2286 : PyExc_NameError, GLOBAL_NAME_ERROR_MSG, w);
2287 0 : break;
2288 : }
2289 :
2290 12009 : TARGET(LOAD_NAME)
2291 : {
2292 12879 : w = GETITEM(names, oparg);
2293 12879 : if ((v = f->f_locals) == NULL) {
2294 0 : why = WHY_EXCEPTION;
2295 0 : t = PyObject_Repr(w);
2296 0 : if (t == NULL)
2297 0 : break;
2298 0 : PyErr_Format(PyExc_SystemError,
2299 : "no locals when loading %s",
2300 0 : PyString_AS_STRING(w));
2301 0 : Py_DECREF(t);
2302 0 : break;
2303 : }
2304 12879 : if (PyDict_CheckExact(v)) {
2305 12879 : x = PyDict_GetItem(v, w);
2306 12879 : Py_XINCREF(x);
2307 : }
2308 : else {
2309 0 : x = PyObject_GetItem(v, w);
2310 0 : if (x == NULL && PyErr_Occurred()) {
2311 0 : if (!PyErr_ExceptionMatches(
2312 : PyExc_KeyError))
2313 0 : break;
2314 0 : PyErr_Clear();
2315 : }
2316 : }
2317 12879 : if (x == NULL) {
2318 4014 : x = PyDict_GetItem(f->f_globals, w);
2319 4014 : if (x == NULL) {
2320 2592 : x = PyDict_GetItem(f->f_builtins, w);
2321 2592 : if (x == NULL) {
2322 0 : format_exc_check_arg(
2323 : PyExc_NameError,
2324 : NAME_ERROR_MSG, w);
2325 0 : break;
2326 : }
2327 : }
2328 4014 : Py_INCREF(x);
2329 : }
2330 12879 : PUSH(x);
2331 12879 : DISPATCH();
2332 : }
2333 :
2334 235515 : TARGET(LOAD_GLOBAL)
2335 : {
2336 261741 : w = GETITEM(names, oparg);
2337 261741 : 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 261741 : long hash = ((PyStringObject *)w)->ob_shash;
2342 261741 : if (hash != -1) {
2343 : PyDictObject *d;
2344 : PyDictEntry *e;
2345 261741 : d = (PyDictObject *)(f->f_globals);
2346 261741 : e = d->ma_lookup(d, w, hash);
2347 261741 : if (e == NULL) {
2348 0 : x = NULL;
2349 0 : break;
2350 : }
2351 261741 : x = e->me_value;
2352 261741 : if (x != NULL) {
2353 164980 : Py_INCREF(x);
2354 164980 : PUSH(x);
2355 164980 : DISPATCH();
2356 : }
2357 96761 : d = (PyDictObject *)(f->f_builtins);
2358 96761 : e = d->ma_lookup(d, w, hash);
2359 96761 : if (e == NULL) {
2360 0 : x = NULL;
2361 0 : break;
2362 : }
2363 96761 : x = e->me_value;
2364 96761 : if (x != NULL) {
2365 96761 : Py_INCREF(x);
2366 96761 : PUSH(x);
2367 96761 : DISPATCH();
2368 : }
2369 0 : goto load_global_error;
2370 : }
2371 : }
2372 : /* This is the un-inlined version of the code above */
2373 0 : x = PyDict_GetItem(f->f_globals, w);
2374 0 : if (x == NULL) {
2375 0 : x = PyDict_GetItem(f->f_builtins, w);
2376 0 : if (x == NULL) {
2377 : load_global_error:
2378 0 : format_exc_check_arg(
2379 : PyExc_NameError,
2380 : GLOBAL_NAME_ERROR_MSG, w);
2381 0 : break;
2382 : }
2383 : }
2384 0 : Py_INCREF(x);
2385 0 : PUSH(x);
2386 0 : DISPATCH();
2387 : }
2388 :
2389 0 : TARGET(DELETE_FAST)
2390 : {
2391 0 : x = GETLOCAL(oparg);
2392 0 : if (x != NULL) {
2393 0 : SETLOCAL(oparg, NULL);
2394 0 : DISPATCH();
2395 : }
2396 0 : format_exc_check_arg(
2397 : PyExc_UnboundLocalError,
2398 : UNBOUNDLOCAL_ERROR_MSG,
2399 : PyTuple_GetItem(co->co_varnames, oparg)
2400 : );
2401 0 : break;
2402 : }
2403 :
2404 84 : TARGET(LOAD_CLOSURE)
2405 : {
2406 84 : x = freevars[oparg];
2407 84 : Py_INCREF(x);
2408 84 : PUSH(x);
2409 84 : if (x != NULL) DISPATCH();
2410 0 : break;
2411 : }
2412 :
2413 261 : TARGET(LOAD_DEREF)
2414 : {
2415 261 : x = freevars[oparg];
2416 261 : w = PyCell_Get(x);
2417 261 : if (w != NULL) {
2418 261 : PUSH(w);
2419 261 : DISPATCH();
2420 : }
2421 0 : err = -1;
2422 : /* Don't stomp existing exception */
2423 0 : if (PyErr_Occurred())
2424 0 : break;
2425 0 : if (oparg < PyTuple_GET_SIZE(co->co_cellvars)) {
2426 0 : v = PyTuple_GET_ITEM(co->co_cellvars,
2427 : oparg);
2428 0 : format_exc_check_arg(
2429 : PyExc_UnboundLocalError,
2430 : UNBOUNDLOCAL_ERROR_MSG,
2431 : v);
2432 : } else {
2433 0 : v = PyTuple_GET_ITEM(co->co_freevars, oparg -
2434 : PyTuple_GET_SIZE(co->co_cellvars));
2435 0 : format_exc_check_arg(PyExc_NameError,
2436 : UNBOUNDFREE_ERROR_MSG, v);
2437 : }
2438 0 : break;
2439 : }
2440 :
2441 81 : TARGET(STORE_DEREF)
2442 : {
2443 81 : w = POP();
2444 81 : x = freevars[oparg];
2445 81 : PyCell_Set(x, w);
2446 81 : Py_DECREF(w);
2447 81 : DISPATCH();
2448 : }
2449 :
2450 26366 : TARGET(BUILD_TUPLE)
2451 : {
2452 26559 : x = PyTuple_New(oparg);
2453 26559 : if (x != NULL) {
2454 114663 : for (; --oparg >= 0;) {
2455 61545 : w = POP();
2456 61545 : PyTuple_SET_ITEM(x, oparg, w);
2457 : }
2458 26559 : PUSH(x);
2459 26559 : DISPATCH();
2460 : }
2461 0 : break;
2462 : }
2463 :
2464 11176 : TARGET(BUILD_LIST)
2465 : {
2466 13433 : x = PyList_New(oparg);
2467 13433 : if (x != NULL) {
2468 32492 : for (; --oparg >= 0;) {
2469 5626 : w = POP();
2470 5626 : PyList_SET_ITEM(x, oparg, w);
2471 : }
2472 13433 : PUSH(x);
2473 13433 : DISPATCH();
2474 : }
2475 0 : break;
2476 : }
2477 :
2478 3 : TARGET(BUILD_SET)
2479 : {
2480 : int i;
2481 3 : x = PySet_New(NULL);
2482 3 : if (x != NULL) {
2483 12 : for (i = oparg; i > 0; i--) {
2484 9 : w = PEEK(i);
2485 9 : if (err == 0)
2486 9 : err = PySet_Add(x, w);
2487 9 : Py_DECREF(w);
2488 : }
2489 3 : STACKADJ(-oparg);
2490 3 : if (err != 0) {
2491 0 : Py_DECREF(x);
2492 0 : break;
2493 : }
2494 3 : PUSH(x);
2495 3 : DISPATCH();
2496 : }
2497 0 : break;
2498 : }
2499 :
2500 1453 : TARGET(BUILD_MAP)
2501 : {
2502 1909 : x = _PyDict_NewPresized((Py_ssize_t)oparg);
2503 1909 : PUSH(x);
2504 1909 : if (x != NULL) DISPATCH();
2505 0 : break;
2506 : }
2507 :
2508 5598 : TARGET_NOARG(STORE_MAP)
2509 : {
2510 5598 : w = TOP(); /* key */
2511 5598 : u = SECOND(); /* value */
2512 5598 : v = THIRD(); /* dict */
2513 5598 : STACKADJ(-2);
2514 : assert (PyDict_CheckExact(v));
2515 5598 : err = PyDict_SetItem(v, w, u); /* v[w] = u */
2516 5598 : Py_DECREF(u);
2517 5598 : Py_DECREF(w);
2518 5598 : if (err == 0) DISPATCH();
2519 0 : break;
2520 : }
2521 :
2522 706 : TARGET(MAP_ADD)
2523 : {
2524 706 : w = TOP(); /* key */
2525 706 : u = SECOND(); /* value */
2526 706 : STACKADJ(-2);
2527 706 : v = stack_pointer[-oparg]; /* dict */
2528 : assert (PyDict_CheckExact(v));
2529 706 : err = PyDict_SetItem(v, w, u); /* v[w] = u */
2530 706 : Py_DECREF(u);
2531 706 : Py_DECREF(w);
2532 706 : if (err == 0) {
2533 : PREDICT(JUMP_ABSOLUTE);
2534 706 : DISPATCH();
2535 : }
2536 0 : break;
2537 : }
2538 :
2539 260249 : TARGET(LOAD_ATTR)
2540 : {
2541 260752 : w = GETITEM(names, oparg);
2542 260752 : v = TOP();
2543 260752 : x = PyObject_GetAttr(v, w);
2544 260752 : Py_DECREF(v);
2545 260752 : SET_TOP(x);
2546 260752 : if (x != NULL) DISPATCH();
2547 6 : break;
2548 : }
2549 :
2550 150186 : TARGET(COMPARE_OP)
2551 : {
2552 150837 : w = POP();
2553 150837 : v = TOP();
2554 186944 : if (PyInt_CheckExact(w) && PyInt_CheckExact(v)) {
2555 : /* INLINE: cmp(int, int) */
2556 : register long a, b;
2557 : register int res;
2558 36107 : a = PyInt_AS_LONG(v);
2559 36107 : b = PyInt_AS_LONG(w);
2560 36107 : switch (oparg) {
2561 3374 : case PyCmp_LT: res = a < b; break;
2562 573 : case PyCmp_LE: res = a <= b; break;
2563 13663 : case PyCmp_EQ: res = a == b; break;
2564 995 : case PyCmp_NE: res = a != b; break;
2565 2703 : case PyCmp_GT: res = a > b; break;
2566 14799 : case PyCmp_GE: res = a >= b; break;
2567 0 : case PyCmp_IS: res = v == w; break;
2568 0 : case PyCmp_IS_NOT: res = v != w; break;
2569 0 : default: goto slow_compare;
2570 : }
2571 36107 : x = res ? Py_True : Py_False;
2572 36107 : Py_INCREF(x);
2573 : }
2574 : else {
2575 : slow_compare:
2576 114730 : x = cmp_outcome(oparg, v, w);
2577 : }
2578 150837 : Py_DECREF(v);
2579 150837 : Py_DECREF(w);
2580 150837 : SET_TOP(x);
2581 150837 : if (x == NULL) break;
2582 : PREDICT(POP_JUMP_IF_FALSE);
2583 : PREDICT(POP_JUMP_IF_TRUE);
2584 150837 : DISPATCH();
2585 : }
2586 :
2587 1149 : TARGET(IMPORT_NAME)
2588 : {
2589 1149 : w = GETITEM(names, oparg);
2590 1149 : x = PyDict_GetItemString(f->f_builtins, "__import__");
2591 1149 : if (x == NULL) {
2592 0 : PyErr_SetString(PyExc_ImportError,
2593 : "__import__ not found");
2594 0 : break;
2595 : }
2596 1149 : Py_INCREF(x);
2597 1149 : v = POP();
2598 1149 : u = TOP();
2599 1149 : if (PyInt_AsLong(u) != -1 || PyErr_Occurred())
2600 6 : w = PyTuple_Pack(5,
2601 : w,
2602 : f->f_globals,
2603 6 : f->f_locals == NULL ?
2604 : Py_None : f->f_locals,
2605 : v,
2606 : u);
2607 : else
2608 1143 : w = PyTuple_Pack(4,
2609 : w,
2610 : f->f_globals,
2611 1143 : f->f_locals == NULL ?
2612 : Py_None : f->f_locals,
2613 : v);
2614 1149 : Py_DECREF(v);
2615 1149 : Py_DECREF(u);
2616 1149 : if (w == NULL) {
2617 0 : u = POP();
2618 0 : Py_DECREF(x);
2619 0 : x = NULL;
2620 0 : break;
2621 : }
2622 : READ_TIMESTAMP(intr0);
2623 1149 : v = x;
2624 1149 : x = PyEval_CallObject(v, w);
2625 1149 : Py_DECREF(v);
2626 : READ_TIMESTAMP(intr1);
2627 1149 : Py_DECREF(w);
2628 1149 : SET_TOP(x);
2629 1149 : if (x != NULL) DISPATCH();
2630 12 : break;
2631 : }
2632 :
2633 33 : TARGET_NOARG(IMPORT_STAR)
2634 : {
2635 33 : v = POP();
2636 33 : PyFrame_FastToLocals(f);
2637 33 : if ((x = f->f_locals) == NULL) {
2638 0 : PyErr_SetString(PyExc_SystemError,
2639 : "no locals found during 'import *'");
2640 0 : break;
2641 : }
2642 : READ_TIMESTAMP(intr0);
2643 33 : err = import_all_from(x, v);
2644 : READ_TIMESTAMP(intr1);
2645 33 : PyFrame_LocalsToFast(f, 0);
2646 33 : Py_DECREF(v);
2647 33 : if (err == 0) DISPATCH();
2648 0 : break;
2649 : }
2650 :
2651 855 : TARGET(IMPORT_FROM)
2652 : {
2653 864 : w = GETITEM(names, oparg);
2654 864 : v = TOP();
2655 : READ_TIMESTAMP(intr0);
2656 864 : x = import_from(v, w);
2657 : READ_TIMESTAMP(intr1);
2658 864 : PUSH(x);
2659 864 : if (x != NULL) DISPATCH();
2660 0 : break;
2661 : }
2662 :
2663 28689 : TARGET(JUMP_FORWARD)
2664 : {
2665 28862 : JUMPBY(oparg);
2666 28862 : FAST_DISPATCH();
2667 : }
2668 :
2669 : PREDICTED_WITH_ARG(POP_JUMP_IF_FALSE);
2670 213934 : TARGET(POP_JUMP_IF_FALSE)
2671 : {
2672 215819 : w = POP();
2673 215819 : if (w == Py_True) {
2674 57691 : Py_DECREF(w);
2675 57691 : FAST_DISPATCH();
2676 : }
2677 158128 : if (w == Py_False) {
2678 113627 : Py_DECREF(w);
2679 113627 : JUMPTO(oparg);
2680 113627 : FAST_DISPATCH();
2681 : }
2682 44501 : err = PyObject_IsTrue(w);
2683 44501 : Py_DECREF(w);
2684 44501 : if (err > 0)
2685 19137 : err = 0;
2686 25364 : else if (err == 0)
2687 25364 : JUMPTO(oparg);
2688 : else
2689 0 : break;
2690 44501 : DISPATCH();
2691 : }
2692 :
2693 : PREDICTED_WITH_ARG(POP_JUMP_IF_TRUE);
2694 14052 : TARGET(POP_JUMP_IF_TRUE)
2695 : {
2696 14128 : w = POP();
2697 14128 : if (w == Py_False) {
2698 2699 : Py_DECREF(w);
2699 2699 : FAST_DISPATCH();
2700 : }
2701 11429 : if (w == Py_True) {
2702 4297 : Py_DECREF(w);
2703 4297 : JUMPTO(oparg);
2704 4297 : FAST_DISPATCH();
2705 : }
2706 7132 : err = PyObject_IsTrue(w);
2707 7132 : Py_DECREF(w);
2708 7132 : if (err > 0) {
2709 1915 : err = 0;
2710 1915 : JUMPTO(oparg);
2711 : }
2712 5217 : else if (err == 0)
2713 : ;
2714 : else
2715 0 : break;
2716 7132 : DISPATCH();
2717 : }
2718 :
2719 2781 : TARGET(JUMP_IF_FALSE_OR_POP)
2720 : {
2721 2796 : w = TOP();
2722 2796 : if (w == Py_True) {
2723 2115 : STACKADJ(-1);
2724 2115 : Py_DECREF(w);
2725 2115 : FAST_DISPATCH();
2726 : }
2727 681 : if (w == Py_False) {
2728 681 : JUMPTO(oparg);
2729 681 : FAST_DISPATCH();
2730 : }
2731 0 : err = PyObject_IsTrue(w);
2732 0 : if (err > 0) {
2733 0 : STACKADJ(-1);
2734 0 : Py_DECREF(w);
2735 0 : err = 0;
2736 : }
2737 0 : else if (err == 0)
2738 0 : JUMPTO(oparg);
2739 : else
2740 0 : break;
2741 0 : DISPATCH();
2742 : }
2743 :
2744 2876 : TARGET(JUMP_IF_TRUE_OR_POP)
2745 : {
2746 2882 : w = TOP();
2747 2882 : if (w == Py_False) {
2748 153 : STACKADJ(-1);
2749 153 : Py_DECREF(w);
2750 153 : FAST_DISPATCH();
2751 : }
2752 2729 : if (w == Py_True) {
2753 1253 : JUMPTO(oparg);
2754 1253 : FAST_DISPATCH();
2755 : }
2756 1476 : err = PyObject_IsTrue(w);
2757 1476 : if (err > 0) {
2758 921 : err = 0;
2759 921 : JUMPTO(oparg);
2760 : }
2761 555 : else if (err == 0) {
2762 555 : STACKADJ(-1);
2763 555 : Py_DECREF(w);
2764 : }
2765 : else
2766 0 : break;
2767 1476 : DISPATCH();
2768 : }
2769 :
2770 : PREDICTED_WITH_ARG(JUMP_ABSOLUTE);
2771 51160 : TARGET(JUMP_ABSOLUTE)
2772 : {
2773 53569 : 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 53569 : DISPATCH();
2785 : #endif
2786 : }
2787 :
2788 16294 : TARGET_NOARG(GET_ITER)
2789 : {
2790 : /* before: [obj]; after [getiter(obj)] */
2791 16395 : v = TOP();
2792 16395 : x = PyObject_GetIter(v);
2793 16395 : Py_DECREF(v);
2794 16395 : if (x != NULL) {
2795 16395 : SET_TOP(x);
2796 : PREDICT(FOR_ITER);
2797 16395 : DISPATCH();
2798 : }
2799 0 : STACKADJ(-1);
2800 0 : break;
2801 : }
2802 :
2803 : PREDICTED_WITH_ARG(FOR_ITER);
2804 60958 : TARGET(FOR_ITER)
2805 : {
2806 : /* before: [iter]; after: [iter, iter()] *or* [] */
2807 61527 : v = TOP();
2808 61527 : x = (*v->ob_type->tp_iternext)(v);
2809 61527 : if (x != NULL) {
2810 47754 : PUSH(x);
2811 : PREDICT(STORE_FAST);
2812 : PREDICT(UNPACK_SEQUENCE);
2813 47754 : DISPATCH();
2814 : }
2815 13773 : if (PyErr_Occurred()) {
2816 0 : if (!PyErr_ExceptionMatches(
2817 : PyExc_StopIteration))
2818 0 : break;
2819 0 : PyErr_Clear();
2820 : }
2821 : /* iterator ended normally */
2822 13773 : x = v = POP();
2823 13773 : Py_DECREF(v);
2824 13773 : JUMPBY(oparg);
2825 13773 : DISPATCH();
2826 : }
2827 :
2828 6563 : TARGET_NOARG(BREAK_LOOP)
2829 : {
2830 6689 : why = WHY_BREAK;
2831 6689 : goto fast_block_end;
2832 : }
2833 :
2834 0 : TARGET(CONTINUE_LOOP)
2835 : {
2836 0 : retval = PyInt_FromLong(oparg);
2837 0 : if (!retval) {
2838 0 : x = NULL;
2839 0 : break;
2840 : }
2841 0 : why = WHY_CONTINUE;
2842 0 : goto fast_block_end;
2843 : }
2844 :
2845 20087 : TARGET_WITH_IMPL(SETUP_LOOP, _setup_finally)
2846 12398 : TARGET_WITH_IMPL(SETUP_EXCEPT, _setup_finally)
2847 0 : 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 35264 : PyFrame_BlockSetup(f, opcode, INSTR_OFFSET() + oparg,
2856 35264 : STACK_LEVEL());
2857 35264 : DISPATCH();
2858 : }
2859 :
2860 :
2861 :
2862 72 : TARGET(SETUP_WITH)
2863 : {
2864 : {
2865 : static PyObject *exit, *enter;
2866 75 : w = TOP();
2867 75 : x = special_lookup(w, "__exit__", &exit);
2868 75 : if (!x)
2869 0 : break;
2870 75 : SET_TOP(x);
2871 75 : u = special_lookup(w, "__enter__", &enter);
2872 75 : Py_DECREF(w);
2873 75 : if (!u) {
2874 0 : x = NULL;
2875 0 : break;
2876 : }
2877 75 : x = PyObject_CallFunctionObjArgs(u, NULL);
2878 75 : Py_DECREF(u);
2879 75 : if (!x)
2880 0 : 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 75 : PyFrame_BlockSetup(f, SETUP_WITH, INSTR_OFFSET() + oparg,
2886 75 : STACK_LEVEL());
2887 :
2888 75 : PUSH(x);
2889 75 : DISPATCH();
2890 : }
2891 : }
2892 :
2893 69 : 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 75 : u = POP();
2920 75 : if (u == Py_None) {
2921 69 : exit_func = TOP();
2922 69 : SET_TOP(u);
2923 69 : v = w = Py_None;
2924 : }
2925 6 : else if (PyInt_Check(u)) {
2926 6 : switch(PyInt_AS_LONG(u)) {
2927 : case WHY_RETURN:
2928 : case WHY_CONTINUE:
2929 : /* Retval in TOP. */
2930 6 : exit_func = SECOND();
2931 6 : SET_SECOND(TOP());
2932 6 : SET_TOP(u);
2933 6 : break;
2934 : default:
2935 0 : exit_func = TOP();
2936 0 : SET_TOP(u);
2937 0 : break;
2938 : }
2939 6 : u = v = w = Py_None;
2940 : }
2941 : else {
2942 0 : v = TOP();
2943 0 : w = SECOND();
2944 0 : exit_func = THIRD();
2945 0 : SET_TOP(u);
2946 0 : SET_SECOND(v);
2947 0 : SET_THIRD(w);
2948 : }
2949 : /* XXX Not the fastest way to call it... */
2950 75 : x = PyObject_CallFunctionObjArgs(exit_func, u, v, w,
2951 : NULL);
2952 75 : Py_DECREF(exit_func);
2953 75 : if (x == NULL)
2954 0 : break; /* Go to error exit */
2955 :
2956 75 : if (u != Py_None)
2957 0 : err = PyObject_IsTrue(x);
2958 : else
2959 75 : err = 0;
2960 75 : Py_DECREF(x);
2961 :
2962 75 : if (err < 0)
2963 0 : break; /* Go to error exit */
2964 75 : else if (err > 0) {
2965 0 : err = 0;
2966 : /* There was an exception and a true return */
2967 0 : STACKADJ(-2);
2968 0 : Py_INCREF(Py_None);
2969 0 : SET_TOP(Py_None);
2970 0 : Py_DECREF(u);
2971 0 : Py_DECREF(v);
2972 0 : 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 75 : break;
2979 : }
2980 :
2981 220275 : TARGET(CALL_FUNCTION)
2982 : {
2983 : PyObject **sp;
2984 : PCALL(PCALL_ALL);
2985 222177 : sp = stack_pointer;
2986 : #ifdef WITH_TSC
2987 : x = call_function(&sp, oparg, &intr0, &intr1);
2988 : #else
2989 222177 : x = call_function(&sp, oparg);
2990 : #endif
2991 222177 : stack_pointer = sp;
2992 222177 : PUSH(x);
2993 222177 : if (x != NULL) DISPATCH();
2994 102 : break;
2995 : }
2996 :
2997 870 : TARGET_WITH_IMPL(CALL_FUNCTION_VAR, _call_function_var_kw)
2998 0 : TARGET_WITH_IMPL(CALL_FUNCTION_KW, _call_function_var_kw)
2999 33 : TARGET(CALL_FUNCTION_VAR_KW)
3000 : _call_function_var_kw:
3001 : {
3002 903 : int na = oparg & 0xff;
3003 903 : int nk = (oparg>>8) & 0xff;
3004 903 : int flags = (opcode - CALL_FUNCTION) & 3;
3005 903 : int n = na + 2 * nk;
3006 : PyObject **pfunc, *func, **sp;
3007 : PCALL(PCALL_ALL);
3008 903 : if (flags & CALL_FLAG_VAR)
3009 903 : n++;
3010 903 : if (flags & CALL_FLAG_KW)
3011 33 : n++;
3012 903 : pfunc = stack_pointer - n - 1;
3013 903 : func = *pfunc;
3014 :
3015 903 : if (PyMethod_Check(func)
3016 1722 : && PyMethod_GET_SELF(func) != NULL) {
3017 861 : PyObject *self = PyMethod_GET_SELF(func);
3018 861 : Py_INCREF(self);
3019 861 : func = PyMethod_GET_FUNCTION(func);
3020 861 : Py_INCREF(func);
3021 861 : Py_DECREF(*pfunc);
3022 861 : *pfunc = self;
3023 861 : na++;
3024 : } else
3025 42 : Py_INCREF(func);
3026 903 : sp = stack_pointer;
3027 : READ_TIMESTAMP(intr0);
3028 903 : x = ext_do_call(func, &sp, flags, na, nk);
3029 : READ_TIMESTAMP(intr1);
3030 903 : stack_pointer = sp;
3031 903 : Py_DECREF(func);
3032 :
3033 1848 : while (stack_pointer > pfunc) {
3034 42 : w = POP();
3035 42 : Py_DECREF(w);
3036 : }
3037 903 : PUSH(x);
3038 903 : if (x != NULL) DISPATCH();
3039 0 : break;
3040 : }
3041 :
3042 :
3043 6989 : TARGET(MAKE_FUNCTION)
3044 : {
3045 6989 : v = POP(); /* code object */
3046 6989 : x = PyFunction_New(v, f->f_globals);
3047 6989 : Py_DECREF(v);
3048 : /* XXX Maybe this should be a separate opcode? */
3049 6989 : if (x != NULL && oparg > 0) {
3050 1164 : v = PyTuple_New(oparg);
3051 1164 : if (v == NULL) {
3052 0 : Py_DECREF(x);
3053 0 : x = NULL;
3054 0 : break;
3055 : }
3056 4227 : while (--oparg >= 0) {
3057 1899 : w = POP();
3058 1899 : PyTuple_SET_ITEM(v, oparg, w);
3059 : }
3060 1164 : err = PyFunction_SetDefaults(x, v);
3061 1164 : Py_DECREF(v);
3062 : }
3063 6989 : PUSH(x);
3064 6989 : break;
3065 : }
3066 :
3067 84 : TARGET(MAKE_CLOSURE)
3068 : {
3069 84 : v = POP(); /* code object */
3070 84 : x = PyFunction_New(v, f->f_globals);
3071 84 : Py_DECREF(v);
3072 84 : if (x != NULL) {
3073 84 : v = POP();
3074 84 : if (PyFunction_SetClosure(x, v) != 0) {
3075 : /* Can't happen unless bytecode is corrupt. */
3076 0 : why = WHY_EXCEPTION;
3077 : }
3078 84 : Py_DECREF(v);
3079 : }
3080 84 : if (x != NULL && oparg > 0) {
3081 0 : v = PyTuple_New(oparg);
3082 0 : if (v == NULL) {
3083 0 : Py_DECREF(x);
3084 0 : x = NULL;
3085 0 : break;
3086 : }
3087 0 : while (--oparg >= 0) {
3088 0 : w = POP();
3089 0 : PyTuple_SET_ITEM(v, oparg, w);
3090 : }
3091 0 : if (PyFunction_SetDefaults(x, v) != 0) {
3092 : /* Can't happen unless
3093 : PyFunction_SetDefaults changes. */
3094 0 : why = WHY_EXCEPTION;
3095 : }
3096 0 : Py_DECREF(v);
3097 : }
3098 84 : PUSH(x);
3099 84 : break;
3100 : }
3101 :
3102 198 : TARGET(BUILD_SLICE)
3103 : {
3104 198 : if (oparg == 3)
3105 198 : w = POP();
3106 : else
3107 0 : w = NULL;
3108 198 : v = POP();
3109 198 : u = TOP();
3110 198 : x = PySlice_New(u, v, w);
3111 198 : Py_DECREF(u);
3112 198 : Py_DECREF(v);
3113 198 : Py_XDECREF(w);
3114 198 : SET_TOP(x);
3115 198 : if (x != NULL) DISPATCH();
3116 0 : break;
3117 : }
3118 :
3119 0 : TARGET(EXTENDED_ARG)
3120 : {
3121 0 : opcode = NEXTOP();
3122 0 : oparg = oparg<<16 | NEXTARG();
3123 0 : goto dispatch_opcode;
3124 : }
3125 :
3126 : #if USE_COMPUTED_GOTOS
3127 : _unknown_opcode:
3128 : #endif
3129 : default:
3130 0 : fprintf(stderr,
3131 : "XXX lineno: %d, opcode: %d\n",
3132 : PyFrame_GetLineNumber(f),
3133 : opcode);
3134 0 : PyErr_SetString(PyExc_SystemError, "unknown opcode");
3135 0 : why = WHY_EXCEPTION;
3136 0 : 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 10211 : if (why == WHY_NOT) {
3151 10175 : 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 8048 : continue; /* Normal, fast path */
3161 : #ifdef CHECKEXC
3162 : }
3163 : #endif
3164 : }
3165 2127 : why = WHY_EXCEPTION;
3166 2127 : x = Py_None;
3167 2127 : err = 0;
3168 : }
3169 :
3170 : /* Double-check exception status */
3171 :
3172 2163 : if (why == WHY_EXCEPTION || why == WHY_RERAISE) {
3173 2157 : if (!PyErr_Occurred()) {
3174 0 : PyErr_SetString(PyExc_SystemError,
3175 : "error return without exception set");
3176 0 : 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 2163 : if (why == WHY_EXCEPTION) {
3194 2154 : PyTraceBack_Here(f);
3195 :
3196 2154 : if (tstate->c_tracefunc != NULL)
3197 0 : 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 2163 : if (why == WHY_RERAISE)
3204 3 : why = WHY_EXCEPTION;
3205 :
3206 : /* Unwind stacks if a (pseudo) exception occurred */
3207 :
3208 : fast_block_end:
3209 190099 : while (why != WHY_NOT && f->f_iblock > 0) {
3210 : /* Peek at the current block. */
3211 11710 : PyTryBlock *b = &f->f_blockstack[f->f_iblock - 1];
3212 :
3213 : assert(why != WHY_YIELD);
3214 11710 : if (b->b_type == SETUP_LOOP && why == WHY_CONTINUE) {
3215 0 : why = WHY_NOT;
3216 0 : JUMPTO(PyInt_AS_LONG(retval));
3217 0 : Py_DECREF(retval);
3218 0 : break;
3219 : }
3220 :
3221 : /* Now we have to pop the block. */
3222 11710 : f->f_iblock--;
3223 :
3224 27017 : while (STACK_LEVEL() > b->b_level) {
3225 3597 : v = POP();
3226 3597 : Py_XDECREF(v);
3227 : }
3228 11710 : if (b->b_type == SETUP_LOOP && why == WHY_BREAK) {
3229 6689 : why = WHY_NOT;
3230 6689 : JUMPTO(b->b_handler);
3231 6689 : break;
3232 : }
3233 10042 : if (b->b_type == SETUP_FINALLY ||
3234 8242 : (b->b_type == SETUP_EXCEPT &&
3235 4049 : why == WHY_EXCEPTION) ||
3236 4049 : b->b_type == SETUP_WITH) {
3237 978 : if (why == WHY_EXCEPTION) {
3238 : PyObject *exc, *val, *tb;
3239 972 : PyErr_Fetch(&exc, &val, &tb);
3240 972 : if (val == NULL) {
3241 6 : val = Py_None;
3242 6 : 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 972 : if (b->b_type == SETUP_EXCEPT ||
3250 0 : b->b_type == SETUP_WITH) {
3251 972 : PyErr_NormalizeException(
3252 : &exc, &val, &tb);
3253 972 : set_exc_info(tstate,
3254 : exc, val, tb);
3255 : }
3256 972 : if (tb == NULL) {
3257 0 : Py_INCREF(Py_None);
3258 0 : PUSH(Py_None);
3259 : } else
3260 972 : PUSH(tb);
3261 972 : PUSH(val);
3262 972 : PUSH(exc);
3263 : }
3264 : else {
3265 6 : if (why & (WHY_RETURN | WHY_CONTINUE))
3266 6 : PUSH(retval);
3267 6 : v = PyInt_FromLong((long)why);
3268 6 : PUSH(v);
3269 : }
3270 978 : why = WHY_NOT;
3271 978 : JUMPTO(b->b_handler);
3272 978 : break;
3273 : }
3274 : } /* unwind stack */
3275 :
3276 : /* End the loop if we still have an error (or return) */
3277 :
3278 93028 : if (why != WHY_NOT)
3279 85361 : break;
3280 : READ_TIMESTAMP(loop1);
3281 :
3282 30408 : } /* main loop */
3283 :
3284 : assert(why != WHY_YIELD);
3285 : /* Pop remaining stack entries. */
3286 171880 : while (!EMPTY()) {
3287 1158 : v = POP();
3288 1158 : Py_XDECREF(v);
3289 : }
3290 :
3291 85361 : if (why != WHY_RETURN)
3292 1185 : retval = NULL;
3293 :
3294 : fast_yield:
3295 91550 : if (tstate->use_tracing) {
3296 0 : if (tstate->c_tracefunc) {
3297 0 : if (why == WHY_RETURN || why == WHY_YIELD) {
3298 0 : if (call_trace(tstate->c_tracefunc,
3299 : tstate->c_traceobj, f,
3300 : PyTrace_RETURN, retval)) {
3301 0 : Py_XDECREF(retval);
3302 0 : retval = NULL;
3303 0 : why = WHY_EXCEPTION;
3304 : }
3305 : }
3306 0 : else if (why == WHY_EXCEPTION) {
3307 0 : call_trace_protected(tstate->c_tracefunc,
3308 : tstate->c_traceobj, f,
3309 : PyTrace_RETURN, NULL);
3310 : }
3311 : }
3312 0 : if (tstate->c_profilefunc) {
3313 0 : if (why == WHY_EXCEPTION)
3314 0 : call_trace_protected(tstate->c_profilefunc,
3315 : tstate->c_profileobj, f,
3316 : PyTrace_RETURN, NULL);
3317 0 : else if (call_trace(tstate->c_profilefunc,
3318 : tstate->c_profileobj, f,
3319 : PyTrace_RETURN, retval)) {
3320 0 : Py_XDECREF(retval);
3321 0 : retval = NULL;
3322 0 : why = WHY_EXCEPTION;
3323 : }
3324 : }
3325 : }
3326 :
3327 91550 : if (tstate->frame->f_exc_type != NULL)
3328 972 : 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 91550 : Py_LeaveRecursiveCall();
3337 91550 : tstate->frame = f->f_back;
3338 :
3339 91550 : 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 *
3347 37433 : 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 37433 : register PyObject *retval = NULL;
3353 : register PyObject **fastlocals, **freevars;
3354 37433 : PyThreadState *tstate = PyThreadState_GET();
3355 : PyObject *x, *u;
3356 :
3357 37433 : if (globals == NULL) {
3358 0 : PyErr_SetString(PyExc_SystemError,
3359 : "PyEval_EvalCodeEx: NULL globals");
3360 0 : return NULL;
3361 : }
3362 :
3363 : assert(tstate != NULL);
3364 : assert(globals != NULL);
3365 37433 : f = PyFrame_New(tstate, co, globals, locals);
3366 37433 : if (f == NULL)
3367 0 : return NULL;
3368 :
3369 37433 : fastlocals = f->f_localsplus;
3370 37433 : freevars = f->f_localsplus + co->co_nlocals;
3371 :
3372 40568 : if (co->co_argcount > 0 ||
3373 39560 : co->co_flags & (CO_VARARGS | CO_VARKEYWORDS)) {
3374 : int i;
3375 36425 : int n = argcount;
3376 36425 : PyObject *kwdict = NULL;
3377 36425 : if (co->co_flags & CO_VARKEYWORDS) {
3378 224 : kwdict = PyDict_New();
3379 224 : if (kwdict == NULL)
3380 0 : goto fail;
3381 224 : i = co->co_argcount;
3382 224 : if (co->co_flags & CO_VARARGS)
3383 224 : i++;
3384 224 : SETLOCAL(i, kwdict);
3385 : }
3386 36425 : if (argcount > co->co_argcount) {
3387 3197 : if (!(co->co_flags & CO_VARARGS)) {
3388 0 : 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 0 : co->co_argcount == 1 ? "" : "s",
3395 : argcount + kwcount);
3396 0 : goto fail;
3397 : }
3398 3197 : n = co->co_argcount;
3399 : }
3400 108906 : for (i = 0; i < n; i++) {
3401 72481 : x = args[i];
3402 72481 : Py_INCREF(x);
3403 72481 : SETLOCAL(i, x);
3404 : }
3405 36425 : if (co->co_flags & CO_VARARGS) {
3406 3299 : u = PyTuple_New(argcount - n);
3407 3299 : if (u == NULL)
3408 0 : goto fail;
3409 3299 : SETLOCAL(co->co_argcount, u);
3410 8998 : for (i = n; i < argcount; i++) {
3411 5699 : x = args[i];
3412 5699 : Py_INCREF(x);
3413 5699 : PyTuple_SET_ITEM(u, i-n, x);
3414 : }
3415 : }
3416 38213 : for (i = 0; i < kwcount; i++) {
3417 : PyObject **co_varnames;
3418 1788 : PyObject *keyword = kws[2*i];
3419 1788 : PyObject *value = kws[2*i + 1];
3420 : int j;
3421 1788 : if (keyword == NULL || !(PyString_Check(keyword)
3422 : #ifdef Py_USING_UNICODE
3423 0 : || PyUnicode_Check(keyword)
3424 : #endif
3425 : )) {
3426 0 : PyErr_Format(PyExc_TypeError,
3427 : "%.200s() keywords must be strings",
3428 : PyString_AsString(co->co_name));
3429 0 : goto fail;
3430 : }
3431 : /* Speed hack: do raw pointer compares. As names are
3432 : normally interned this should almost always hit. */
3433 1788 : co_varnames = ((PyTupleObject *)(co->co_varnames))->ob_item;
3434 6711 : for (j = 0; j < co->co_argcount; j++) {
3435 6477 : PyObject *nm = co_varnames[j];
3436 6477 : if (nm == keyword)
3437 1554 : goto kw_found;
3438 : }
3439 : /* Slow fallback, just in case */
3440 468 : for (j = 0; j < co->co_argcount; j++) {
3441 234 : PyObject *nm = co_varnames[j];
3442 234 : int cmp = PyObject_RichCompareBool(
3443 : keyword, nm, Py_EQ);
3444 234 : if (cmp > 0)
3445 0 : goto kw_found;
3446 234 : else if (cmp < 0)
3447 0 : goto fail;
3448 : }
3449 234 : if (kwdict == NULL) {
3450 0 : PyObject *kwd_str = kwd_as_string(keyword);
3451 0 : if (kwd_str) {
3452 0 : 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 0 : Py_DECREF(kwd_str);
3458 : }
3459 0 : goto fail;
3460 : }
3461 234 : PyDict_SetItem(kwdict, keyword, value);
3462 234 : continue;
3463 : kw_found:
3464 1554 : if (GETLOCAL(j) != NULL) {
3465 0 : PyObject *kwd_str = kwd_as_string(keyword);
3466 0 : if (kwd_str) {
3467 0 : 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 0 : Py_DECREF(kwd_str);
3474 : }
3475 0 : goto fail;
3476 : }
3477 1554 : Py_INCREF(value);
3478 1554 : SETLOCAL(j, value);
3479 : }
3480 36425 : if (argcount < co->co_argcount) {
3481 11249 : int m = co->co_argcount - defcount;
3482 11258 : for (i = argcount; i < m; i++) {
3483 9 : if (GETLOCAL(i) == NULL) {
3484 0 : int j, given = 0;
3485 0 : for (j = 0; j < co->co_argcount; j++)
3486 0 : if (GETLOCAL(j))
3487 0 : given++;
3488 0 : PyErr_Format(PyExc_TypeError,
3489 : "%.200s() takes %s %d "
3490 : "argument%s (%d given)",
3491 : PyString_AsString(co->co_name),
3492 0 : ((co->co_flags & CO_VARARGS) ||
3493 : defcount) ? "at least"
3494 : : "exactly",
3495 : m, m == 1 ? "" : "s", given);
3496 0 : goto fail;
3497 : }
3498 : }
3499 11249 : if (n > m)
3500 1470 : i = n - m;
3501 : else
3502 9779 : i = 0;
3503 23797 : for (; i < defcount; i++) {
3504 12548 : if (GETLOCAL(m+i) == NULL) {
3505 11003 : PyObject *def = defs[i];
3506 11003 : Py_INCREF(def);
3507 11003 : SETLOCAL(m+i, def);
3508 : }
3509 : }
3510 : }
3511 : }
3512 1008 : else if (argcount > 0 || kwcount > 0) {
3513 0 : PyErr_Format(PyExc_TypeError,
3514 : "%.200s() takes no arguments (%d given)",
3515 : PyString_AsString(co->co_name),
3516 : argcount + kwcount);
3517 0 : 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 37433 : if (PyTuple_GET_SIZE(co->co_cellvars)) {
3522 : int i, j, nargs, found;
3523 : char *cellname, *argname;
3524 : PyObject *c;
3525 :
3526 12 : nargs = co->co_argcount;
3527 12 : if (co->co_flags & CO_VARARGS)
3528 0 : nargs++;
3529 12 : if (co->co_flags & CO_VARKEYWORDS)
3530 0 : 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 24 : for (i = 0; i < PyTuple_GET_SIZE(co->co_cellvars); ++i) {
3540 12 : cellname = PyString_AS_STRING(
3541 : PyTuple_GET_ITEM(co->co_cellvars, i));
3542 12 : found = 0;
3543 24 : for (j = 0; j < nargs; j++) {
3544 15 : argname = PyString_AS_STRING(
3545 : PyTuple_GET_ITEM(co->co_varnames, j));
3546 15 : if (strcmp(cellname, argname) == 0) {
3547 3 : c = PyCell_New(GETLOCAL(j));
3548 3 : if (c == NULL)
3549 0 : goto fail;
3550 3 : GETLOCAL(co->co_nlocals + i) = c;
3551 3 : found = 1;
3552 3 : break;
3553 : }
3554 : }
3555 12 : if (found == 0) {
3556 9 : c = PyCell_New(NULL);
3557 9 : if (c == NULL)
3558 0 : goto fail;
3559 9 : SETLOCAL(co->co_nlocals + i, c);
3560 : }
3561 : }
3562 : }
3563 37433 : if (PyTuple_GET_SIZE(co->co_freevars)) {
3564 : int i;
3565 168 : for (i = 0; i < PyTuple_GET_SIZE(co->co_freevars); ++i) {
3566 84 : PyObject *o = PyTuple_GET_ITEM(closure, i);
3567 84 : Py_INCREF(o);
3568 84 : freevars[PyTuple_GET_SIZE(co->co_cellvars) + i] = o;
3569 : }
3570 : }
3571 :
3572 37433 : 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 426 : 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 426 : return PyGen_New(f);
3582 : }
3583 :
3584 37007 : 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 37007 : ++tstate->recursion_depth;
3595 37007 : Py_DECREF(f);
3596 37007 : --tstate->recursion_depth;
3597 37007 : return retval;
3598 : }
3599 :
3600 :
3601 : static PyObject *
3602 150 : special_lookup(PyObject *o, char *meth, PyObject **cache)
3603 : {
3604 : PyObject *res;
3605 150 : if (PyInstance_Check(o)) {
3606 0 : if (!*cache)
3607 0 : return PyObject_GetAttrString(o, meth);
3608 : else
3609 0 : return PyObject_GetAttr(o, *cache);
3610 : }
3611 150 : res = _PyObject_LookupSpecial(o, meth, cache);
3612 150 : if (res == NULL && !PyErr_Occurred()) {
3613 0 : PyErr_SetObject(PyExc_AttributeError, *cache);
3614 0 : return NULL;
3615 : }
3616 150 : return res;
3617 : }
3618 :
3619 :
3620 : static PyObject *
3621 0 : kwd_as_string(PyObject *kwd) {
3622 : #ifdef Py_USING_UNICODE
3623 0 : if (PyString_Check(kwd)) {
3624 : #else
3625 : assert(PyString_Check(kwd));
3626 : #endif
3627 0 : Py_INCREF(kwd);
3628 0 : return kwd;
3629 : #ifdef Py_USING_UNICODE
3630 : }
3631 0 : 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
3699 972 : set_exc_info(PyThreadState *tstate,
3700 : PyObject *type, PyObject *value, PyObject *tb)
3701 : {
3702 972 : PyFrameObject *frame = tstate->frame;
3703 : PyObject *tmp_type, *tmp_value, *tmp_tb;
3704 :
3705 : assert(type != NULL);
3706 : assert(frame != NULL);
3707 972 : 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 972 : if (tstate->exc_type == NULL) {
3713 : /* XXX Why is this set to Py_None? */
3714 3 : Py_INCREF(Py_None);
3715 3 : tstate->exc_type = Py_None;
3716 : }
3717 972 : Py_INCREF(tstate->exc_type);
3718 972 : Py_XINCREF(tstate->exc_value);
3719 972 : Py_XINCREF(tstate->exc_traceback);
3720 972 : frame->f_exc_type = tstate->exc_type;
3721 972 : frame->f_exc_value = tstate->exc_value;
3722 972 : frame->f_exc_traceback = tstate->exc_traceback;
3723 : }
3724 : /* Set new exception for this thread. */
3725 972 : tmp_type = tstate->exc_type;
3726 972 : tmp_value = tstate->exc_value;
3727 972 : tmp_tb = tstate->exc_traceback;
3728 972 : Py_INCREF(type);
3729 972 : Py_XINCREF(value);
3730 972 : Py_XINCREF(tb);
3731 972 : tstate->exc_type = type;
3732 972 : tstate->exc_value = value;
3733 972 : tstate->exc_traceback = tb;
3734 972 : Py_XDECREF(tmp_type);
3735 972 : Py_XDECREF(tmp_value);
3736 972 : Py_XDECREF(tmp_tb);
3737 : /* For b/w compatibility */
3738 972 : PySys_SetObject("exc_type", type);
3739 972 : PySys_SetObject("exc_value", value);
3740 972 : PySys_SetObject("exc_traceback", tb);
3741 972 : }
3742 :
3743 : static void
3744 972 : 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 972 : 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 972 : tmp_type = tstate->exc_type;
3759 972 : tmp_value = tstate->exc_value;
3760 972 : tmp_tb = tstate->exc_traceback;
3761 972 : Py_INCREF(frame->f_exc_type);
3762 972 : Py_XINCREF(frame->f_exc_value);
3763 972 : Py_XINCREF(frame->f_exc_traceback);
3764 972 : tstate->exc_type = frame->f_exc_type;
3765 972 : tstate->exc_value = frame->f_exc_value;
3766 972 : tstate->exc_traceback = frame->f_exc_traceback;
3767 972 : Py_XDECREF(tmp_type);
3768 972 : Py_XDECREF(tmp_value);
3769 972 : Py_XDECREF(tmp_tb);
3770 :
3771 : /* For b/w compatibility */
3772 972 : PySys_SetObject("exc_type", frame->f_exc_type);
3773 972 : PySys_SetObject("exc_value", frame->f_exc_value);
3774 972 : PySys_SetObject("exc_traceback", frame->f_exc_traceback);
3775 :
3776 : /* Clear the frame's exception info. */
3777 972 : tmp_type = frame->f_exc_type;
3778 972 : tmp_value = frame->f_exc_value;
3779 972 : tmp_tb = frame->f_exc_traceback;
3780 972 : frame->f_exc_type = NULL;
3781 972 : frame->f_exc_value = NULL;
3782 972 : frame->f_exc_traceback = NULL;
3783 972 : Py_DECREF(tmp_type);
3784 972 : Py_XDECREF(tmp_value);
3785 972 : Py_XDECREF(tmp_tb);
3786 972 : }
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
3791 24 : do_raise(PyObject *type, PyObject *value, PyObject *tb)
3792 : {
3793 24 : if (type == NULL) {
3794 : /* Reraise */
3795 0 : PyThreadState *tstate = PyThreadState_GET();
3796 0 : type = tstate->exc_type == NULL ? Py_None : tstate->exc_type;
3797 0 : value = tstate->exc_value;
3798 0 : tb = tstate->exc_traceback;
3799 0 : Py_XINCREF(type);
3800 0 : Py_XINCREF(value);
3801 0 : 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 24 : if (tb == Py_None) {
3826 0 : Py_DECREF(tb);
3827 0 : tb = NULL;
3828 : }
3829 24 : else if (tb != NULL && !PyTraceBack_Check(tb)) {
3830 0 : PyErr_SetString(PyExc_TypeError,
3831 : "raise: arg 3 must be a traceback or None");
3832 0 : goto raise_error;
3833 : }
3834 :
3835 : /* Next, replace a missing value with None */
3836 24 : if (value == NULL) {
3837 24 : value = Py_None;
3838 24 : Py_INCREF(value);
3839 : }
3840 :
3841 : /* Next, repeatedly, replace a tuple exception with its first item */
3842 48 : while (PyTuple_Check(type) && PyTuple_Size(type) > 0) {
3843 0 : PyObject *tmp = type;
3844 0 : type = PyTuple_GET_ITEM(type, 0);
3845 0 : Py_INCREF(type);
3846 0 : Py_DECREF(tmp);
3847 : }
3848 :
3849 24 : if (PyExceptionClass_Check(type)) {
3850 3 : PyErr_NormalizeException(&type, &value, &tb);
3851 6 : if (!PyExceptionInstance_Check(value)) {
3852 0 : PyErr_Format(PyExc_TypeError,
3853 : "calling %s() should have returned an instance of "
3854 : "BaseException, not '%s'",
3855 0 : ((PyTypeObject *)type)->tp_name,
3856 0 : Py_TYPE(value)->tp_name);
3857 0 : goto raise_error;
3858 : }
3859 : }
3860 21 : else if (PyExceptionInstance_Check(type)) {
3861 : /* Raising an instance. The value should be a dummy. */
3862 42 : if (value != Py_None) {
3863 0 : PyErr_SetString(PyExc_TypeError,
3864 : "instance exception may not have a separate value");
3865 0 : goto raise_error;
3866 : }
3867 : else {
3868 : /* Normalize to raise <class>, <instance> */
3869 21 : Py_DECREF(value);
3870 21 : value = type;
3871 21 : type = PyExceptionInstance_Class(type);
3872 21 : 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 0 : PyErr_Format(PyExc_TypeError,
3879 : "exceptions must be old-style classes or "
3880 : "derived from BaseException, not %s",
3881 0 : type->ob_type->tp_name);
3882 0 : goto raise_error;
3883 : }
3884 :
3885 : assert(PyExceptionClass_Check(type));
3886 24 : if (Py_Py3kWarningFlag && PyClass_Check(type)) {
3887 0 : if (PyErr_WarnEx(PyExc_DeprecationWarning,
3888 : "exceptions must derive from BaseException "
3889 : "in 3.x", 1) < 0)
3890 0 : goto raise_error;
3891 : }
3892 :
3893 24 : PyErr_Restore(type, value, tb);
3894 24 : if (tb == NULL)
3895 24 : return WHY_EXCEPTION;
3896 : else
3897 0 : return WHY_RERAISE;
3898 : raise_error:
3899 0 : Py_XDECREF(value);
3900 0 : Py_XDECREF(type);
3901 0 : Py_XDECREF(tb);
3902 0 : 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
3909 0 : unpack_iterable(PyObject *v, int argcnt, PyObject **sp)
3910 : {
3911 0 : int i = 0;
3912 : PyObject *it; /* iter(v) */
3913 : PyObject *w;
3914 :
3915 : assert(v != NULL);
3916 :
3917 0 : it = PyObject_GetIter(v);
3918 0 : if (it == NULL)
3919 0 : goto Error;
3920 :
3921 0 : for (; i < argcnt; i++) {
3922 0 : w = PyIter_Next(it);
3923 0 : if (w == NULL) {
3924 : /* Iterator done, via error or exhaustion. */
3925 0 : if (!PyErr_Occurred()) {
3926 0 : PyErr_Format(PyExc_ValueError,
3927 : "need more than %d value%s to unpack",
3928 : i, i == 1 ? "" : "s");
3929 : }
3930 0 : goto Error;
3931 : }
3932 0 : *--sp = w;
3933 : }
3934 :
3935 : /* We better have exhausted the iterator now. */
3936 0 : w = PyIter_Next(it);
3937 0 : if (w == NULL) {
3938 0 : if (PyErr_Occurred())
3939 0 : goto Error;
3940 0 : Py_DECREF(it);
3941 0 : return 1;
3942 : }
3943 0 : Py_DECREF(w);
3944 0 : PyErr_SetString(PyExc_ValueError, "too many values to unpack");
3945 : /* fall through */
3946 : Error:
3947 0 : for (; i > 0; i--, sp++)
3948 0 : Py_DECREF(*sp);
3949 0 : Py_XDECREF(it);
3950 0 : return 0;
3951 : }
3952 :
3953 :
3954 : #ifdef LLTRACE
3955 : static int
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
3967 0 : call_exc_trace(Py_tracefunc func, PyObject *self, PyFrameObject *f)
3968 : {
3969 : PyObject *type, *value, *traceback, *arg;
3970 : int err;
3971 0 : PyErr_Fetch(&type, &value, &traceback);
3972 0 : if (value == NULL) {
3973 0 : value = Py_None;
3974 0 : Py_INCREF(value);
3975 : }
3976 0 : arg = PyTuple_Pack(3, type, value, traceback);
3977 0 : if (arg == NULL) {
3978 0 : PyErr_Restore(type, value, traceback);
3979 0 : return;
3980 : }
3981 0 : err = call_trace(func, self, f, PyTrace_EXCEPTION, arg);
3982 0 : Py_DECREF(arg);
3983 0 : if (err == 0)
3984 0 : PyErr_Restore(type, value, traceback);
3985 : else {
3986 0 : Py_XDECREF(type);
3987 0 : Py_XDECREF(value);
3988 0 : Py_XDECREF(traceback);
3989 : }
3990 : }
3991 :
3992 : static int
3993 0 : 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 0 : PyErr_Fetch(&type, &value, &traceback);
3999 0 : err = call_trace(func, obj, frame, what, arg);
4000 0 : if (err == 0)
4001 : {
4002 0 : PyErr_Restore(type, value, traceback);
4003 0 : return 0;
4004 : }
4005 : else {
4006 0 : Py_XDECREF(type);
4007 0 : Py_XDECREF(value);
4008 0 : Py_XDECREF(traceback);
4009 0 : return -1;
4010 : }
4011 : }
4012 :
4013 : static int
4014 0 : call_trace(Py_tracefunc func, PyObject *obj, PyFrameObject *frame,
4015 : int what, PyObject *arg)
4016 : {
4017 0 : register PyThreadState *tstate = frame->f_tstate;
4018 : int result;
4019 0 : if (tstate->tracing)
4020 0 : return 0;
4021 0 : tstate->tracing++;
4022 0 : tstate->use_tracing = 0;
4023 0 : result = func(obj, frame, what, arg);
4024 0 : tstate->use_tracing = ((tstate->c_tracefunc != NULL)
4025 0 : || (tstate->c_profilefunc != NULL));
4026 0 : tstate->tracing--;
4027 0 : return result;
4028 : }
4029 :
4030 : PyObject *
4031 0 : _PyEval_CallTracing(PyObject *func, PyObject *args)
4032 : {
4033 0 : PyFrameObject *frame = PyEval_GetFrame();
4034 0 : PyThreadState *tstate = frame->f_tstate;
4035 0 : int save_tracing = tstate->tracing;
4036 0 : int save_use_tracing = tstate->use_tracing;
4037 : PyObject *result;
4038 :
4039 0 : tstate->tracing = 0;
4040 0 : tstate->use_tracing = ((tstate->c_tracefunc != NULL)
4041 0 : || (tstate->c_profilefunc != NULL));
4042 0 : result = PyObject_Call(func, args, NULL);
4043 0 : tstate->tracing = save_tracing;
4044 0 : tstate->use_tracing = save_use_tracing;
4045 0 : return result;
4046 : }
4047 :
4048 : /* See Objects/lnotab_notes.txt for a description of how tracing works. */
4049 : static int
4050 0 : maybe_call_line_trace(Py_tracefunc func, PyObject *obj,
4051 : PyFrameObject *frame, int *instr_lb, int *instr_ub,
4052 : int *instr_prev)
4053 : {
4054 0 : int result = 0;
4055 0 : 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 0 : if (frame->f_lasti < *instr_lb || frame->f_lasti >= *instr_ub) {
4061 : PyAddrPair bounds;
4062 0 : line = _PyCode_CheckLineNumber(frame->f_code, frame->f_lasti,
4063 : &bounds);
4064 0 : *instr_lb = bounds.ap_lower;
4065 0 : *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 0 : if (frame->f_lasti == *instr_lb || frame->f_lasti < *instr_prev) {
4071 0 : frame->f_lineno = line;
4072 0 : result = call_trace(func, obj, frame, PyTrace_LINE, Py_None);
4073 : }
4074 0 : *instr_prev = frame->f_lasti;
4075 0 : return result;
4076 : }
4077 :
4078 : void
4079 0 : PyEval_SetProfile(Py_tracefunc func, PyObject *arg)
4080 : {
4081 0 : PyThreadState *tstate = PyThreadState_GET();
4082 0 : PyObject *temp = tstate->c_profileobj;
4083 0 : Py_XINCREF(arg);
4084 0 : tstate->c_profilefunc = NULL;
4085 0 : tstate->c_profileobj = NULL;
4086 : /* Must make sure that tracing is not ignored if 'temp' is freed */
4087 0 : tstate->use_tracing = tstate->c_tracefunc != NULL;
4088 0 : Py_XDECREF(temp);
4089 0 : tstate->c_profilefunc = func;
4090 0 : tstate->c_profileobj = arg;
4091 : /* Flag that tracing or profiling is turned on */
4092 0 : tstate->use_tracing = (func != NULL) || (tstate->c_tracefunc != NULL);
4093 0 : }
4094 :
4095 : void
4096 0 : PyEval_SetTrace(Py_tracefunc func, PyObject *arg)
4097 : {
4098 0 : PyThreadState *tstate = PyThreadState_GET();
4099 0 : PyObject *temp = tstate->c_traceobj;
4100 0 : _Py_TracingPossible += (func != NULL) - (tstate->c_tracefunc != NULL);
4101 0 : Py_XINCREF(arg);
4102 0 : tstate->c_tracefunc = NULL;
4103 0 : tstate->c_traceobj = NULL;
4104 : /* Must make sure that profiling is not ignored if 'temp' is freed */
4105 0 : tstate->use_tracing = tstate->c_profilefunc != NULL;
4106 0 : Py_XDECREF(temp);
4107 0 : tstate->c_tracefunc = func;
4108 0 : tstate->c_traceobj = arg;
4109 : /* Flag that tracing or profiling is turned on */
4110 0 : tstate->use_tracing = ((func != NULL)
4111 0 : || (tstate->c_profilefunc != NULL));
4112 0 : }
4113 :
4114 : PyObject *
4115 264 : PyEval_GetBuiltins(void)
4116 : {
4117 264 : PyFrameObject *current_frame = PyEval_GetFrame();
4118 264 : if (current_frame == NULL)
4119 3 : return PyThreadState_GET()->interp->builtins;
4120 : else
4121 261 : return current_frame->f_builtins;
4122 : }
4123 :
4124 : PyObject *
4125 0 : PyEval_GetLocals(void)
4126 : {
4127 0 : PyFrameObject *current_frame = PyEval_GetFrame();
4128 0 : if (current_frame == NULL)
4129 0 : return NULL;
4130 0 : PyFrame_FastToLocals(current_frame);
4131 0 : return current_frame->f_locals;
4132 : }
4133 :
4134 : PyObject *
4135 558 : PyEval_GetGlobals(void)
4136 : {
4137 558 : PyFrameObject *current_frame = PyEval_GetFrame();
4138 558 : if (current_frame == NULL)
4139 9 : return NULL;
4140 : else
4141 549 : return current_frame->f_globals;
4142 : }
4143 :
4144 : PyFrameObject *
4145 6880 : PyEval_GetFrame(void)
4146 : {
4147 6880 : PyThreadState *tstate = PyThreadState_GET();
4148 6880 : return _PyThreadState_GetFrame(tstate);
4149 : }
4150 :
4151 : int
4152 6031 : PyEval_GetRestricted(void)
4153 : {
4154 6031 : PyFrameObject *current_frame = PyEval_GetFrame();
4155 6031 : return current_frame == NULL ? 0 : PyFrame_IsRestricted(current_frame);
4156 : }
4157 :
4158 : int
4159 27 : PyEval_MergeCompilerFlags(PyCompilerFlags *cf)
4160 : {
4161 27 : PyFrameObject *current_frame = PyEval_GetFrame();
4162 27 : int result = cf->cf_flags != 0;
4163 :
4164 27 : if (current_frame != NULL) {
4165 27 : const int codeflags = current_frame->f_code->co_flags;
4166 27 : const int compilerflags = codeflags & PyCF_MASK;
4167 27 : if (compilerflags) {
4168 0 : result = 1;
4169 0 : 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 27 : return result;
4179 : }
4180 :
4181 : int
4182 6 : Py_FlushLine(void)
4183 : {
4184 6 : PyObject *f = PySys_GetObject("stdout");
4185 6 : if (f == NULL)
4186 0 : return 0;
4187 6 : if (!PyFile_SoftSpace(f, 0))
4188 6 : return 0;
4189 0 : 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 *
4197 15202 : PyEval_CallObjectWithKeywords(PyObject *func, PyObject *arg, PyObject *kw)
4198 : {
4199 : PyObject *result;
4200 :
4201 15202 : if (arg == NULL) {
4202 3577 : arg = PyTuple_New(0);
4203 3577 : if (arg == NULL)
4204 0 : return NULL;
4205 : }
4206 11625 : else if (!PyTuple_Check(arg)) {
4207 0 : PyErr_SetString(PyExc_TypeError,
4208 : "argument list must be a tuple");
4209 0 : return NULL;
4210 : }
4211 : else
4212 11625 : Py_INCREF(arg);
4213 :
4214 15202 : if (kw != NULL && !PyDict_Check(kw)) {
4215 0 : PyErr_SetString(PyExc_TypeError,
4216 : "keyword list must be a dictionary");
4217 0 : Py_DECREF(arg);
4218 0 : return NULL;
4219 : }
4220 :
4221 15202 : result = PyObject_Call(func, arg, kw);
4222 15202 : Py_DECREF(arg);
4223 15202 : return result;
4224 : }
4225 :
4226 : const char *
4227 0 : PyEval_GetFuncName(PyObject *func)
4228 : {
4229 0 : if (PyMethod_Check(func))
4230 0 : return PyEval_GetFuncName(PyMethod_GET_FUNCTION(func));
4231 0 : else if (PyFunction_Check(func))
4232 0 : return PyString_AsString(((PyFunctionObject*)func)->func_name);
4233 0 : else if (PyCFunction_Check(func))
4234 0 : return ((PyCFunctionObject*)func)->m_ml->ml_name;
4235 0 : else if (PyClass_Check(func))
4236 0 : return PyString_AsString(((PyClassObject*)func)->cl_name);
4237 0 : else if (PyInstance_Check(func)) {
4238 0 : return PyString_AsString(
4239 0 : ((PyInstanceObject*)func)->in_class->cl_name);
4240 : } else {
4241 0 : return func->ob_type->tp_name;
4242 : }
4243 : }
4244 :
4245 : const char *
4246 0 : PyEval_GetFuncDesc(PyObject *func)
4247 : {
4248 0 : if (PyMethod_Check(func))
4249 0 : return "()";
4250 0 : else if (PyFunction_Check(func))
4251 0 : return "()";
4252 0 : else if (PyCFunction_Check(func))
4253 0 : return "()";
4254 0 : else if (PyClass_Check(func))
4255 0 : return " constructor";
4256 0 : else if (PyInstance_Check(func)) {
4257 0 : return " instance";
4258 : } else {
4259 0 : return " object";
4260 : }
4261 : }
4262 :
4263 : static void
4264 0 : err_args(PyObject *func, int flags, int nargs)
4265 : {
4266 0 : if (flags & METH_NOARGS)
4267 0 : PyErr_Format(PyExc_TypeError,
4268 : "%.200s() takes no arguments (%d given)",
4269 0 : ((PyCFunctionObject *)func)->m_ml->ml_name,
4270 : nargs);
4271 : else
4272 0 : PyErr_Format(PyExc_TypeError,
4273 : "%.200s() takes exactly one argument (%d given)",
4274 0 : ((PyCFunctionObject *)func)->m_ml->ml_name,
4275 : nargs);
4276 0 : }
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 *
4311 222177 : call_function(PyObject ***pp_stack, int oparg
4312 : #ifdef WITH_TSC
4313 : , uint64* pintr0, uint64* pintr1
4314 : #endif
4315 : )
4316 : {
4317 222177 : int na = oparg & 0xff;
4318 222177 : int nk = (oparg>>8) & 0xff;
4319 222177 : int n = na + 2 * nk;
4320 222177 : PyObject **pfunc = (*pp_stack) - n - 1;
4321 222177 : 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 358301 : if (PyCFunction_Check(func) && nk == 0) {
4328 136124 : int flags = PyCFunction_GET_FLAGS(func);
4329 136124 : PyThreadState *tstate = PyThreadState_GET();
4330 :
4331 : PCALL(PCALL_CFUNCTION);
4332 136124 : if (flags & (METH_NOARGS | METH_O)) {
4333 88990 : PyCFunction meth = PyCFunction_GET_FUNCTION(func);
4334 88990 : PyObject *self = PyCFunction_GET_SELF(func);
4335 88990 : if (flags & METH_NOARGS && na == 0) {
4336 6380 : C_TRACE(x, (*meth)(self,NULL));
4337 : }
4338 165220 : else if (flags & METH_O && na == 1) {
4339 82610 : PyObject *arg = EXT_POP(*pp_stack);
4340 82610 : C_TRACE(x, (*meth)(self,arg));
4341 82610 : Py_DECREF(arg);
4342 : }
4343 : else {
4344 0 : err_args(func, flags, na);
4345 0 : x = NULL;
4346 : }
4347 : }
4348 : else {
4349 : PyObject *callargs;
4350 47134 : callargs = load_args(pp_stack, na);
4351 : READ_TIMESTAMP(*pintr0);
4352 47134 : C_TRACE(x, PyCFunction_Call(func,callargs,NULL));
4353 : READ_TIMESTAMP(*pintr1);
4354 47134 : Py_XDECREF(callargs);
4355 : }
4356 : } else {
4357 127028 : if (PyMethod_Check(func) && PyMethod_GET_SELF(func) != NULL) {
4358 : /* optimize access to bound methods */
4359 40975 : PyObject *self = PyMethod_GET_SELF(func);
4360 : PCALL(PCALL_METHOD);
4361 : PCALL(PCALL_BOUND_METHOD);
4362 40975 : Py_INCREF(self);
4363 40975 : func = PyMethod_GET_FUNCTION(func);
4364 40975 : Py_INCREF(func);
4365 40975 : Py_SETREF(*pfunc, self);
4366 40975 : na++;
4367 40975 : n++;
4368 : } else
4369 45078 : Py_INCREF(func);
4370 : READ_TIMESTAMP(*pintr0);
4371 86053 : if (PyFunction_Check(func))
4372 63610 : x = fast_function(func, pp_stack, n, na, nk);
4373 : else
4374 22443 : x = do_call(func, pp_stack, na, nk);
4375 : READ_TIMESTAMP(*pintr1);
4376 86053 : 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 727331 : while ((*pp_stack) > pfunc) {
4384 282977 : w = EXT_POP(*pp_stack);
4385 282977 : Py_DECREF(w);
4386 : PCALL(PCALL_POP);
4387 : }
4388 222177 : 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 *
4401 63610 : fast_function(PyObject *func, PyObject ***pp_stack, int n, int na, int nk)
4402 : {
4403 63610 : PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
4404 63610 : PyObject *globals = PyFunction_GET_GLOBALS(func);
4405 63610 : PyObject *argdefs = PyFunction_GET_DEFAULTS(func);
4406 63610 : PyObject **d = NULL;
4407 63610 : int nd = 0;
4408 :
4409 : PCALL(PCALL_FUNCTION);
4410 : PCALL(PCALL_FAST_FUNCTION);
4411 113117 : if (argdefs == NULL && co->co_argcount == n && nk==0 &&
4412 49507 : co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) {
4413 : PyFrameObject *f;
4414 47928 : PyObject *retval = NULL;
4415 47928 : 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 47928 : f = PyFrame_New(tstate, co, globals, NULL);
4427 47928 : if (f == NULL)
4428 0 : return NULL;
4429 :
4430 47928 : fastlocals = f->f_localsplus;
4431 47928 : stack = (*pp_stack) - n;
4432 :
4433 117353 : for (i = 0; i < n; i++) {
4434 69425 : Py_INCREF(*stack);
4435 69425 : fastlocals[i] = *stack++;
4436 : }
4437 47928 : retval = PyEval_EvalFrameEx(f,0);
4438 47928 : ++tstate->recursion_depth;
4439 47928 : Py_DECREF(f);
4440 47928 : --tstate->recursion_depth;
4441 47928 : return retval;
4442 : }
4443 15682 : if (argdefs != NULL) {
4444 11094 : d = &PyTuple_GET_ITEM(argdefs, 0);
4445 11094 : nd = Py_SIZE(argdefs);
4446 : }
4447 47046 : return PyEval_EvalCodeEx(co, globals,
4448 15682 : (PyObject *)NULL, (*pp_stack)-n, na,
4449 15682 : (*pp_stack)-2*nk, nk, d, nd,
4450 : PyFunction_GET_CLOSURE(func));
4451 : }
4452 :
4453 : static PyObject *
4454 1112 : update_keyword_args(PyObject *orig_kwdict, int nk, PyObject ***pp_stack,
4455 : PyObject *func)
4456 : {
4457 1112 : PyObject *kwdict = NULL;
4458 1112 : if (orig_kwdict == NULL)
4459 1112 : kwdict = PyDict_New();
4460 : else {
4461 0 : kwdict = PyDict_Copy(orig_kwdict);
4462 0 : Py_DECREF(orig_kwdict);
4463 : }
4464 1112 : if (kwdict == NULL)
4465 0 : return NULL;
4466 4496 : while (--nk >= 0) {
4467 : int err;
4468 2272 : PyObject *value = EXT_POP(*pp_stack);
4469 2272 : PyObject *key = EXT_POP(*pp_stack);
4470 2272 : if (PyDict_GetItem(kwdict, key) != NULL) {
4471 0 : 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 0 : Py_DECREF(key);
4478 0 : Py_DECREF(value);
4479 0 : Py_DECREF(kwdict);
4480 0 : return NULL;
4481 : }
4482 2272 : err = PyDict_SetItem(kwdict, key, value);
4483 2272 : Py_DECREF(key);
4484 2272 : Py_DECREF(value);
4485 2272 : if (err) {
4486 0 : Py_DECREF(kwdict);
4487 0 : return NULL;
4488 : }
4489 : }
4490 1112 : return kwdict;
4491 : }
4492 :
4493 : static PyObject *
4494 903 : update_star_args(int nstack, int nstar, PyObject *stararg,
4495 : PyObject ***pp_stack)
4496 : {
4497 : PyObject *callargs, *w;
4498 :
4499 903 : callargs = PyTuple_New(nstack + nstar);
4500 903 : if (callargs == NULL) {
4501 0 : return NULL;
4502 : }
4503 903 : if (nstar) {
4504 : int i;
4505 1641 : for (i = 0; i < nstar; i++) {
4506 822 : PyObject *a = PyTuple_GET_ITEM(stararg, i);
4507 822 : Py_INCREF(a);
4508 822 : PyTuple_SET_ITEM(callargs, nstack + i, a);
4509 : }
4510 : }
4511 3528 : while (--nstack >= 0) {
4512 1722 : w = EXT_POP(*pp_stack);
4513 1722 : PyTuple_SET_ITEM(callargs, nstack, w);
4514 : }
4515 903 : return callargs;
4516 : }
4517 :
4518 : static PyObject *
4519 69577 : load_args(PyObject ***pp_stack, int na)
4520 : {
4521 69577 : PyObject *args = PyTuple_New(na);
4522 : PyObject *w;
4523 :
4524 69577 : if (args == NULL)
4525 0 : return NULL;
4526 253203 : while (--na >= 0) {
4527 114049 : w = EXT_POP(*pp_stack);
4528 114049 : PyTuple_SET_ITEM(args, na, w);
4529 : }
4530 69577 : return args;
4531 : }
4532 :
4533 : static PyObject *
4534 22443 : do_call(PyObject *func, PyObject ***pp_stack, int na, int nk)
4535 : {
4536 22443 : PyObject *callargs = NULL;
4537 22443 : PyObject *kwdict = NULL;
4538 22443 : PyObject *result = NULL;
4539 :
4540 22443 : if (nk > 0) {
4541 1112 : kwdict = update_keyword_args(NULL, nk, pp_stack, func);
4542 1112 : if (kwdict == NULL)
4543 0 : goto call_fail;
4544 : }
4545 22443 : callargs = load_args(pp_stack, na);
4546 22443 : if (callargs == NULL)
4547 0 : 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 22443 : if (PyCFunction_Check(func)) {
4565 291 : PyThreadState *tstate = PyThreadState_GET();
4566 291 : C_TRACE(result, PyCFunction_Call(func, callargs, kwdict));
4567 : }
4568 : else
4569 22152 : result = PyObject_Call(func, callargs, kwdict);
4570 : call_fail:
4571 22443 : Py_XDECREF(callargs);
4572 22443 : Py_XDECREF(kwdict);
4573 22443 : return result;
4574 : }
4575 :
4576 : static PyObject *
4577 903 : ext_do_call(PyObject *func, PyObject ***pp_stack, int flags, int na, int nk)
4578 : {
4579 903 : int nstar = 0;
4580 903 : PyObject *callargs = NULL;
4581 903 : PyObject *stararg = NULL;
4582 903 : PyObject *kwdict = NULL;
4583 903 : PyObject *result = NULL;
4584 :
4585 903 : if (flags & CALL_FLAG_KW) {
4586 33 : kwdict = EXT_POP(*pp_stack);
4587 33 : if (!PyDict_Check(kwdict)) {
4588 : PyObject *d;
4589 0 : d = PyDict_New();
4590 0 : if (d == NULL)
4591 0 : goto ext_call_fail;
4592 0 : if (PyDict_Update(d, kwdict) != 0) {
4593 0 : 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 0 : if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
4601 0 : 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 0 : kwdict->ob_type->tp_name);
4607 : }
4608 0 : goto ext_call_fail;
4609 : }
4610 0 : Py_DECREF(kwdict);
4611 0 : kwdict = d;
4612 : }
4613 : }
4614 903 : if (flags & CALL_FLAG_VAR) {
4615 903 : stararg = EXT_POP(*pp_stack);
4616 903 : if (!PyTuple_Check(stararg)) {
4617 0 : PyObject *t = NULL;
4618 0 : t = PySequence_Tuple(stararg);
4619 0 : if (t == NULL) {
4620 0 : if (PyErr_ExceptionMatches(PyExc_TypeError) &&
4621 : /* Don't mask TypeError raised from a generator */
4622 0 : !PyGen_Check(stararg)) {
4623 0 : 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 0 : stararg->ob_type->tp_name);
4629 : }
4630 0 : goto ext_call_fail;
4631 : }
4632 0 : Py_DECREF(stararg);
4633 0 : stararg = t;
4634 : }
4635 903 : nstar = PyTuple_GET_SIZE(stararg);
4636 : }
4637 903 : if (nk > 0) {
4638 0 : kwdict = update_keyword_args(kwdict, nk, pp_stack, func);
4639 0 : if (kwdict == NULL)
4640 0 : goto ext_call_fail;
4641 : }
4642 903 : callargs = update_star_args(na, nstar, stararg, pp_stack);
4643 903 : if (callargs == NULL)
4644 0 : 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 903 : if (PyCFunction_Check(func)) {
4662 0 : PyThreadState *tstate = PyThreadState_GET();
4663 0 : C_TRACE(result, PyCFunction_Call(func, callargs, kwdict));
4664 : }
4665 : else
4666 903 : result = PyObject_Call(func, callargs, kwdict);
4667 : ext_call_fail:
4668 903 : Py_XDECREF(callargs);
4669 903 : Py_XDECREF(kwdict);
4670 903 : Py_XDECREF(stararg);
4671 903 : 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
4685 18168 : _PyEval_SliceIndex(PyObject *v, Py_ssize_t *pi)
4686 : {
4687 18168 : if (v != NULL) {
4688 : Py_ssize_t x;
4689 13107 : 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 13107 : x = PyInt_AS_LONG(v);
4695 : }
4696 0 : else if (PyIndex_Check(v)) {
4697 0 : x = PyNumber_AsSsize_t(v, NULL);
4698 0 : if (x == -1 && PyErr_Occurred())
4699 0 : return 0;
4700 : }
4701 : else {
4702 0 : PyErr_SetString(PyExc_TypeError,
4703 : "slice indices must be integers or "
4704 : "None or have an __index__ method");
4705 0 : return 0;
4706 : }
4707 13107 : *pi = x;
4708 : }
4709 18168 : 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 *
4717 7194 : apply_slice(PyObject *u, PyObject *v, PyObject *w) /* return u[v:w] */
4718 : {
4719 7194 : PyTypeObject *tp = u->ob_type;
4720 7194 : PySequenceMethods *sq = tp->tp_as_sequence;
4721 :
4722 7194 : if (sq && sq->sq_slice && ISINDEX(v) && ISINDEX(w)) {
4723 7194 : Py_ssize_t ilow = 0, ihigh = PY_SSIZE_T_MAX;
4724 7194 : if (!_PyEval_SliceIndex(v, &ilow))
4725 0 : return NULL;
4726 7194 : if (!_PyEval_SliceIndex(w, &ihigh))
4727 0 : return NULL;
4728 7194 : return PySequence_GetSlice(u, ilow, ihigh);
4729 : }
4730 : else {
4731 0 : PyObject *slice = PySlice_New(v, w, NULL);
4732 0 : if (slice != NULL) {
4733 0 : PyObject *res = PyObject_GetItem(u, slice);
4734 0 : Py_DECREF(slice);
4735 0 : return res;
4736 : }
4737 : else
4738 0 : return NULL;
4739 : }
4740 : }
4741 :
4742 : static int
4743 0 : assign_slice(PyObject *u, PyObject *v, PyObject *w, PyObject *x)
4744 : /* u[v:w] = x */
4745 : {
4746 0 : PyTypeObject *tp = u->ob_type;
4747 0 : PySequenceMethods *sq = tp->tp_as_sequence;
4748 :
4749 0 : if (sq && sq->sq_ass_slice && ISINDEX(v) && ISINDEX(w)) {
4750 0 : Py_ssize_t ilow = 0, ihigh = PY_SSIZE_T_MAX;
4751 0 : if (!_PyEval_SliceIndex(v, &ilow))
4752 0 : return -1;
4753 0 : if (!_PyEval_SliceIndex(w, &ihigh))
4754 0 : return -1;
4755 0 : if (x == NULL)
4756 0 : return PySequence_DelSlice(u, ilow, ihigh);
4757 : else
4758 0 : return PySequence_SetSlice(u, ilow, ihigh, x);
4759 : }
4760 : else {
4761 0 : PyObject *slice = PySlice_New(v, w, NULL);
4762 0 : if (slice != NULL) {
4763 : int res;
4764 0 : if (x != NULL)
4765 0 : res = PyObject_SetItem(u, slice, x);
4766 : else
4767 0 : res = PyObject_DelItem(u, slice);
4768 0 : Py_DECREF(slice);
4769 0 : return res;
4770 : }
4771 : else
4772 0 : 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 *
4784 114730 : cmp_outcome(int op, register PyObject *v, register PyObject *w)
4785 : {
4786 114730 : int res = 0;
4787 114730 : switch (op) {
4788 : case PyCmp_IS:
4789 38701 : res = (v == w);
4790 38701 : break;
4791 : case PyCmp_IS_NOT:
4792 2508 : res = (v != w);
4793 2508 : break;
4794 : case PyCmp_IN:
4795 24722 : res = PySequence_Contains(w, v);
4796 24722 : if (res < 0)
4797 0 : return NULL;
4798 24722 : break;
4799 : case PyCmp_NOT_IN:
4800 5550 : res = PySequence_Contains(w, v);
4801 5550 : if (res < 0)
4802 0 : return NULL;
4803 5550 : res = !res;
4804 5550 : break;
4805 : case PyCmp_EXC_MATCH:
4806 978 : if (PyTuple_Check(w)) {
4807 : Py_ssize_t i, length;
4808 3 : length = PyTuple_Size(w);
4809 9 : for (i = 0; i < length; i += 1) {
4810 6 : PyObject *exc = PyTuple_GET_ITEM(w, i);
4811 6 : if (PyString_Check(exc)) {
4812 : int ret_val;
4813 0 : ret_val = PyErr_WarnEx(
4814 : PyExc_DeprecationWarning,
4815 : "catching of string "
4816 : "exceptions is deprecated", 1);
4817 0 : if (ret_val < 0)
4818 0 : return NULL;
4819 : }
4820 6 : else if (Py_Py3kWarningFlag &&
4821 0 : !PyTuple_Check(exc) &&
4822 0 : !Py3kExceptionClass_Check(exc))
4823 : {
4824 : int ret_val;
4825 0 : ret_val = PyErr_WarnEx(
4826 : PyExc_DeprecationWarning,
4827 : CANNOT_CATCH_MSG, 1);
4828 0 : if (ret_val < 0)
4829 0 : return NULL;
4830 : }
4831 : }
4832 : }
4833 : else {
4834 975 : if (PyString_Check(w)) {
4835 : int ret_val;
4836 0 : ret_val = PyErr_WarnEx(
4837 : PyExc_DeprecationWarning,
4838 : "catching of string "
4839 : "exceptions is deprecated", 1);
4840 0 : if (ret_val < 0)
4841 0 : return NULL;
4842 : }
4843 975 : else if (Py_Py3kWarningFlag &&
4844 0 : !PyTuple_Check(w) &&
4845 0 : !Py3kExceptionClass_Check(w))
4846 : {
4847 : int ret_val;
4848 0 : ret_val = PyErr_WarnEx(
4849 : PyExc_DeprecationWarning,
4850 : CANNOT_CATCH_MSG, 1);
4851 0 : if (ret_val < 0)
4852 0 : return NULL;
4853 : }
4854 : }
4855 978 : res = PyErr_GivenExceptionMatches(v, w);
4856 978 : break;
4857 : default:
4858 42271 : return PyObject_RichCompare(v, w, op);
4859 : }
4860 72459 : v = res ? Py_True : Py_False;
4861 72459 : Py_INCREF(v);
4862 72459 : return v;
4863 : }
4864 :
4865 : static PyObject *
4866 864 : import_from(PyObject *v, PyObject *name)
4867 : {
4868 : PyObject *x;
4869 :
4870 864 : x = PyObject_GetAttr(v, name);
4871 864 : if (x == NULL && PyErr_ExceptionMatches(PyExc_AttributeError)) {
4872 0 : PyErr_Format(PyExc_ImportError,
4873 : "cannot import name %.230s",
4874 : PyString_AsString(name));
4875 : }
4876 864 : return x;
4877 : }
4878 :
4879 : static int
4880 33 : import_all_from(PyObject *locals, PyObject *v)
4881 : {
4882 33 : PyObject *all = PyObject_GetAttrString(v, "__all__");
4883 : PyObject *dict, *name, *value;
4884 33 : int skip_leading_underscores = 0;
4885 : int pos, err;
4886 :
4887 33 : if (all == NULL) {
4888 24 : if (!PyErr_ExceptionMatches(PyExc_AttributeError))
4889 0 : return -1; /* Unexpected error */
4890 24 : PyErr_Clear();
4891 24 : dict = PyObject_GetAttrString(v, "__dict__");
4892 24 : if (dict == NULL) {
4893 0 : if (!PyErr_ExceptionMatches(PyExc_AttributeError))
4894 0 : return -1;
4895 0 : PyErr_SetString(PyExc_ImportError,
4896 : "from-import-* object has no __dict__ and no __all__");
4897 0 : return -1;
4898 : }
4899 24 : all = PyMapping_Keys(dict);
4900 24 : Py_DECREF(dict);
4901 24 : if (all == NULL)
4902 0 : return -1;
4903 24 : skip_leading_underscores = 1;
4904 : }
4905 :
4906 1854 : for (pos = 0, err = 0; ; pos++) {
4907 1854 : name = PySequence_GetItem(all, pos);
4908 1854 : if (name == NULL) {
4909 33 : if (!PyErr_ExceptionMatches(PyExc_IndexError))
4910 0 : err = -1;
4911 : else
4912 33 : PyErr_Clear();
4913 33 : break;
4914 : }
4915 3534 : if (skip_leading_underscores &&
4916 3426 : PyString_Check(name) &&
4917 1713 : PyString_AS_STRING(name)[0] == '_')
4918 : {
4919 120 : Py_DECREF(name);
4920 120 : continue;
4921 : }
4922 1701 : value = PyObject_GetAttr(v, name);
4923 1701 : if (value == NULL)
4924 0 : err = -1;
4925 1701 : else if (PyDict_CheckExact(locals))
4926 1701 : err = PyDict_SetItem(locals, name, value);
4927 : else
4928 0 : err = PyObject_SetItem(locals, name, value);
4929 1701 : Py_DECREF(name);
4930 1701 : Py_XDECREF(value);
4931 1701 : if (err != 0)
4932 0 : break;
4933 1821 : }
4934 33 : Py_DECREF(all);
4935 33 : return err;
4936 : }
4937 :
4938 : static PyObject *
4939 702 : build_class(PyObject *methods, PyObject *bases, PyObject *name)
4940 : {
4941 702 : PyObject *metaclass = NULL, *result, *base;
4942 :
4943 702 : if (PyDict_Check(methods))
4944 702 : metaclass = PyDict_GetItemString(methods, "__metaclass__");
4945 702 : if (metaclass != NULL)
4946 21 : Py_INCREF(metaclass);
4947 681 : else if (PyTuple_Check(bases) && PyTuple_GET_SIZE(bases) > 0) {
4948 519 : base = PyTuple_GET_ITEM(bases, 0);
4949 519 : metaclass = PyObject_GetAttrString(base, "__class__");
4950 1038 : if (metaclass == NULL) {
4951 102 : PyErr_Clear();
4952 102 : metaclass = (PyObject *)base->ob_type;
4953 102 : Py_INCREF(metaclass);
4954 : }
4955 : }
4956 : else {
4957 162 : PyObject *g = PyEval_GetGlobals();
4958 162 : if (g != NULL && PyDict_Check(g))
4959 162 : metaclass = PyDict_GetItemString(g, "__metaclass__");
4960 162 : if (metaclass == NULL)
4961 162 : metaclass = (PyObject *) &PyClass_Type;
4962 162 : Py_INCREF(metaclass);
4963 : }
4964 702 : result = PyObject_CallFunctionObjArgs(metaclass, name, bases, methods,
4965 : NULL);
4966 702 : Py_DECREF(metaclass);
4967 702 : 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 0 : PyErr_Fetch(&ptype, &pvalue, &ptraceback);
4976 0 : if (PyString_Check(pvalue)) {
4977 : PyObject *newmsg;
4978 0 : newmsg = PyString_FromFormat(
4979 : "Error when calling the metaclass bases\n"
4980 : " %s",
4981 0 : PyString_AS_STRING(pvalue));
4982 0 : if (newmsg != NULL) {
4983 0 : Py_DECREF(pvalue);
4984 0 : pvalue = newmsg;
4985 : }
4986 : }
4987 0 : PyErr_Restore(ptype, pvalue, ptraceback);
4988 : }
4989 702 : return result;
4990 : }
4991 :
4992 : static int
4993 27 : exec_statement(PyFrameObject *f, PyObject *prog, PyObject *globals,
4994 : PyObject *locals)
4995 : {
4996 : int n;
4997 : PyObject *v;
4998 27 : int plain = 0;
4999 :
5000 27 : if (PyTuple_Check(prog) && globals == Py_None && locals == Py_None &&
5001 0 : ((n = PyTuple_Size(prog)) == 2 || n == 3)) {
5002 : /* Backward compatibility hack */
5003 0 : globals = PyTuple_GetItem(prog, 1);
5004 0 : if (n == 3)
5005 0 : locals = PyTuple_GetItem(prog, 2);
5006 0 : prog = PyTuple_GetItem(prog, 0);
5007 : }
5008 27 : if (globals == Py_None) {
5009 0 : globals = PyEval_GetGlobals();
5010 0 : if (locals == Py_None) {
5011 0 : locals = PyEval_GetLocals();
5012 0 : plain = 1;
5013 : }
5014 0 : if (!globals || !locals) {
5015 0 : PyErr_SetString(PyExc_SystemError,
5016 : "globals and locals cannot be NULL");
5017 0 : return -1;
5018 : }
5019 : }
5020 27 : else if (locals == Py_None)
5021 0 : locals = globals;
5022 27 : if (!PyString_Check(prog) &&
5023 : #ifdef Py_USING_UNICODE
5024 0 : !PyUnicode_Check(prog) &&
5025 : #endif
5026 0 : !PyCode_Check(prog) &&
5027 0 : !PyFile_Check(prog)) {
5028 0 : PyErr_SetString(PyExc_TypeError,
5029 : "exec: arg 1 must be a string, file, or code object");
5030 0 : return -1;
5031 : }
5032 27 : if (!PyDict_Check(globals)) {
5033 0 : PyErr_SetString(PyExc_TypeError,
5034 : "exec: arg 2 must be a dictionary or None");
5035 0 : return -1;
5036 : }
5037 27 : if (!PyMapping_Check(locals)) {
5038 0 : PyErr_SetString(PyExc_TypeError,
5039 : "exec: arg 3 must be a mapping or None");
5040 0 : return -1;
5041 : }
5042 27 : if (PyDict_GetItemString(globals, "__builtins__") == NULL)
5043 27 : PyDict_SetItemString(globals, "__builtins__", f->f_builtins);
5044 27 : if (PyCode_Check(prog)) {
5045 0 : if (PyCode_GetNumFree((PyCodeObject *)prog) > 0) {
5046 0 : PyErr_SetString(PyExc_TypeError,
5047 : "code object passed to exec may not contain free variables");
5048 0 : return -1;
5049 : }
5050 0 : v = PyEval_EvalCode((PyCodeObject *) prog, globals, locals);
5051 : }
5052 27 : else if (PyFile_Check(prog)) {
5053 0 : FILE *fp = PyFile_AsFile(prog);
5054 0 : char *name = PyString_AsString(PyFile_Name(prog));
5055 : PyCompilerFlags cf;
5056 0 : if (name == NULL)
5057 0 : return -1;
5058 0 : cf.cf_flags = 0;
5059 0 : if (PyEval_MergeCompilerFlags(&cf))
5060 0 : v = PyRun_FileFlags(fp, name, Py_file_input, globals,
5061 : locals, &cf);
5062 : else
5063 0 : v = PyRun_File(fp, name, Py_file_input, globals,
5064 : locals);
5065 : }
5066 : else {
5067 27 : PyObject *tmp = NULL;
5068 : char *str;
5069 : PyCompilerFlags cf;
5070 27 : cf.cf_flags = 0;
5071 : #ifdef Py_USING_UNICODE
5072 27 : if (PyUnicode_Check(prog)) {
5073 0 : tmp = PyUnicode_AsUTF8String(prog);
5074 0 : if (tmp == NULL)
5075 0 : return -1;
5076 0 : prog = tmp;
5077 0 : cf.cf_flags |= PyCF_SOURCE_IS_UTF8;
5078 : }
5079 : #endif
5080 27 : if (PyString_AsStringAndSize(prog, &str, NULL))
5081 0 : return -1;
5082 27 : if (PyEval_MergeCompilerFlags(&cf))
5083 0 : v = PyRun_StringFlags(str, Py_file_input, globals,
5084 : locals, &cf);
5085 : else
5086 27 : v = PyRun_String(str, Py_file_input, globals, locals);
5087 27 : Py_XDECREF(tmp);
5088 : }
5089 27 : if (plain)
5090 0 : PyFrame_LocalsToFast(f, 0);
5091 27 : if (v == NULL)
5092 0 : return -1;
5093 27 : Py_DECREF(v);
5094 27 : return 0;
5095 : }
5096 :
5097 : static void
5098 0 : format_exc_check_arg(PyObject *exc, char *format_str, PyObject *obj)
5099 : {
5100 : char *obj_str;
5101 :
5102 0 : if (!obj)
5103 0 : return;
5104 :
5105 0 : obj_str = PyString_AsString(obj);
5106 0 : if (!obj_str)
5107 0 : return;
5108 :
5109 0 : PyErr_Format(exc, format_str, obj_str);
5110 : }
5111 :
5112 : static PyObject *
5113 7033 : 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 7033 : Py_ssize_t v_len = PyString_GET_SIZE(v);
5119 7033 : Py_ssize_t w_len = PyString_GET_SIZE(w);
5120 7033 : Py_ssize_t new_len = v_len + w_len;
5121 7033 : if (new_len < 0) {
5122 0 : PyErr_SetString(PyExc_OverflowError,
5123 : "strings are too large to concat");
5124 0 : return NULL;
5125 : }
5126 :
5127 7033 : 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 1827 : switch (*next_instr) {
5135 : case STORE_FAST:
5136 : {
5137 378 : int oparg = PEEKARG();
5138 378 : PyObject **fastlocals = f->f_localsplus;
5139 378 : if (GETLOCAL(oparg) == v)
5140 378 : SETLOCAL(oparg, NULL);
5141 378 : break;
5142 : }
5143 : case STORE_DEREF:
5144 : {
5145 0 : PyObject **freevars = (f->f_localsplus +
5146 0 : f->f_code->co_nlocals);
5147 0 : PyObject *c = freevars[PEEKARG()];
5148 0 : if (PyCell_GET(c) == v)
5149 0 : PyCell_Set(c, NULL);
5150 0 : break;
5151 : }
5152 : case STORE_NAME:
5153 : {
5154 12 : PyObject *names = f->f_code->co_names;
5155 12 : PyObject *name = GETITEM(names, PEEKARG());
5156 12 : PyObject *locals = f->f_locals;
5157 24 : if (PyDict_CheckExact(locals) &&
5158 12 : PyDict_GetItem(locals, name) == v) {
5159 0 : if (PyDict_DelItem(locals, name) != 0) {
5160 0 : PyErr_Clear();
5161 : }
5162 : }
5163 12 : break;
5164 : }
5165 : }
5166 : }
5167 :
5168 7033 : 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 462 : 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 0 : return NULL;
5180 : }
5181 : /* copy 'w' into the newly allocated area of 'v' */
5182 924 : memcpy(PyString_AS_STRING(v) + v_len,
5183 462 : PyString_AS_STRING(w), w_len);
5184 462 : return v;
5185 : }
5186 : else {
5187 : /* When in-place resizing is not an option. */
5188 6571 : PyString_Concat(&v, w);
5189 6571 : return v;
5190 : }
5191 : }
5192 :
5193 : #ifdef DYNAMIC_EXECUTION_PROFILE
5194 :
5195 : static PyObject *
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 *
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
|
