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