1
2 /* Execute compiled code */
3
4 /* XXX TO DO:
5 XXX speed up searching for keywords by using a dictionary
6 XXX document it!
7 */
8
9 /* enable more aggressive intra-module optimizations, where available */
10 #define PY_LOCAL_AGGRESSIVE
11
12 #include "Python.h"
13
14 #include "code.h"
15 #include "frameobject.h"
16 #include "eval.h"
17 #include "opcode.h"
18 #include "structmember.h"
19
20 #include <ctype.h>
21
22 #ifndef WITH_TSC
23
24 #define READ_TIMESTAMP(var)
25
26 #else
27
28 typedef unsigned long long uint64;
29
30 #if defined(__ppc__) /* <- Don't know if this is the correct symbol; this
31 section should work for GCC on any PowerPC platform,
32 irrespective of OS. POWER? Who knows :-) */
33
34 #define READ_TIMESTAMP(var) ppc_getcounter(&var)
35
36 static void
ppc_getcounter(uint64 * v)37 ppc_getcounter(uint64 *v)
38 {
39 register unsigned long tbu, tb, tbu2;
40
41 loop:
42 asm volatile ("mftbu %0" : "=r" (tbu) );
43 asm volatile ("mftb %0" : "=r" (tb) );
44 asm volatile ("mftbu %0" : "=r" (tbu2));
45 if (__builtin_expect(tbu != tbu2, 0)) goto loop;
46
47 /* The slightly peculiar way of writing the next lines is
48 compiled better by GCC than any other way I tried. */
49 ((long*)(v))[0] = tbu;
50 ((long*)(v))[1] = tb;
51 }
52
53 #else /* this is for linux/x86 (and probably any other GCC/x86 combo) */
54
55 #define READ_TIMESTAMP(val) \
56 __asm__ __volatile__("rdtsc" : "=A" (val))
57
58 #endif
59
dump_tsc(int opcode,int ticked,uint64 inst0,uint64 inst1,uint64 loop0,uint64 loop1,uint64 intr0,uint64 intr1)60 void dump_tsc(int opcode, int ticked, uint64 inst0, uint64 inst1,
61 uint64 loop0, uint64 loop1, uint64 intr0, uint64 intr1)
62 {
63 uint64 intr, inst, loop;
64 PyThreadState *tstate = PyThreadState_Get();
65 if (!tstate->interp->tscdump)
66 return;
67 intr = intr1 - intr0;
68 inst = inst1 - inst0 - intr;
69 loop = loop1 - loop0 - intr;
70 fprintf(stderr, "opcode=%03d t=%d inst=%06lld loop=%06lld\n",
71 opcode, ticked, inst, loop);
72 }
73
74 #endif
75
76 /* Turn this on if your compiler chokes on the big switch: */
77 /* #define CASE_TOO_BIG 1 */
78
79 #ifdef Py_DEBUG
80 /* For debugging the interpreter: */
81 #define LLTRACE 1 /* Low-level trace feature */
82 #define CHECKEXC 1 /* Double-check exception checking */
83 #endif
84
85 typedef PyObject *(*callproc)(PyObject *, PyObject *, PyObject *);
86
87 /* Forward declarations */
88 #ifdef WITH_TSC
89 static PyObject * call_function(PyObject ***, int, uint64*, uint64*);
90 #else
91 static PyObject * call_function(PyObject ***, int);
92 #endif
93 static PyObject * fast_function(PyObject *, PyObject ***, int, int, int);
94 static PyObject * do_call(PyObject *, PyObject ***, int, int);
95 static PyObject * ext_do_call(PyObject *, PyObject ***, int, int, int);
96 static PyObject * update_keyword_args(PyObject *, int, PyObject ***,PyObject *);
97 static PyObject * update_star_args(int, int, PyObject *, PyObject ***);
98 static PyObject * load_args(PyObject ***, int);
99 #define CALL_FLAG_VAR 1
100 #define CALL_FLAG_KW 2
101
102 #ifdef LLTRACE
103 static int lltrace;
104 static int prtrace(PyObject *, char *);
105 #endif
106 static int call_trace(Py_tracefunc, PyObject *, PyFrameObject *,
107 int, PyObject *);
108 static void call_trace_protected(Py_tracefunc, PyObject *,
109 PyFrameObject *, int, PyObject *);
110 static void call_exc_trace(Py_tracefunc, PyObject *, PyFrameObject *);
111 static int maybe_call_line_trace(Py_tracefunc, PyObject *,
112 PyFrameObject *, int *, int *, int *);
113
114 static PyObject * apply_slice(PyObject *, PyObject *, PyObject *);
115 static int assign_slice(PyObject *, PyObject *,
116 PyObject *, PyObject *);
117 static PyObject * cmp_outcome(int, PyObject *, PyObject *);
118 static PyObject * import_from(PyObject *, PyObject *);
119 static int import_all_from(PyObject *, PyObject *);
120 static PyObject * build_class(PyObject *, PyObject *, PyObject *);
121 static int exec_statement(PyFrameObject *,
122 PyObject *, PyObject *, PyObject *);
123 static void set_exc_info(PyThreadState *, PyObject *, PyObject *, PyObject *);
124 static void reset_exc_info(PyThreadState *);
125 static void format_exc_check_arg(PyObject *, char *, PyObject *);
126 static PyObject * string_concatenate(PyObject *, PyObject *,
127 PyFrameObject *, unsigned char *);
128
129 #define NAME_ERROR_MSG \
130 "name '%.200s' is not defined"
131 #define GLOBAL_NAME_ERROR_MSG \
132 "global name '%.200s' is not defined"
133 #define UNBOUNDLOCAL_ERROR_MSG \
134 "local variable '%.200s' referenced before assignment"
135 #define UNBOUNDFREE_ERROR_MSG \
136 "free variable '%.200s' referenced before assignment" \
137 " in enclosing scope"
138
139 /* Dynamic execution profile */
140 #ifdef DYNAMIC_EXECUTION_PROFILE
141 #ifdef DXPAIRS
142 static long dxpairs[257][256];
143 #define dxp dxpairs[256]
144 #else
145 static long dxp[256];
146 #endif
147 #endif
148
149 /* Function call profile */
150 #ifdef CALL_PROFILE
151 #define PCALL_NUM 11
152 static int pcall[PCALL_NUM];
153
154 #define PCALL_ALL 0
155 #define PCALL_FUNCTION 1
156 #define PCALL_FAST_FUNCTION 2
157 #define PCALL_FASTER_FUNCTION 3
158 #define PCALL_METHOD 4
159 #define PCALL_BOUND_METHOD 5
160 #define PCALL_CFUNCTION 6
161 #define PCALL_TYPE 7
162 #define PCALL_GENERATOR 8
163 #define PCALL_OTHER 9
164 #define PCALL_POP 10
165
166 /* Notes about the statistics
167
168 PCALL_FAST stats
169
170 FAST_FUNCTION means no argument tuple needs to be created.
171 FASTER_FUNCTION means that the fast-path frame setup code is used.
172
173 If there is a method call where the call can be optimized by changing
174 the argument tuple and calling the function directly, it gets recorded
175 twice.
176
177 As a result, the relationship among the statistics appears to be
178 PCALL_ALL == PCALL_FUNCTION + PCALL_METHOD - PCALL_BOUND_METHOD +
179 PCALL_CFUNCTION + PCALL_TYPE + PCALL_GENERATOR + PCALL_OTHER
180 PCALL_FUNCTION > PCALL_FAST_FUNCTION > PCALL_FASTER_FUNCTION
181 PCALL_METHOD > PCALL_BOUND_METHOD
182 */
183
184 #define PCALL(POS) pcall[POS]++
185
186 PyObject *
PyEval_GetCallStats(PyObject * self)187 PyEval_GetCallStats(PyObject *self)
188 {
189 return Py_BuildValue("iiiiiiiiii",
190 pcall[0], pcall[1], pcall[2], pcall[3],
191 pcall[4], pcall[5], pcall[6], pcall[7],
192 pcall[8], pcall[9]);
193 }
194 #else
195 #define PCALL(O)
196
197 PyObject *
PyEval_GetCallStats(PyObject * self)198 PyEval_GetCallStats(PyObject *self)
199 {
200 Py_INCREF(Py_None);
201 return Py_None;
202 }
203 #endif
204
205
206 #ifdef WITH_THREAD
207
208 #ifdef HAVE_ERRNO_H
209 #include <errno.h>
210 #endif
211 #include "pythread.h"
212
213 static PyThread_type_lock interpreter_lock = 0; /* This is the GIL */
214 static long main_thread = 0;
215
216 int
PyEval_ThreadsInitialized(void)217 PyEval_ThreadsInitialized(void)
218 {
219 return interpreter_lock != 0;
220 }
221
222 void
PyEval_InitThreads(void)223 PyEval_InitThreads(void)
224 {
225 if (interpreter_lock)
226 return;
227 interpreter_lock = PyThread_allocate_lock();
228 PyThread_acquire_lock(interpreter_lock, 1);
229 main_thread = PyThread_get_thread_ident();
230 }
231
232 void
PyEval_AcquireLock(void)233 PyEval_AcquireLock(void)
234 {
235 PyThread_acquire_lock(interpreter_lock, 1);
236 }
237
238 void
PyEval_ReleaseLock(void)239 PyEval_ReleaseLock(void)
240 {
241 PyThread_release_lock(interpreter_lock);
242 }
243
244 void
PyEval_AcquireThread(PyThreadState * tstate)245 PyEval_AcquireThread(PyThreadState *tstate)
246 {
247 if (tstate == NULL)
248 Py_FatalError("PyEval_AcquireThread: NULL new thread state");
249 /* Check someone has called PyEval_InitThreads() to create the lock */
250 assert(interpreter_lock);
251 PyThread_acquire_lock(interpreter_lock, 1);
252 if (PyThreadState_Swap(tstate) != NULL)
253 Py_FatalError(
254 "PyEval_AcquireThread: non-NULL old thread state");
255 }
256
257 void
PyEval_ReleaseThread(PyThreadState * tstate)258 PyEval_ReleaseThread(PyThreadState *tstate)
259 {
260 if (tstate == NULL)
261 Py_FatalError("PyEval_ReleaseThread: NULL thread state");
262 if (PyThreadState_Swap(NULL) != tstate)
263 Py_FatalError("PyEval_ReleaseThread: wrong thread state");
264 PyThread_release_lock(interpreter_lock);
265 }
266
267 /* This function is called from PyOS_AfterFork to ensure that newly
268 created child processes don't hold locks referring to threads which
269 are not running in the child process. (This could also be done using
270 pthread_atfork mechanism, at least for the pthreads implementation.) */
271
272 void
PyEval_ReInitThreads(void)273 PyEval_ReInitThreads(void)
274 {
275 if (!interpreter_lock)
276 return;
277 /*XXX Can't use PyThread_free_lock here because it does too
278 much error-checking. Doing this cleanly would require
279 adding a new function to each thread_*.h. Instead, just
280 create a new lock and waste a little bit of memory */
281 interpreter_lock = PyThread_allocate_lock();
282 PyThread_acquire_lock(interpreter_lock, 1);
283 main_thread = PyThread_get_thread_ident();
284 }
285 #endif
286
287 /* Functions save_thread and restore_thread are always defined so
288 dynamically loaded modules needn't be compiled separately for use
289 with and without threads: */
290
291 PyThreadState *
PyEval_SaveThread(void)292 PyEval_SaveThread(void)
293 {
294 PyThreadState *tstate = PyThreadState_Swap(NULL);
295 if (tstate == NULL)
296 Py_FatalError("PyEval_SaveThread: NULL tstate");
297 #ifdef WITH_THREAD
298 if (interpreter_lock)
299 PyThread_release_lock(interpreter_lock);
300 #endif
301 return tstate;
302 }
303
304 void
PyEval_RestoreThread(PyThreadState * tstate)305 PyEval_RestoreThread(PyThreadState *tstate)
306 {
307 if (tstate == NULL)
308 Py_FatalError("PyEval_RestoreThread: NULL tstate");
309 #ifdef WITH_THREAD
310 if (interpreter_lock) {
311 int err = errno;
312 PyThread_acquire_lock(interpreter_lock, 1);
313 errno = err;
314 }
315 #endif
316 PyThreadState_Swap(tstate);
317 }
318
319
320 /* Mechanism whereby asynchronously executing callbacks (e.g. UNIX
321 signal handlers or Mac I/O completion routines) can schedule calls
322 to a function to be called synchronously.
323 The synchronous function is called with one void* argument.
324 It should return 0 for success or -1 for failure -- failure should
325 be accompanied by an exception.
326
327 If registry succeeds, the registry function returns 0; if it fails
328 (e.g. due to too many pending calls) it returns -1 (without setting
329 an exception condition).
330
331 Note that because registry may occur from within signal handlers,
332 or other asynchronous events, calling malloc() is unsafe!
333
334 #ifdef WITH_THREAD
335 Any thread can schedule pending calls, but only the main thread
336 will execute them.
337 #endif
338
339 XXX WARNING! ASYNCHRONOUSLY EXECUTING CODE!
340 There are two possible race conditions:
341 (1) nested asynchronous registry calls;
342 (2) registry calls made while pending calls are being processed.
343 While (1) is very unlikely, (2) is a real possibility.
344 The current code is safe against (2), but not against (1).
345 The safety against (2) is derived from the fact that only one
346 thread (the main thread) ever takes things out of the queue.
347
348 XXX Darn! With the advent of thread state, we should have an array
349 of pending calls per thread in the thread state! Later...
350 */
351
352 #define NPENDINGCALLS 32
353 static struct {
354 int (*func)(void *);
355 void *arg;
356 } pendingcalls[NPENDINGCALLS];
357 static volatile int pendingfirst = 0;
358 static volatile int pendinglast = 0;
359 static volatile int things_to_do = 0;
360
361 int
Py_AddPendingCall(int (* func)(void *),void * arg)362 Py_AddPendingCall(int (*func)(void *), void *arg)
363 {
364 static volatile int busy = 0;
365 int i, j;
366 /* XXX Begin critical section */
367 /* XXX If you want this to be safe against nested
368 XXX asynchronous calls, you'll have to work harder! */
369 if (busy)
370 return -1;
371 busy = 1;
372 i = pendinglast;
373 j = (i + 1) % NPENDINGCALLS;
374 if (j == pendingfirst) {
375 busy = 0;
376 return -1; /* Queue full */
377 }
378 pendingcalls[i].func = func;
379 pendingcalls[i].arg = arg;
380 pendinglast = j;
381
382 _Py_Ticker = 0;
383 things_to_do = 1; /* Signal main loop */
384 busy = 0;
385 /* XXX End critical section */
386 return 0;
387 }
388
389 int
Py_MakePendingCalls(void)390 Py_MakePendingCalls(void)
391 {
392 static int busy = 0;
393 #ifdef WITH_THREAD
394 if (main_thread && PyThread_get_thread_ident() != main_thread)
395 return 0;
396 #endif
397 if (busy)
398 return 0;
399 busy = 1;
400 things_to_do = 0;
401 for (;;) {
402 int i;
403 int (*func)(void *);
404 void *arg;
405 i = pendingfirst;
406 if (i == pendinglast)
407 break; /* Queue empty */
408 func = pendingcalls[i].func;
409 arg = pendingcalls[i].arg;
410 pendingfirst = (i + 1) % NPENDINGCALLS;
411 if (func(arg) < 0) {
412 busy = 0;
413 things_to_do = 1; /* We're not done yet */
414 return -1;
415 }
416 }
417 busy = 0;
418 return 0;
419 }
420
421
422 /* The interpreter's recursion limit */
423
424 #ifndef Py_DEFAULT_RECURSION_LIMIT
425 #define Py_DEFAULT_RECURSION_LIMIT 1000
426 #endif
427 static int recursion_limit = Py_DEFAULT_RECURSION_LIMIT;
428 int _Py_CheckRecursionLimit = Py_DEFAULT_RECURSION_LIMIT;
429
430 int
Py_GetRecursionLimit(void)431 Py_GetRecursionLimit(void)
432 {
433 return recursion_limit;
434 }
435
436 void
Py_SetRecursionLimit(int new_limit)437 Py_SetRecursionLimit(int new_limit)
438 {
439 recursion_limit = new_limit;
440 _Py_CheckRecursionLimit = recursion_limit;
441 }
442
443 /* the macro Py_EnterRecursiveCall() only calls _Py_CheckRecursiveCall()
444 if the recursion_depth reaches _Py_CheckRecursionLimit.
445 If USE_STACKCHECK, the macro decrements _Py_CheckRecursionLimit
446 to guarantee that _Py_CheckRecursiveCall() is regularly called.
447 Without USE_STACKCHECK, there is no need for this. */
448 int
_Py_CheckRecursiveCall(char * where)449 _Py_CheckRecursiveCall(char *where)
450 {
451 PyThreadState *tstate = PyThreadState_GET();
452
453 #ifdef USE_STACKCHECK
454 if (PyOS_CheckStack()) {
455 --tstate->recursion_depth;
456 PyErr_SetString(PyExc_MemoryError, "Stack overflow");
457 return -1;
458 }
459 #endif
460 if (tstate->recursion_depth > recursion_limit) {
461 --tstate->recursion_depth;
462 PyErr_Format(PyExc_RuntimeError,
463 "maximum recursion depth exceeded%s",
464 where);
465 return -1;
466 }
467 _Py_CheckRecursionLimit = recursion_limit;
468 return 0;
469 }
470
471 /* Status code for main loop (reason for stack unwind) */
472 enum why_code {
473 WHY_NOT = 0x0001, /* No error */
474 WHY_EXCEPTION = 0x0002, /* Exception occurred */
475 WHY_RERAISE = 0x0004, /* Exception re-raised by 'finally' */
476 WHY_RETURN = 0x0008, /* 'return' statement */
477 WHY_BREAK = 0x0010, /* 'break' statement */
478 WHY_CONTINUE = 0x0020, /* 'continue' statement */
479 WHY_YIELD = 0x0040 /* 'yield' operator */
480 };
481
482 static enum why_code do_raise(PyObject *, PyObject *, PyObject *);
483 static int unpack_iterable(PyObject *, int, PyObject **);
484
485 /* for manipulating the thread switch and periodic "stuff" - used to be
486 per thread, now just a pair o' globals */
487 int _Py_CheckInterval = 100;
488 volatile int _Py_Ticker = 100;
489
490 PyObject *
PyEval_EvalCode(PyCodeObject * co,PyObject * globals,PyObject * locals)491 PyEval_EvalCode(PyCodeObject *co, PyObject *globals, PyObject *locals)
492 {
493 /* XXX raise SystemError if globals is NULL */
494 return PyEval_EvalCodeEx(co,
495 globals, locals,
496 (PyObject **)NULL, 0,
497 (PyObject **)NULL, 0,
498 (PyObject **)NULL, 0,
499 NULL);
500 }
501
502
503 /* Interpreter main loop */
504
505 PyObject *
PyEval_EvalFrame(PyFrameObject * f)506 PyEval_EvalFrame(PyFrameObject *f) {
507 /* This is for backward compatibility with extension modules that
508 used this API; core interpreter code should call PyEval_EvalFrameEx() */
509 return PyEval_EvalFrameEx(f, 0);
510 }
511
512 PyObject *
PyEval_EvalFrameEx(PyFrameObject * f,int throwflag)513 PyEval_EvalFrameEx(PyFrameObject *f, int throwflag)
514 {
515 #ifdef DXPAIRS
516 int lastopcode = 0;
517 #endif
518 register PyObject **stack_pointer; /* Next free slot in value stack */
519 register unsigned char *next_instr;
520 register int opcode; /* Current opcode */
521 register int oparg; /* Current opcode argument, if any */
522 register enum why_code why; /* Reason for block stack unwind */
523 register int err; /* Error status -- nonzero if error */
524 register PyObject *x; /* Result object -- NULL if error */
525 register PyObject *v; /* Temporary objects popped off stack */
526 register PyObject *w;
527 register PyObject *u;
528 register PyObject *t;
529 register PyObject *stream = NULL; /* for PRINT opcodes */
530 register PyObject **fastlocals, **freevars;
531 PyObject *retval = NULL; /* Return value */
532 PyThreadState *tstate = PyThreadState_GET();
533 PyCodeObject *co;
534
535 /* when tracing we set things up so that
536
537 not (instr_lb <= current_bytecode_offset < instr_ub)
538
539 is true when the line being executed has changed. The
540 initial values are such as to make this false the first
541 time it is tested. */
542 int instr_ub = -1, instr_lb = 0, instr_prev = -1;
543
544 unsigned char *first_instr;
545 PyObject *names;
546 PyObject *consts;
547 #if defined(Py_DEBUG) || defined(LLTRACE)
548 /* Make it easier to find out where we are with a debugger */
549 char *filename;
550 #endif
551
552 /* Tuple access macros */
553
554 #ifndef Py_DEBUG
555 #define GETITEM(v, i) PyTuple_GET_ITEM((PyTupleObject *)(v), (i))
556 #else
557 #define GETITEM(v, i) PyTuple_GetItem((v), (i))
558 #endif
559
560 #ifdef WITH_TSC
561 /* Use Pentium timestamp counter to mark certain events:
562 inst0 -- beginning of switch statement for opcode dispatch
563 inst1 -- end of switch statement (may be skipped)
564 loop0 -- the top of the mainloop
565 loop1 -- place where control returns again to top of mainloop
566 (may be skipped)
567 intr1 -- beginning of long interruption
568 intr2 -- end of long interruption
569
570 Many opcodes call out to helper C functions. In some cases, the
571 time in those functions should be counted towards the time for the
572 opcode, but not in all cases. For example, a CALL_FUNCTION opcode
573 calls another Python function; there's no point in charge all the
574 bytecode executed by the called function to the caller.
575
576 It's hard to make a useful judgement statically. In the presence
577 of operator overloading, it's impossible to tell if a call will
578 execute new Python code or not.
579
580 It's a case-by-case judgement. I'll use intr1 for the following
581 cases:
582
583 EXEC_STMT
584 IMPORT_STAR
585 IMPORT_FROM
586 CALL_FUNCTION (and friends)
587
588 */
589 uint64 inst0, inst1, loop0, loop1, intr0 = 0, intr1 = 0;
590 int ticked = 0;
591
592 READ_TIMESTAMP(inst0);
593 READ_TIMESTAMP(inst1);
594 READ_TIMESTAMP(loop0);
595 READ_TIMESTAMP(loop1);
596
597 /* shut up the compiler */
598 opcode = 0;
599 #endif
600
601 /* Code access macros */
602
603 #define INSTR_OFFSET() ((int)(next_instr - first_instr))
604 #define NEXTOP() (*next_instr++)
605 #define NEXTARG() (next_instr += 2, (next_instr[-1]<<8) + next_instr[-2])
606 #define PEEKARG() ((next_instr[2]<<8) + next_instr[1])
607 #define JUMPTO(x) (next_instr = first_instr + (x))
608 #define JUMPBY(x) (next_instr += (x))
609
610 /* OpCode prediction macros
611 Some opcodes tend to come in pairs thus making it possible to predict
612 the second code when the first is run. For example, COMPARE_OP is often
613 followed by JUMP_IF_FALSE or JUMP_IF_TRUE. And, those opcodes are often
614 followed by a POP_TOP.
615
616 Verifying the prediction costs a single high-speed test of register
617 variable against a constant. If the pairing was good, then the
618 processor has a high likelihood of making its own successful branch
619 prediction which results in a nearly zero overhead transition to the
620 next opcode.
621
622 A successful prediction saves a trip through the eval-loop including
623 its two unpredictable branches, the HASARG test and the switch-case.
624
625 If collecting opcode statistics, turn off prediction so that
626 statistics are accurately maintained (the predictions bypass
627 the opcode frequency counter updates).
628 */
629
630 #ifdef DYNAMIC_EXECUTION_PROFILE
631 #define PREDICT(op) if (0) goto PRED_##op
632 #else
633 #define PREDICT(op) if (*next_instr == op) goto PRED_##op
634 #endif
635
636 #define PREDICTED(op) PRED_##op: next_instr++
637 #define PREDICTED_WITH_ARG(op) PRED_##op: oparg = PEEKARG(); next_instr += 3
638
639 /* Stack manipulation macros */
640
641 /* The stack can grow at most MAXINT deep, as co_nlocals and
642 co_stacksize are ints. */
643 #define STACK_LEVEL() ((int)(stack_pointer - f->f_valuestack))
644 #define EMPTY() (STACK_LEVEL() == 0)
645 #define TOP() (stack_pointer[-1])
646 #define SECOND() (stack_pointer[-2])
647 #define THIRD() (stack_pointer[-3])
648 #define FOURTH() (stack_pointer[-4])
649 #define SET_TOP(v) (stack_pointer[-1] = (v))
650 #define SET_SECOND(v) (stack_pointer[-2] = (v))
651 #define SET_THIRD(v) (stack_pointer[-3] = (v))
652 #define SET_FOURTH(v) (stack_pointer[-4] = (v))
653 #define BASIC_STACKADJ(n) (stack_pointer += n)
654 #define BASIC_PUSH(v) (*stack_pointer++ = (v))
655 #define BASIC_POP() (*--stack_pointer)
656
657 #ifdef LLTRACE
658 #define PUSH(v) { (void)(BASIC_PUSH(v), \
659 lltrace && prtrace(TOP(), "push")); \
660 assert(STACK_LEVEL() <= co->co_stacksize); }
661 #define POP() ((void)(lltrace && prtrace(TOP(), "pop")), BASIC_POP())
662 #define STACKADJ(n) { (void)(BASIC_STACKADJ(n), \
663 lltrace && prtrace(TOP(), "stackadj")); \
664 assert(STACK_LEVEL() <= co->co_stacksize); }
665 #define EXT_POP(STACK_POINTER) (lltrace && prtrace(*(STACK_POINTER), "ext_pop"), *--(STACK_POINTER))
666 #else
667 #define PUSH(v) BASIC_PUSH(v)
668 #define POP() BASIC_POP()
669 #define STACKADJ(n) BASIC_STACKADJ(n)
670 #define EXT_POP(STACK_POINTER) (*--(STACK_POINTER))
671 #endif
672
673 /* Local variable macros */
674
675 #define GETLOCAL(i) (fastlocals[i])
676
677 /* The SETLOCAL() macro must not DECREF the local variable in-place and
678 then store the new value; it must copy the old value to a temporary
679 value, then store the new value, and then DECREF the temporary value.
680 This is because it is possible that during the DECREF the frame is
681 accessed by other code (e.g. a __del__ method or gc.collect()) and the
682 variable would be pointing to already-freed memory. */
683 #define SETLOCAL(i, value) do { PyObject *tmp = GETLOCAL(i); \
684 GETLOCAL(i) = value; \
685 Py_XDECREF(tmp); } while (0)
686
687 /* Start of code */
688
689 if (f == NULL)
690 return NULL;
691
692 /* push frame */
693 if (Py_EnterRecursiveCall(""))
694 return NULL;
695
696 tstate->frame = f;
697
698 if (tstate->use_tracing) {
699 if (tstate->c_tracefunc != NULL) {
700 /* tstate->c_tracefunc, if defined, is a
701 function that will be called on *every* entry
702 to a code block. Its return value, if not
703 None, is a function that will be called at
704 the start of each executed line of code.
705 (Actually, the function must return itself
706 in order to continue tracing.) The trace
707 functions are called with three arguments:
708 a pointer to the current frame, a string
709 indicating why the function is called, and
710 an argument which depends on the situation.
711 The global trace function is also called
712 whenever an exception is detected. */
713 if (call_trace(tstate->c_tracefunc, tstate->c_traceobj,
714 f, PyTrace_CALL, Py_None)) {
715 /* Trace function raised an error */
716 goto exit_eval_frame;
717 }
718 }
719 if (tstate->c_profilefunc != NULL) {
720 /* Similar for c_profilefunc, except it needn't
721 return itself and isn't called for "line" events */
722 if (call_trace(tstate->c_profilefunc,
723 tstate->c_profileobj,
724 f, PyTrace_CALL, Py_None)) {
725 /* Profile function raised an error */
726 goto exit_eval_frame;
727 }
728 }
729 }
730
731 co = f->f_code;
732 names = co->co_names;
733 consts = co->co_consts;
734 fastlocals = f->f_localsplus;
735 freevars = f->f_localsplus + co->co_nlocals;
736 first_instr = (unsigned char*) PyString_AS_STRING(co->co_code);
737 /* An explanation is in order for the next line.
738
739 f->f_lasti now refers to the index of the last instruction
740 executed. You might think this was obvious from the name, but
741 this wasn't always true before 2.3! PyFrame_New now sets
742 f->f_lasti to -1 (i.e. the index *before* the first instruction)
743 and YIELD_VALUE doesn't fiddle with f_lasti any more. So this
744 does work. Promise. */
745 next_instr = first_instr + f->f_lasti + 1;
746 stack_pointer = f->f_stacktop;
747 assert(stack_pointer != NULL);
748 f->f_stacktop = NULL; /* remains NULL unless yield suspends frame */
749
750 #ifdef LLTRACE
751 lltrace = PyDict_GetItemString(f->f_globals, "__lltrace__") != NULL;
752 #endif
753 #if defined(Py_DEBUG) || defined(LLTRACE)
754 filename = PyString_AsString(co->co_filename);
755 #endif
756
757 why = WHY_NOT;
758 err = 0;
759 x = Py_None; /* Not a reference, just anything non-NULL */
760 w = NULL;
761
762 if (throwflag) { /* support for generator.throw() */
763 why = WHY_EXCEPTION;
764 goto on_error;
765 }
766
767 for (;;) {
768 #ifdef WITH_TSC
769 if (inst1 == 0) {
770 /* Almost surely, the opcode executed a break
771 or a continue, preventing inst1 from being set
772 on the way out of the loop.
773 */
774 READ_TIMESTAMP(inst1);
775 loop1 = inst1;
776 }
777 dump_tsc(opcode, ticked, inst0, inst1, loop0, loop1,
778 intr0, intr1);
779 ticked = 0;
780 inst1 = 0;
781 intr0 = 0;
782 intr1 = 0;
783 READ_TIMESTAMP(loop0);
784 #endif
785 assert(stack_pointer >= f->f_valuestack); /* else underflow */
786 assert(STACK_LEVEL() <= co->co_stacksize); /* else overflow */
787
788 /* Do periodic things. Doing this every time through
789 the loop would add too much overhead, so we do it
790 only every Nth instruction. We also do it if
791 ``things_to_do'' is set, i.e. when an asynchronous
792 event needs attention (e.g. a signal handler or
793 async I/O handler); see Py_AddPendingCall() and
794 Py_MakePendingCalls() above. */
795
796 if (--_Py_Ticker < 0) {
797 if (*next_instr == SETUP_FINALLY) {
798 /* Make the last opcode before
799 a try: finally: block uninterruptable. */
800 goto fast_next_opcode;
801 }
802 _Py_Ticker = _Py_CheckInterval;
803 tstate->tick_counter++;
804 #ifdef WITH_TSC
805 ticked = 1;
806 #endif
807 if (things_to_do) {
808 if (Py_MakePendingCalls() < 0) {
809 why = WHY_EXCEPTION;
810 goto on_error;
811 }
812 if (things_to_do)
813 /* MakePendingCalls() didn't succeed.
814 Force early re-execution of this
815 "periodic" code, possibly after
816 a thread switch */
817 _Py_Ticker = 0;
818 }
819 #ifdef WITH_THREAD
820 if (interpreter_lock) {
821 /* Give another thread a chance */
822
823 if (PyThreadState_Swap(NULL) != tstate)
824 Py_FatalError("ceval: tstate mix-up");
825 PyThread_release_lock(interpreter_lock);
826
827 /* Other threads may run now */
828
829 PyThread_acquire_lock(interpreter_lock, 1);
830 if (PyThreadState_Swap(tstate) != NULL)
831 Py_FatalError("ceval: orphan tstate");
832
833 /* Check for thread interrupts */
834
835 if (tstate->async_exc != NULL) {
836 x = tstate->async_exc;
837 tstate->async_exc = NULL;
838 PyErr_SetNone(x);
839 Py_DECREF(x);
840 why = WHY_EXCEPTION;
841 goto on_error;
842 }
843 }
844 #endif
845 }
846
847 fast_next_opcode:
848 f->f_lasti = INSTR_OFFSET();
849
850 /* line-by-line tracing support */
851
852 if (tstate->c_tracefunc != NULL && !tstate->tracing) {
853 /* see maybe_call_line_trace
854 for expository comments */
855 f->f_stacktop = stack_pointer;
856
857 err = maybe_call_line_trace(tstate->c_tracefunc,
858 tstate->c_traceobj,
859 f, &instr_lb, &instr_ub,
860 &instr_prev);
861 /* Reload possibly changed frame fields */
862 JUMPTO(f->f_lasti);
863 if (f->f_stacktop != NULL) {
864 stack_pointer = f->f_stacktop;
865 f->f_stacktop = NULL;
866 }
867 if (err) {
868 /* trace function raised an exception */
869 goto on_error;
870 }
871 }
872
873 /* Extract opcode and argument */
874
875 opcode = NEXTOP();
876 oparg = 0; /* allows oparg to be stored in a register because
877 it doesn't have to be remembered across a full loop */
878 if (HAS_ARG(opcode))
879 oparg = NEXTARG();
880 dispatch_opcode:
881 #ifdef DYNAMIC_EXECUTION_PROFILE
882 #ifdef DXPAIRS
883 dxpairs[lastopcode][opcode]++;
884 lastopcode = opcode;
885 #endif
886 dxp[opcode]++;
887 #endif
888
889 #ifdef LLTRACE
890 /* Instruction tracing */
891
892 if (lltrace) {
893 if (HAS_ARG(opcode)) {
894 printf("%d: %d, %d\n",
895 f->f_lasti, opcode, oparg);
896 }
897 else {
898 printf("%d: %d\n",
899 f->f_lasti, opcode);
900 }
901 }
902 #endif
903
904 /* Main switch on opcode */
905 READ_TIMESTAMP(inst0);
906
907 switch (opcode) {
908
909 /* BEWARE!
910 It is essential that any operation that fails sets either
911 x to NULL, err to nonzero, or why to anything but WHY_NOT,
912 and that no operation that succeeds does this! */
913
914 /* case STOP_CODE: this is an error! */
915
916 case NOP:
917 goto fast_next_opcode;
918
919 case LOAD_FAST:
920 x = GETLOCAL(oparg);
921 if (x != NULL) {
922 Py_INCREF(x);
923 PUSH(x);
924 goto fast_next_opcode;
925 }
926 format_exc_check_arg(PyExc_UnboundLocalError,
927 UNBOUNDLOCAL_ERROR_MSG,
928 PyTuple_GetItem(co->co_varnames, oparg));
929 break;
930
931 case LOAD_CONST:
932 x = GETITEM(consts, oparg);
933 Py_INCREF(x);
934 PUSH(x);
935 goto fast_next_opcode;
936
937 PREDICTED_WITH_ARG(STORE_FAST);
938 case STORE_FAST:
939 v = POP();
940 SETLOCAL(oparg, v);
941 goto fast_next_opcode;
942
943 PREDICTED(POP_TOP);
944 case POP_TOP:
945 v = POP();
946 Py_DECREF(v);
947 goto fast_next_opcode;
948
949 case ROT_TWO:
950 v = TOP();
951 w = SECOND();
952 SET_TOP(w);
953 SET_SECOND(v);
954 goto fast_next_opcode;
955
956 case ROT_THREE:
957 v = TOP();
958 w = SECOND();
959 x = THIRD();
960 SET_TOP(w);
961 SET_SECOND(x);
962 SET_THIRD(v);
963 goto fast_next_opcode;
964
965 case ROT_FOUR:
966 u = TOP();
967 v = SECOND();
968 w = THIRD();
969 x = FOURTH();
970 SET_TOP(v);
971 SET_SECOND(w);
972 SET_THIRD(x);
973 SET_FOURTH(u);
974 goto fast_next_opcode;
975
976 case DUP_TOP:
977 v = TOP();
978 Py_INCREF(v);
979 PUSH(v);
980 goto fast_next_opcode;
981
982 case DUP_TOPX:
983 if (oparg == 2) {
984 x = TOP();
985 Py_INCREF(x);
986 w = SECOND();
987 Py_INCREF(w);
988 STACKADJ(2);
989 SET_TOP(x);
990 SET_SECOND(w);
991 goto fast_next_opcode;
992 } else if (oparg == 3) {
993 x = TOP();
994 Py_INCREF(x);
995 w = SECOND();
996 Py_INCREF(w);
997 v = THIRD();
998 Py_INCREF(v);
999 STACKADJ(3);
1000 SET_TOP(x);
1001 SET_SECOND(w);
1002 SET_THIRD(v);
1003 goto fast_next_opcode;
1004 }
1005 Py_FatalError("invalid argument to DUP_TOPX"
1006 " (bytecode corruption?)");
1007 break;
1008
1009 case UNARY_POSITIVE:
1010 v = TOP();
1011 x = PyNumber_Positive(v);
1012 Py_DECREF(v);
1013 SET_TOP(x);
1014 if (x != NULL) continue;
1015 break;
1016
1017 case UNARY_NEGATIVE:
1018 v = TOP();
1019 x = PyNumber_Negative(v);
1020 Py_DECREF(v);
1021 SET_TOP(x);
1022 if (x != NULL) continue;
1023 break;
1024
1025 case UNARY_NOT:
1026 v = TOP();
1027 err = PyObject_IsTrue(v);
1028 Py_DECREF(v);
1029 if (err == 0) {
1030 Py_INCREF(Py_True);
1031 SET_TOP(Py_True);
1032 continue;
1033 }
1034 else if (err > 0) {
1035 Py_INCREF(Py_False);
1036 SET_TOP(Py_False);
1037 err = 0;
1038 continue;
1039 }
1040 STACKADJ(-1);
1041 break;
1042
1043 case UNARY_CONVERT:
1044 v = TOP();
1045 x = PyObject_Repr(v);
1046 Py_DECREF(v);
1047 SET_TOP(x);
1048 if (x != NULL) continue;
1049 break;
1050
1051 case UNARY_INVERT:
1052 v = TOP();
1053 x = PyNumber_Invert(v);
1054 Py_DECREF(v);
1055 SET_TOP(x);
1056 if (x != NULL) continue;
1057 break;
1058
1059 case BINARY_POWER:
1060 w = POP();
1061 v = TOP();
1062 x = PyNumber_Power(v, w, Py_None);
1063 Py_DECREF(v);
1064 Py_DECREF(w);
1065 SET_TOP(x);
1066 if (x != NULL) continue;
1067 break;
1068
1069 case BINARY_MULTIPLY:
1070 w = POP();
1071 v = TOP();
1072 x = PyNumber_Multiply(v, w);
1073 Py_DECREF(v);
1074 Py_DECREF(w);
1075 SET_TOP(x);
1076 if (x != NULL) continue;
1077 break;
1078
1079 case BINARY_DIVIDE:
1080 if (!_Py_QnewFlag) {
1081 w = POP();
1082 v = TOP();
1083 x = PyNumber_Divide(v, w);
1084 Py_DECREF(v);
1085 Py_DECREF(w);
1086 SET_TOP(x);
1087 if (x != NULL) continue;
1088 break;
1089 }
1090 /* -Qnew is in effect: fall through to
1091 BINARY_TRUE_DIVIDE */
1092 case BINARY_TRUE_DIVIDE:
1093 w = POP();
1094 v = TOP();
1095 x = PyNumber_TrueDivide(v, w);
1096 Py_DECREF(v);
1097 Py_DECREF(w);
1098 SET_TOP(x);
1099 if (x != NULL) continue;
1100 break;
1101
1102 case BINARY_FLOOR_DIVIDE:
1103 w = POP();
1104 v = TOP();
1105 x = PyNumber_FloorDivide(v, w);
1106 Py_DECREF(v);
1107 Py_DECREF(w);
1108 SET_TOP(x);
1109 if (x != NULL) continue;
1110 break;
1111
1112 case BINARY_MODULO:
1113 w = POP();
1114 v = TOP();
1115 x = PyNumber_Remainder(v, w);
1116 Py_DECREF(v);
1117 Py_DECREF(w);
1118 SET_TOP(x);
1119 if (x != NULL) continue;
1120 break;
1121
1122 case BINARY_ADD:
1123 w = POP();
1124 v = TOP();
1125 if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
1126 /* INLINE: int + int */
1127 register long a, b, i;
1128 a = PyInt_AS_LONG(v);
1129 b = PyInt_AS_LONG(w);
1130 i = a + b;
1131 if ((i^a) < 0 && (i^b) < 0)
1132 goto slow_add;
1133 x = PyInt_FromLong(i);
1134 }
1135 else if (PyString_CheckExact(v) &&
1136 PyString_CheckExact(w)) {
1137 x = string_concatenate(v, w, f, next_instr);
1138 /* string_concatenate consumed the ref to v */
1139 goto skip_decref_vx;
1140 }
1141 else {
1142 slow_add:
1143 x = PyNumber_Add(v, w);
1144 }
1145 Py_DECREF(v);
1146 skip_decref_vx:
1147 Py_DECREF(w);
1148 SET_TOP(x);
1149 if (x != NULL) continue;
1150 break;
1151
1152 case BINARY_SUBTRACT:
1153 w = POP();
1154 v = TOP();
1155 if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
1156 /* INLINE: int - int */
1157 register long a, b, i;
1158 a = PyInt_AS_LONG(v);
1159 b = PyInt_AS_LONG(w);
1160 i = a - b;
1161 if ((i^a) < 0 && (i^~b) < 0)
1162 goto slow_sub;
1163 x = PyInt_FromLong(i);
1164 }
1165 else {
1166 slow_sub:
1167 x = PyNumber_Subtract(v, w);
1168 }
1169 Py_DECREF(v);
1170 Py_DECREF(w);
1171 SET_TOP(x);
1172 if (x != NULL) continue;
1173 break;
1174
1175 case BINARY_SUBSCR:
1176 w = POP();
1177 v = TOP();
1178 if (PyList_CheckExact(v) && PyInt_CheckExact(w)) {
1179 /* INLINE: list[int] */
1180 Py_ssize_t i = PyInt_AsSsize_t(w);
1181 if (i < 0)
1182 i += PyList_GET_SIZE(v);
1183 if (i >= 0 && i < PyList_GET_SIZE(v)) {
1184 x = PyList_GET_ITEM(v, i);
1185 Py_INCREF(x);
1186 }
1187 else
1188 goto slow_get;
1189 }
1190 else
1191 slow_get:
1192 x = PyObject_GetItem(v, w);
1193 Py_DECREF(v);
1194 Py_DECREF(w);
1195 SET_TOP(x);
1196 if (x != NULL) continue;
1197 break;
1198
1199 case BINARY_LSHIFT:
1200 w = POP();
1201 v = TOP();
1202 x = PyNumber_Lshift(v, w);
1203 Py_DECREF(v);
1204 Py_DECREF(w);
1205 SET_TOP(x);
1206 if (x != NULL) continue;
1207 break;
1208
1209 case BINARY_RSHIFT:
1210 w = POP();
1211 v = TOP();
1212 x = PyNumber_Rshift(v, w);
1213 Py_DECREF(v);
1214 Py_DECREF(w);
1215 SET_TOP(x);
1216 if (x != NULL) continue;
1217 break;
1218
1219 case BINARY_AND:
1220 w = POP();
1221 v = TOP();
1222 x = PyNumber_And(v, w);
1223 Py_DECREF(v);
1224 Py_DECREF(w);
1225 SET_TOP(x);
1226 if (x != NULL) continue;
1227 break;
1228
1229 case BINARY_XOR:
1230 w = POP();
1231 v = TOP();
1232 x = PyNumber_Xor(v, w);
1233 Py_DECREF(v);
1234 Py_DECREF(w);
1235 SET_TOP(x);
1236 if (x != NULL) continue;
1237 break;
1238
1239 case BINARY_OR:
1240 w = POP();
1241 v = TOP();
1242 x = PyNumber_Or(v, w);
1243 Py_DECREF(v);
1244 Py_DECREF(w);
1245 SET_TOP(x);
1246 if (x != NULL) continue;
1247 break;
1248
1249 case LIST_APPEND:
1250 w = POP();
1251 v = POP();
1252 err = PyList_Append(v, w);
1253 Py_DECREF(v);
1254 Py_DECREF(w);
1255 if (err == 0) {
1256 PREDICT(JUMP_ABSOLUTE);
1257 continue;
1258 }
1259 break;
1260
1261 case INPLACE_POWER:
1262 w = POP();
1263 v = TOP();
1264 x = PyNumber_InPlacePower(v, w, Py_None);
1265 Py_DECREF(v);
1266 Py_DECREF(w);
1267 SET_TOP(x);
1268 if (x != NULL) continue;
1269 break;
1270
1271 case INPLACE_MULTIPLY:
1272 w = POP();
1273 v = TOP();
1274 x = PyNumber_InPlaceMultiply(v, w);
1275 Py_DECREF(v);
1276 Py_DECREF(w);
1277 SET_TOP(x);
1278 if (x != NULL) continue;
1279 break;
1280
1281 case INPLACE_DIVIDE:
1282 if (!_Py_QnewFlag) {
1283 w = POP();
1284 v = TOP();
1285 x = PyNumber_InPlaceDivide(v, w);
1286 Py_DECREF(v);
1287 Py_DECREF(w);
1288 SET_TOP(x);
1289 if (x != NULL) continue;
1290 break;
1291 }
1292 /* -Qnew is in effect: fall through to
1293 INPLACE_TRUE_DIVIDE */
1294 case INPLACE_TRUE_DIVIDE:
1295 w = POP();
1296 v = TOP();
1297 x = PyNumber_InPlaceTrueDivide(v, w);
1298 Py_DECREF(v);
1299 Py_DECREF(w);
1300 SET_TOP(x);
1301 if (x != NULL) continue;
1302 break;
1303
1304 case INPLACE_FLOOR_DIVIDE:
1305 w = POP();
1306 v = TOP();
1307 x = PyNumber_InPlaceFloorDivide(v, w);
1308 Py_DECREF(v);
1309 Py_DECREF(w);
1310 SET_TOP(x);
1311 if (x != NULL) continue;
1312 break;
1313
1314 case INPLACE_MODULO:
1315 w = POP();
1316 v = TOP();
1317 x = PyNumber_InPlaceRemainder(v, w);
1318 Py_DECREF(v);
1319 Py_DECREF(w);
1320 SET_TOP(x);
1321 if (x != NULL) continue;
1322 break;
1323
1324 case INPLACE_ADD:
1325 w = POP();
1326 v = TOP();
1327 if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
1328 /* INLINE: int + int */
1329 register long a, b, i;
1330 a = PyInt_AS_LONG(v);
1331 b = PyInt_AS_LONG(w);
1332 i = a + b;
1333 if ((i^a) < 0 && (i^b) < 0)
1334 goto slow_iadd;
1335 x = PyInt_FromLong(i);
1336 }
1337 else if (PyString_CheckExact(v) &&
1338 PyString_CheckExact(w)) {
1339 x = string_concatenate(v, w, f, next_instr);
1340 /* string_concatenate consumed the ref to v */
1341 goto skip_decref_v;
1342 }
1343 else {
1344 slow_iadd:
1345 x = PyNumber_InPlaceAdd(v, w);
1346 }
1347 Py_DECREF(v);
1348 skip_decref_v:
1349 Py_DECREF(w);
1350 SET_TOP(x);
1351 if (x != NULL) continue;
1352 break;
1353
1354 case INPLACE_SUBTRACT:
1355 w = POP();
1356 v = TOP();
1357 if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
1358 /* INLINE: int - int */
1359 register long a, b, i;
1360 a = PyInt_AS_LONG(v);
1361 b = PyInt_AS_LONG(w);
1362 i = a - b;
1363 if ((i^a) < 0 && (i^~b) < 0)
1364 goto slow_isub;
1365 x = PyInt_FromLong(i);
1366 }
1367 else {
1368 slow_isub:
1369 x = PyNumber_InPlaceSubtract(v, w);
1370 }
1371 Py_DECREF(v);
1372 Py_DECREF(w);
1373 SET_TOP(x);
1374 if (x != NULL) continue;
1375 break;
1376
1377 case INPLACE_LSHIFT:
1378 w = POP();
1379 v = TOP();
1380 x = PyNumber_InPlaceLshift(v, w);
1381 Py_DECREF(v);
1382 Py_DECREF(w);
1383 SET_TOP(x);
1384 if (x != NULL) continue;
1385 break;
1386
1387 case INPLACE_RSHIFT:
1388 w = POP();
1389 v = TOP();
1390 x = PyNumber_InPlaceRshift(v, w);
1391 Py_DECREF(v);
1392 Py_DECREF(w);
1393 SET_TOP(x);
1394 if (x != NULL) continue;
1395 break;
1396
1397 case INPLACE_AND:
1398 w = POP();
1399 v = TOP();
1400 x = PyNumber_InPlaceAnd(v, w);
1401 Py_DECREF(v);
1402 Py_DECREF(w);
1403 SET_TOP(x);
1404 if (x != NULL) continue;
1405 break;
1406
1407 case INPLACE_XOR:
1408 w = POP();
1409 v = TOP();
1410 x = PyNumber_InPlaceXor(v, w);
1411 Py_DECREF(v);
1412 Py_DECREF(w);
1413 SET_TOP(x);
1414 if (x != NULL) continue;
1415 break;
1416
1417 case INPLACE_OR:
1418 w = POP();
1419 v = TOP();
1420 x = PyNumber_InPlaceOr(v, w);
1421 Py_DECREF(v);
1422 Py_DECREF(w);
1423 SET_TOP(x);
1424 if (x != NULL) continue;
1425 break;
1426
1427 case SLICE+0:
1428 case SLICE+1:
1429 case SLICE+2:
1430 case SLICE+3:
1431 if ((opcode-SLICE) & 2)
1432 w = POP();
1433 else
1434 w = NULL;
1435 if ((opcode-SLICE) & 1)
1436 v = POP();
1437 else
1438 v = NULL;
1439 u = TOP();
1440 x = apply_slice(u, v, w);
1441 Py_DECREF(u);
1442 Py_XDECREF(v);
1443 Py_XDECREF(w);
1444 SET_TOP(x);
1445 if (x != NULL) continue;
1446 break;
1447
1448 case STORE_SLICE+0:
1449 case STORE_SLICE+1:
1450 case STORE_SLICE+2:
1451 case STORE_SLICE+3:
1452 if ((opcode-STORE_SLICE) & 2)
1453 w = POP();
1454 else
1455 w = NULL;
1456 if ((opcode-STORE_SLICE) & 1)
1457 v = POP();
1458 else
1459 v = NULL;
1460 u = POP();
1461 t = POP();
1462 err = assign_slice(u, v, w, t); /* u[v:w] = t */
1463 Py_DECREF(t);
1464 Py_DECREF(u);
1465 Py_XDECREF(v);
1466 Py_XDECREF(w);
1467 if (err == 0) continue;
1468 break;
1469
1470 case DELETE_SLICE+0:
1471 case DELETE_SLICE+1:
1472 case DELETE_SLICE+2:
1473 case DELETE_SLICE+3:
1474 if ((opcode-DELETE_SLICE) & 2)
1475 w = POP();
1476 else
1477 w = NULL;
1478 if ((opcode-DELETE_SLICE) & 1)
1479 v = POP();
1480 else
1481 v = NULL;
1482 u = POP();
1483 err = assign_slice(u, v, w, (PyObject *)NULL);
1484 /* del u[v:w] */
1485 Py_DECREF(u);
1486 Py_XDECREF(v);
1487 Py_XDECREF(w);
1488 if (err == 0) continue;
1489 break;
1490
1491 case STORE_SUBSCR:
1492 w = TOP();
1493 v = SECOND();
1494 u = THIRD();
1495 STACKADJ(-3);
1496 /* v[w] = u */
1497 err = PyObject_SetItem(v, w, u);
1498 Py_DECREF(u);
1499 Py_DECREF(v);
1500 Py_DECREF(w);
1501 if (err == 0) continue;
1502 break;
1503
1504 case DELETE_SUBSCR:
1505 w = TOP();
1506 v = SECOND();
1507 STACKADJ(-2);
1508 /* del v[w] */
1509 err = PyObject_DelItem(v, w);
1510 Py_DECREF(v);
1511 Py_DECREF(w);
1512 if (err == 0) continue;
1513 break;
1514
1515 case PRINT_EXPR:
1516 v = POP();
1517 w = PySys_GetObject("displayhook");
1518 if (w == NULL) {
1519 PyErr_SetString(PyExc_RuntimeError,
1520 "lost sys.displayhook");
1521 err = -1;
1522 x = NULL;
1523 }
1524 if (err == 0) {
1525 x = PyTuple_Pack(1, v);
1526 if (x == NULL)
1527 err = -1;
1528 }
1529 if (err == 0) {
1530 w = PyEval_CallObject(w, x);
1531 Py_XDECREF(w);
1532 if (w == NULL)
1533 err = -1;
1534 }
1535 Py_DECREF(v);
1536 Py_XDECREF(x);
1537 break;
1538
1539 case PRINT_ITEM_TO:
1540 w = stream = POP();
1541 /* fall through to PRINT_ITEM */
1542
1543 case PRINT_ITEM:
1544 v = POP();
1545 if (stream == NULL || stream == Py_None) {
1546 w = PySys_GetObject("stdout");
1547 if (w == NULL) {
1548 PyErr_SetString(PyExc_RuntimeError,
1549 "lost sys.stdout");
1550 err = -1;
1551 }
1552 }
1553 /* PyFile_SoftSpace() can exececute arbitrary code
1554 if sys.stdout is an instance with a __getattr__.
1555 If __getattr__ raises an exception, w will
1556 be freed, so we need to prevent that temporarily. */
1557 Py_XINCREF(w);
1558 if (w != NULL && PyFile_SoftSpace(w, 0))
1559 err = PyFile_WriteString(" ", w);
1560 if (err == 0)
1561 err = PyFile_WriteObject(v, w, Py_PRINT_RAW);
1562 if (err == 0) {
1563 /* XXX move into writeobject() ? */
1564 if (PyString_Check(v)) {
1565 char *s = PyString_AS_STRING(v);
1566 Py_ssize_t len = PyString_GET_SIZE(v);
1567 if (len == 0 ||
1568 !isspace(Py_CHARMASK(s[len-1])) ||
1569 s[len-1] == ' ')
1570 PyFile_SoftSpace(w, 1);
1571 }
1572 #ifdef Py_USING_UNICODE
1573 else if (PyUnicode_Check(v)) {
1574 Py_UNICODE *s = PyUnicode_AS_UNICODE(v);
1575 Py_ssize_t len = PyUnicode_GET_SIZE(v);
1576 if (len == 0 ||
1577 !Py_UNICODE_ISSPACE(s[len-1]) ||
1578 s[len-1] == ' ')
1579 PyFile_SoftSpace(w, 1);
1580 }
1581 #endif
1582 else
1583 PyFile_SoftSpace(w, 1);
1584 }
1585 Py_XDECREF(w);
1586 Py_DECREF(v);
1587 Py_XDECREF(stream);
1588 stream = NULL;
1589 if (err == 0)
1590 continue;
1591 break;
1592
1593 case PRINT_NEWLINE_TO:
1594 w = stream = POP();
1595 /* fall through to PRINT_NEWLINE */
1596
1597 case PRINT_NEWLINE:
1598 if (stream == NULL || stream == Py_None) {
1599 w = PySys_GetObject("stdout");
1600 if (w == NULL)
1601 PyErr_SetString(PyExc_RuntimeError,
1602 "lost sys.stdout");
1603 }
1604 if (w != NULL) {
1605 err = PyFile_WriteString("\n", w);
1606 if (err == 0)
1607 PyFile_SoftSpace(w, 0);
1608 }
1609 Py_XDECREF(stream);
1610 stream = NULL;
1611 break;
1612
1613
1614 #ifdef CASE_TOO_BIG
1615 default: switch (opcode) {
1616 #endif
1617 case RAISE_VARARGS:
1618 u = v = w = NULL;
1619 switch (oparg) {
1620 case 3:
1621 u = POP(); /* traceback */
1622 /* Fallthrough */
1623 case 2:
1624 v = POP(); /* value */
1625 /* Fallthrough */
1626 case 1:
1627 w = POP(); /* exc */
1628 case 0: /* Fallthrough */
1629 why = do_raise(w, v, u);
1630 break;
1631 default:
1632 PyErr_SetString(PyExc_SystemError,
1633 "bad RAISE_VARARGS oparg");
1634 why = WHY_EXCEPTION;
1635 break;
1636 }
1637 break;
1638
1639 case LOAD_LOCALS:
1640 if ((x = f->f_locals) != NULL) {
1641 Py_INCREF(x);
1642 PUSH(x);
1643 continue;
1644 }
1645 PyErr_SetString(PyExc_SystemError, "no locals");
1646 break;
1647
1648 case RETURN_VALUE:
1649 retval = POP();
1650 why = WHY_RETURN;
1651 goto fast_block_end;
1652
1653 case YIELD_VALUE:
1654 retval = POP();
1655 f->f_stacktop = stack_pointer;
1656 why = WHY_YIELD;
1657 goto fast_yield;
1658
1659 case EXEC_STMT:
1660 w = TOP();
1661 v = SECOND();
1662 u = THIRD();
1663 STACKADJ(-3);
1664 READ_TIMESTAMP(intr0);
1665 err = exec_statement(f, u, v, w);
1666 READ_TIMESTAMP(intr1);
1667 Py_DECREF(u);
1668 Py_DECREF(v);
1669 Py_DECREF(w);
1670 break;
1671
1672 case POP_BLOCK:
1673 {
1674 PyTryBlock *b = PyFrame_BlockPop(f);
1675 while (STACK_LEVEL() > b->b_level) {
1676 v = POP();
1677 Py_DECREF(v);
1678 }
1679 }
1680 continue;
1681
1682 case END_FINALLY:
1683 v = POP();
1684 if (PyInt_Check(v)) {
1685 why = (enum why_code) PyInt_AS_LONG(v);
1686 assert(why != WHY_YIELD);
1687 if (why == WHY_RETURN ||
1688 why == WHY_CONTINUE)
1689 retval = POP();
1690 }
1691 else if (PyExceptionClass_Check(v) || PyString_Check(v)) {
1692 w = POP();
1693 u = POP();
1694 PyErr_Restore(v, w, u);
1695 why = WHY_RERAISE;
1696 break;
1697 }
1698 else if (v != Py_None) {
1699 PyErr_SetString(PyExc_SystemError,
1700 "'finally' pops bad exception");
1701 why = WHY_EXCEPTION;
1702 }
1703 Py_DECREF(v);
1704 break;
1705
1706 case BUILD_CLASS:
1707 u = TOP();
1708 v = SECOND();
1709 w = THIRD();
1710 STACKADJ(-2);
1711 x = build_class(u, v, w);
1712 SET_TOP(x);
1713 Py_DECREF(u);
1714 Py_DECREF(v);
1715 Py_DECREF(w);
1716 break;
1717
1718 case STORE_NAME:
1719 w = GETITEM(names, oparg);
1720 v = POP();
1721 if ((x = f->f_locals) != NULL) {
1722 if (PyDict_CheckExact(x))
1723 err = PyDict_SetItem(x, w, v);
1724 else
1725 err = PyObject_SetItem(x, w, v);
1726 Py_DECREF(v);
1727 if (err == 0) continue;
1728 break;
1729 }
1730 PyErr_Format(PyExc_SystemError,
1731 "no locals found when storing %s",
1732 PyObject_REPR(w));
1733 break;
1734
1735 case DELETE_NAME:
1736 w = GETITEM(names, oparg);
1737 if ((x = f->f_locals) != NULL) {
1738 if ((err = PyObject_DelItem(x, w)) != 0)
1739 format_exc_check_arg(PyExc_NameError,
1740 NAME_ERROR_MSG ,w);
1741 break;
1742 }
1743 PyErr_Format(PyExc_SystemError,
1744 "no locals when deleting %s",
1745 PyObject_REPR(w));
1746 break;
1747
1748 PREDICTED_WITH_ARG(UNPACK_SEQUENCE);
1749 case UNPACK_SEQUENCE:
1750 v = POP();
1751 if (PyTuple_CheckExact(v) && PyTuple_GET_SIZE(v) == oparg) {
1752 PyObject **items = ((PyTupleObject *)v)->ob_item;
1753 while (oparg--) {
1754 w = items[oparg];
1755 Py_INCREF(w);
1756 PUSH(w);
1757 }
1758 Py_DECREF(v);
1759 continue;
1760 } else if (PyList_CheckExact(v) && PyList_GET_SIZE(v) == oparg) {
1761 PyObject **items = ((PyListObject *)v)->ob_item;
1762 while (oparg--) {
1763 w = items[oparg];
1764 Py_INCREF(w);
1765 PUSH(w);
1766 }
1767 } else if (unpack_iterable(v, oparg,
1768 stack_pointer + oparg))
1769 stack_pointer += oparg;
1770 else {
1771 if (PyErr_ExceptionMatches(PyExc_TypeError))
1772 PyErr_SetString(PyExc_TypeError,
1773 "unpack non-sequence");
1774 why = WHY_EXCEPTION;
1775 }
1776 Py_DECREF(v);
1777 break;
1778
1779 case STORE_ATTR:
1780 w = GETITEM(names, oparg);
1781 v = TOP();
1782 u = SECOND();
1783 STACKADJ(-2);
1784 err = PyObject_SetAttr(v, w, u); /* v.w = u */
1785 Py_DECREF(v);
1786 Py_DECREF(u);
1787 if (err == 0) continue;
1788 break;
1789
1790 case DELETE_ATTR:
1791 w = GETITEM(names, oparg);
1792 v = POP();
1793 err = PyObject_SetAttr(v, w, (PyObject *)NULL);
1794 /* del v.w */
1795 Py_DECREF(v);
1796 break;
1797
1798 case STORE_GLOBAL:
1799 w = GETITEM(names, oparg);
1800 v = POP();
1801 err = PyDict_SetItem(f->f_globals, w, v);
1802 Py_DECREF(v);
1803 if (err == 0) continue;
1804 break;
1805
1806 case DELETE_GLOBAL:
1807 w = GETITEM(names, oparg);
1808 if ((err = PyDict_DelItem(f->f_globals, w)) != 0)
1809 format_exc_check_arg(
1810 PyExc_NameError, GLOBAL_NAME_ERROR_MSG, w);
1811 break;
1812
1813 case LOAD_NAME:
1814 w = GETITEM(names, oparg);
1815 if ((v = f->f_locals) == NULL) {
1816 PyErr_Format(PyExc_SystemError,
1817 "no locals when loading %s",
1818 PyObject_REPR(w));
1819 break;
1820 }
1821 if (PyDict_CheckExact(v)) {
1822 x = PyDict_GetItem(v, w);
1823 Py_XINCREF(x);
1824 }
1825 else {
1826 x = PyObject_GetItem(v, w);
1827 if (x == NULL && PyErr_Occurred()) {
1828 if (!PyErr_ExceptionMatches(PyExc_KeyError))
1829 break;
1830 PyErr_Clear();
1831 }
1832 }
1833 if (x == NULL) {
1834 x = PyDict_GetItem(f->f_globals, w);
1835 if (x == NULL) {
1836 x = PyDict_GetItem(f->f_builtins, w);
1837 if (x == NULL) {
1838 format_exc_check_arg(
1839 PyExc_NameError,
1840 NAME_ERROR_MSG ,w);
1841 break;
1842 }
1843 }
1844 Py_INCREF(x);
1845 }
1846 PUSH(x);
1847 continue;
1848
1849 case LOAD_GLOBAL:
1850 w = GETITEM(names, oparg);
1851 if (PyString_CheckExact(w)) {
1852 /* Inline the PyDict_GetItem() calls.
1853 WARNING: this is an extreme speed hack.
1854 Do not try this at home. */
1855 long hash = ((PyStringObject *)w)->ob_shash;
1856 if (hash != -1) {
1857 PyDictObject *d;
1858 PyDictEntry *e;
1859 d = (PyDictObject *)(f->f_globals);
1860 e = d->ma_lookup(d, w, hash);
1861 if (e == NULL) {
1862 x = NULL;
1863 break;
1864 }
1865 x = e->me_value;
1866 if (x != NULL) {
1867 Py_INCREF(x);
1868 PUSH(x);
1869 continue;
1870 }
1871 d = (PyDictObject *)(f->f_builtins);
1872 e = d->ma_lookup(d, w, hash);
1873 if (e == NULL) {
1874 x = NULL;
1875 break;
1876 }
1877 x = e->me_value;
1878 if (x != NULL) {
1879 Py_INCREF(x);
1880 PUSH(x);
1881 continue;
1882 }
1883 goto load_global_error;
1884 }
1885 }
1886 /* This is the un-inlined version of the code above */
1887 x = PyDict_GetItem(f->f_globals, w);
1888 if (x == NULL) {
1889 x = PyDict_GetItem(f->f_builtins, w);
1890 if (x == NULL) {
1891 load_global_error:
1892 format_exc_check_arg(
1893 PyExc_NameError,
1894 GLOBAL_NAME_ERROR_MSG, w);
1895 break;
1896 }
1897 }
1898 Py_INCREF(x);
1899 PUSH(x);
1900 continue;
1901
1902 case DELETE_FAST:
1903 x = GETLOCAL(oparg);
1904 if (x != NULL) {
1905 SETLOCAL(oparg, NULL);
1906 continue;
1907 }
1908 format_exc_check_arg(
1909 PyExc_UnboundLocalError,
1910 UNBOUNDLOCAL_ERROR_MSG,
1911 PyTuple_GetItem(co->co_varnames, oparg)
1912 );
1913 break;
1914
1915 case LOAD_CLOSURE:
1916 x = freevars[oparg];
1917 Py_INCREF(x);
1918 PUSH(x);
1919 if (x != NULL) continue;
1920 break;
1921
1922 case LOAD_DEREF:
1923 x = freevars[oparg];
1924 w = PyCell_Get(x);
1925 if (w != NULL) {
1926 PUSH(w);
1927 continue;
1928 }
1929 err = -1;
1930 /* Don't stomp existing exception */
1931 if (PyErr_Occurred())
1932 break;
1933 if (oparg < PyTuple_GET_SIZE(co->co_cellvars)) {
1934 v = PyTuple_GET_ITEM(co->co_cellvars,
1935 oparg);
1936 format_exc_check_arg(
1937 PyExc_UnboundLocalError,
1938 UNBOUNDLOCAL_ERROR_MSG,
1939 v);
1940 } else {
1941 v = PyTuple_GET_ITEM(
1942 co->co_freevars,
1943 oparg - PyTuple_GET_SIZE(co->co_cellvars));
1944 format_exc_check_arg(
1945 PyExc_NameError,
1946 UNBOUNDFREE_ERROR_MSG,
1947 v);
1948 }
1949 break;
1950
1951 case STORE_DEREF:
1952 w = POP();
1953 x = freevars[oparg];
1954 PyCell_Set(x, w);
1955 Py_DECREF(w);
1956 continue;
1957
1958 case BUILD_TUPLE:
1959 x = PyTuple_New(oparg);
1960 if (x != NULL) {
1961 for (; --oparg >= 0;) {
1962 w = POP();
1963 PyTuple_SET_ITEM(x, oparg, w);
1964 }
1965 PUSH(x);
1966 continue;
1967 }
1968 break;
1969
1970 case BUILD_LIST:
1971 x = PyList_New(oparg);
1972 if (x != NULL) {
1973 for (; --oparg >= 0;) {
1974 w = POP();
1975 PyList_SET_ITEM(x, oparg, w);
1976 }
1977 PUSH(x);
1978 continue;
1979 }
1980 break;
1981
1982 case BUILD_MAP:
1983 x = PyDict_New();
1984 PUSH(x);
1985 if (x != NULL) continue;
1986 break;
1987
1988 case LOAD_ATTR:
1989 w = GETITEM(names, oparg);
1990 v = TOP();
1991 x = PyObject_GetAttr(v, w);
1992 Py_DECREF(v);
1993 SET_TOP(x);
1994 if (x != NULL) continue;
1995 break;
1996
1997 case COMPARE_OP:
1998 w = POP();
1999 v = TOP();
2000 if (PyInt_CheckExact(w) && PyInt_CheckExact(v)) {
2001 /* INLINE: cmp(int, int) */
2002 register long a, b;
2003 register int res;
2004 a = PyInt_AS_LONG(v);
2005 b = PyInt_AS_LONG(w);
2006 switch (oparg) {
2007 case PyCmp_LT: res = a < b; break;
2008 case PyCmp_LE: res = a <= b; break;
2009 case PyCmp_EQ: res = a == b; break;
2010 case PyCmp_NE: res = a != b; break;
2011 case PyCmp_GT: res = a > b; break;
2012 case PyCmp_GE: res = a >= b; break;
2013 case PyCmp_IS: res = v == w; break;
2014 case PyCmp_IS_NOT: res = v != w; break;
2015 default: goto slow_compare;
2016 }
2017 x = res ? Py_True : Py_False;
2018 Py_INCREF(x);
2019 }
2020 else {
2021 slow_compare:
2022 x = cmp_outcome(oparg, v, w);
2023 }
2024 Py_DECREF(v);
2025 Py_DECREF(w);
2026 SET_TOP(x);
2027 if (x == NULL) break;
2028 PREDICT(JUMP_IF_FALSE);
2029 PREDICT(JUMP_IF_TRUE);
2030 continue;
2031
2032 case IMPORT_NAME:
2033 w = GETITEM(names, oparg);
2034 x = PyDict_GetItemString(f->f_builtins, "__import__");
2035 if (x == NULL) {
2036 PyErr_SetString(PyExc_ImportError,
2037 "__import__ not found");
2038 break;
2039 }
2040 v = POP();
2041 u = TOP();
2042 if (PyInt_AsLong(u) != -1 || PyErr_Occurred())
2043 w = PyTuple_Pack(5,
2044 w,
2045 f->f_globals,
2046 f->f_locals == NULL ?
2047 Py_None : f->f_locals,
2048 v,
2049 u);
2050 else
2051 w = PyTuple_Pack(4,
2052 w,
2053 f->f_globals,
2054 f->f_locals == NULL ?
2055 Py_None : f->f_locals,
2056 v);
2057 Py_DECREF(v);
2058 Py_DECREF(u);
2059 if (w == NULL) {
2060 u = POP();
2061 x = NULL;
2062 break;
2063 }
2064 READ_TIMESTAMP(intr0);
2065 x = PyEval_CallObject(x, w);
2066 READ_TIMESTAMP(intr1);
2067 Py_DECREF(w);
2068 SET_TOP(x);
2069 if (x != NULL) continue;
2070 break;
2071
2072 case IMPORT_STAR:
2073 v = POP();
2074 PyFrame_FastToLocals(f);
2075 if ((x = f->f_locals) == NULL) {
2076 PyErr_SetString(PyExc_SystemError,
2077 "no locals found during 'import *'");
2078 break;
2079 }
2080 READ_TIMESTAMP(intr0);
2081 err = import_all_from(x, v);
2082 READ_TIMESTAMP(intr1);
2083 PyFrame_LocalsToFast(f, 0);
2084 Py_DECREF(v);
2085 if (err == 0) continue;
2086 break;
2087
2088 case IMPORT_FROM:
2089 w = GETITEM(names, oparg);
2090 v = TOP();
2091 READ_TIMESTAMP(intr0);
2092 x = import_from(v, w);
2093 READ_TIMESTAMP(intr1);
2094 PUSH(x);
2095 if (x != NULL) continue;
2096 break;
2097
2098 case JUMP_FORWARD:
2099 JUMPBY(oparg);
2100 goto fast_next_opcode;
2101
2102 PREDICTED_WITH_ARG(JUMP_IF_FALSE);
2103 case JUMP_IF_FALSE:
2104 w = TOP();
2105 if (w == Py_True) {
2106 PREDICT(POP_TOP);
2107 goto fast_next_opcode;
2108 }
2109 if (w == Py_False) {
2110 JUMPBY(oparg);
2111 goto fast_next_opcode;
2112 }
2113 err = PyObject_IsTrue(w);
2114 if (err > 0)
2115 err = 0;
2116 else if (err == 0)
2117 JUMPBY(oparg);
2118 else
2119 break;
2120 continue;
2121
2122 PREDICTED_WITH_ARG(JUMP_IF_TRUE);
2123 case JUMP_IF_TRUE:
2124 w = TOP();
2125 if (w == Py_False) {
2126 PREDICT(POP_TOP);
2127 goto fast_next_opcode;
2128 }
2129 if (w == Py_True) {
2130 JUMPBY(oparg);
2131 goto fast_next_opcode;
2132 }
2133 err = PyObject_IsTrue(w);
2134 if (err > 0) {
2135 err = 0;
2136 JUMPBY(oparg);
2137 }
2138 else if (err == 0)
2139 ;
2140 else
2141 break;
2142 continue;
2143
2144 PREDICTED_WITH_ARG(JUMP_ABSOLUTE);
2145 case JUMP_ABSOLUTE:
2146 JUMPTO(oparg);
2147 continue;
2148
2149 case GET_ITER:
2150 /* before: [obj]; after [getiter(obj)] */
2151 v = TOP();
2152 x = PyObject_GetIter(v);
2153 Py_DECREF(v);
2154 if (x != NULL) {
2155 SET_TOP(x);
2156 PREDICT(FOR_ITER);
2157 continue;
2158 }
2159 STACKADJ(-1);
2160 break;
2161
2162 PREDICTED_WITH_ARG(FOR_ITER);
2163 case FOR_ITER:
2164 /* before: [iter]; after: [iter, iter()] *or* [] */
2165 v = TOP();
2166 x = (*v->ob_type->tp_iternext)(v);
2167 if (x != NULL) {
2168 PUSH(x);
2169 PREDICT(STORE_FAST);
2170 PREDICT(UNPACK_SEQUENCE);
2171 continue;
2172 }
2173 if (PyErr_Occurred()) {
2174 if (!PyErr_ExceptionMatches(PyExc_StopIteration))
2175 break;
2176 PyErr_Clear();
2177 }
2178 /* iterator ended normally */
2179 x = v = POP();
2180 Py_DECREF(v);
2181 JUMPBY(oparg);
2182 continue;
2183
2184 case BREAK_LOOP:
2185 why = WHY_BREAK;
2186 goto fast_block_end;
2187
2188 case CONTINUE_LOOP:
2189 retval = PyInt_FromLong(oparg);
2190 if (!retval) {
2191 x = NULL;
2192 break;
2193 }
2194 why = WHY_CONTINUE;
2195 goto fast_block_end;
2196
2197 case SETUP_LOOP:
2198 case SETUP_EXCEPT:
2199 case SETUP_FINALLY:
2200 /* NOTE: If you add any new block-setup opcodes that are not try/except/finally
2201 handlers, you may need to update the PyGen_NeedsFinalizing() function. */
2202
2203 PyFrame_BlockSetup(f, opcode, INSTR_OFFSET() + oparg,
2204 STACK_LEVEL());
2205 continue;
2206
2207 case WITH_CLEANUP:
2208 {
2209 /* TOP is the context.__exit__ bound method.
2210 Below that are 1-3 values indicating how/why
2211 we entered the finally clause:
2212 - SECOND = None
2213 - (SECOND, THIRD) = (WHY_{RETURN,CONTINUE}), retval
2214 - SECOND = WHY_*; no retval below it
2215 - (SECOND, THIRD, FOURTH) = exc_info()
2216 In the last case, we must call
2217 TOP(SECOND, THIRD, FOURTH)
2218 otherwise we must call
2219 TOP(None, None, None)
2220
2221 In addition, if the stack represents an exception,
2222 *and* the function call returns a 'true' value, we
2223 "zap" this information, to prevent END_FINALLY from
2224 re-raising the exception. (But non-local gotos
2225 should still be resumed.)
2226 */
2227
2228 x = TOP();
2229 u = SECOND();
2230 if (PyInt_Check(u) || u == Py_None) {
2231 u = v = w = Py_None;
2232 }
2233 else {
2234 v = THIRD();
2235 w = FOURTH();
2236 }
2237 /* XXX Not the fastest way to call it... */
2238 x = PyObject_CallFunctionObjArgs(x, u, v, w, NULL);
2239 if (x == NULL)
2240 break; /* Go to error exit */
2241 if (u != Py_None && PyObject_IsTrue(x)) {
2242 /* There was an exception and a true return */
2243 Py_DECREF(x);
2244 x = TOP(); /* Again */
2245 STACKADJ(-3);
2246 Py_INCREF(Py_None);
2247 SET_TOP(Py_None);
2248 Py_DECREF(x);
2249 Py_DECREF(u);
2250 Py_DECREF(v);
2251 Py_DECREF(w);
2252 } else {
2253 /* Let END_FINALLY do its thing */
2254 Py_DECREF(x);
2255 x = POP();
2256 Py_DECREF(x);
2257 }
2258 break;
2259 }
2260
2261 case CALL_FUNCTION:
2262 {
2263 PyObject **sp;
2264 PCALL(PCALL_ALL);
2265 sp = stack_pointer;
2266 #ifdef WITH_TSC
2267 x = call_function(&sp, oparg, &intr0, &intr1);
2268 #else
2269 x = call_function(&sp, oparg);
2270 #endif
2271 stack_pointer = sp;
2272 PUSH(x);
2273 if (x != NULL)
2274 continue;
2275 break;
2276 }
2277
2278 case CALL_FUNCTION_VAR:
2279 case CALL_FUNCTION_KW:
2280 case CALL_FUNCTION_VAR_KW:
2281 {
2282 int na = oparg & 0xff;
2283 int nk = (oparg>>8) & 0xff;
2284 int flags = (opcode - CALL_FUNCTION) & 3;
2285 int n = na + 2 * nk;
2286 PyObject **pfunc, *func, **sp;
2287 PCALL(PCALL_ALL);
2288 if (flags & CALL_FLAG_VAR)
2289 n++;
2290 if (flags & CALL_FLAG_KW)
2291 n++;
2292 pfunc = stack_pointer - n - 1;
2293 func = *pfunc;
2294
2295 if (PyMethod_Check(func)
2296 && PyMethod_GET_SELF(func) != NULL) {
2297 PyObject *self = PyMethod_GET_SELF(func);
2298 Py_INCREF(self);
2299 func = PyMethod_GET_FUNCTION(func);
2300 Py_INCREF(func);
2301 Py_DECREF(*pfunc);
2302 *pfunc = self;
2303 na++;
2304 n++;
2305 } else
2306 Py_INCREF(func);
2307 sp = stack_pointer;
2308 READ_TIMESTAMP(intr0);
2309 x = ext_do_call(func, &sp, flags, na, nk);
2310 READ_TIMESTAMP(intr1);
2311 stack_pointer = sp;
2312 Py_DECREF(func);
2313
2314 while (stack_pointer > pfunc) {
2315 w = POP();
2316 Py_DECREF(w);
2317 }
2318 PUSH(x);
2319 if (x != NULL)
2320 continue;
2321 break;
2322 }
2323
2324 case MAKE_FUNCTION:
2325 v = POP(); /* code object */
2326 x = PyFunction_New(v, f->f_globals);
2327 Py_DECREF(v);
2328 /* XXX Maybe this should be a separate opcode? */
2329 if (x != NULL && oparg > 0) {
2330 v = PyTuple_New(oparg);
2331 if (v == NULL) {
2332 Py_DECREF(x);
2333 x = NULL;
2334 break;
2335 }
2336 while (--oparg >= 0) {
2337 w = POP();
2338 PyTuple_SET_ITEM(v, oparg, w);
2339 }
2340 err = PyFunction_SetDefaults(x, v);
2341 Py_DECREF(v);
2342 }
2343 PUSH(x);
2344 break;
2345
2346 case MAKE_CLOSURE:
2347 {
2348 v = POP(); /* code object */
2349 x = PyFunction_New(v, f->f_globals);
2350 Py_DECREF(v);
2351 if (x != NULL) {
2352 v = POP();
2353 err = PyFunction_SetClosure(x, v);
2354 Py_DECREF(v);
2355 }
2356 if (x != NULL && oparg > 0) {
2357 v = PyTuple_New(oparg);
2358 if (v == NULL) {
2359 Py_DECREF(x);
2360 x = NULL;
2361 break;
2362 }
2363 while (--oparg >= 0) {
2364 w = POP();
2365 PyTuple_SET_ITEM(v, oparg, w);
2366 }
2367 err = PyFunction_SetDefaults(x, v);
2368 Py_DECREF(v);
2369 }
2370 PUSH(x);
2371 break;
2372 }
2373
2374 case BUILD_SLICE:
2375 if (oparg == 3)
2376 w = POP();
2377 else
2378 w = NULL;
2379 v = POP();
2380 u = TOP();
2381 x = PySlice_New(u, v, w);
2382 Py_DECREF(u);
2383 Py_DECREF(v);
2384 Py_XDECREF(w);
2385 SET_TOP(x);
2386 if (x != NULL) continue;
2387 break;
2388
2389 case EXTENDED_ARG:
2390 opcode = NEXTOP();
2391 oparg = oparg<<16 | NEXTARG();
2392 goto dispatch_opcode;
2393
2394 default:
2395 fprintf(stderr,
2396 "XXX lineno: %d, opcode: %d\n",
2397 PyCode_Addr2Line(f->f_code, f->f_lasti),
2398 opcode);
2399 PyErr_SetString(PyExc_SystemError, "unknown opcode");
2400 why = WHY_EXCEPTION;
2401 break;
2402
2403 #ifdef CASE_TOO_BIG
2404 }
2405 #endif
2406
2407 } /* switch */
2408
2409 on_error:
2410
2411 READ_TIMESTAMP(inst1);
2412
2413 /* Quickly continue if no error occurred */
2414
2415 if (why == WHY_NOT) {
2416 if (err == 0 && x != NULL) {
2417 #ifdef CHECKEXC
2418 /* This check is expensive! */
2419 if (PyErr_Occurred())
2420 fprintf(stderr,
2421 "XXX undetected error\n");
2422 else {
2423 #endif
2424 READ_TIMESTAMP(loop1);
2425 continue; /* Normal, fast path */
2426 #ifdef CHECKEXC
2427 }
2428 #endif
2429 }
2430 why = WHY_EXCEPTION;
2431 x = Py_None;
2432 err = 0;
2433 }
2434
2435 /* Double-check exception status */
2436
2437 if (why == WHY_EXCEPTION || why == WHY_RERAISE) {
2438 if (!PyErr_Occurred()) {
2439 PyErr_SetString(PyExc_SystemError,
2440 "error return without exception set");
2441 why = WHY_EXCEPTION;
2442 }
2443 }
2444 #ifdef CHECKEXC
2445 else {
2446 /* This check is expensive! */
2447 if (PyErr_Occurred()) {
2448 char buf[1024];
2449 sprintf(buf, "Stack unwind with exception "
2450 "set and why=%d", why);
2451 Py_FatalError(buf);
2452 }
2453 }
2454 #endif
2455
2456 /* Log traceback info if this is a real exception */
2457
2458 if (why == WHY_EXCEPTION) {
2459 PyTraceBack_Here(f);
2460
2461 if (tstate->c_tracefunc != NULL)
2462 call_exc_trace(tstate->c_tracefunc,
2463 tstate->c_traceobj, f);
2464 }
2465
2466 /* For the rest, treat WHY_RERAISE as WHY_EXCEPTION */
2467
2468 if (why == WHY_RERAISE)
2469 why = WHY_EXCEPTION;
2470
2471 /* Unwind stacks if a (pseudo) exception occurred */
2472
2473 fast_block_end:
2474 while (why != WHY_NOT && f->f_iblock > 0) {
2475 PyTryBlock *b = PyFrame_BlockPop(f);
2476
2477 assert(why != WHY_YIELD);
2478 if (b->b_type == SETUP_LOOP && why == WHY_CONTINUE) {
2479 /* For a continue inside a try block,
2480 don't pop the block for the loop. */
2481 PyFrame_BlockSetup(f, b->b_type, b->b_handler,
2482 b->b_level);
2483 why = WHY_NOT;
2484 JUMPTO(PyInt_AS_LONG(retval));
2485 Py_DECREF(retval);
2486 break;
2487 }
2488
2489 while (STACK_LEVEL() > b->b_level) {
2490 v = POP();
2491 Py_XDECREF(v);
2492 }
2493 if (b->b_type == SETUP_LOOP && why == WHY_BREAK) {
2494 why = WHY_NOT;
2495 JUMPTO(b->b_handler);
2496 break;
2497 }
2498 if (b->b_type == SETUP_FINALLY ||
2499 (b->b_type == SETUP_EXCEPT &&
2500 why == WHY_EXCEPTION)) {
2501 if (why == WHY_EXCEPTION) {
2502 PyObject *exc, *val, *tb;
2503 PyErr_Fetch(&exc, &val, &tb);
2504 if (val == NULL) {
2505 val = Py_None;
2506 Py_INCREF(val);
2507 }
2508 /* Make the raw exception data
2509 available to the handler,
2510 so a program can emulate the
2511 Python main loop. Don't do
2512 this for 'finally'. */
2513 if (b->b_type == SETUP_EXCEPT) {
2514 PyErr_NormalizeException(
2515 &exc, &val, &tb);
2516 set_exc_info(tstate,
2517 exc, val, tb);
2518 }
2519 if (tb == NULL) {
2520 Py_INCREF(Py_None);
2521 PUSH(Py_None);
2522 } else
2523 PUSH(tb);
2524 PUSH(val);
2525 PUSH(exc);
2526 }
2527 else {
2528 if (why & (WHY_RETURN | WHY_CONTINUE))
2529 PUSH(retval);
2530 v = PyInt_FromLong((long)why);
2531 PUSH(v);
2532 }
2533 why = WHY_NOT;
2534 JUMPTO(b->b_handler);
2535 break;
2536 }
2537 } /* unwind stack */
2538
2539 /* End the loop if we still have an error (or return) */
2540
2541 if (why != WHY_NOT)
2542 break;
2543 READ_TIMESTAMP(loop1);
2544
2545 } /* main loop */
2546
2547 assert(why != WHY_YIELD);
2548 /* Pop remaining stack entries. */
2549 while (!EMPTY()) {
2550 v = POP();
2551 Py_XDECREF(v);
2552 }
2553
2554 if (why != WHY_RETURN)
2555 retval = NULL;
2556
2557 fast_yield:
2558 if (tstate->use_tracing) {
2559 if (tstate->c_tracefunc) {
2560 if (why == WHY_RETURN || why == WHY_YIELD) {
2561 if (call_trace(tstate->c_tracefunc,
2562 tstate->c_traceobj, f,
2563 PyTrace_RETURN, retval)) {
2564 Py_XDECREF(retval);
2565 retval = NULL;
2566 why = WHY_EXCEPTION;
2567 }
2568 }
2569 else if (why == WHY_EXCEPTION) {
2570 call_trace_protected(tstate->c_tracefunc,
2571 tstate->c_traceobj, f,
2572 PyTrace_RETURN, NULL);
2573 }
2574 }
2575 if (tstate->c_profilefunc) {
2576 if (why == WHY_EXCEPTION)
2577 call_trace_protected(tstate->c_profilefunc,
2578 tstate->c_profileobj, f,
2579 PyTrace_RETURN, NULL);
2580 else if (call_trace(tstate->c_profilefunc,
2581 tstate->c_profileobj, f,
2582 PyTrace_RETURN, retval)) {
2583 Py_XDECREF(retval);
2584 retval = NULL;
2585 why = WHY_EXCEPTION;
2586 }
2587 }
2588 }
2589
2590 if (tstate->frame->f_exc_type != NULL)
2591 reset_exc_info(tstate);
2592 else {
2593 assert(tstate->frame->f_exc_value == NULL);
2594 assert(tstate->frame->f_exc_traceback == NULL);
2595 }
2596
2597 /* pop frame */
2598 exit_eval_frame:
2599 Py_LeaveRecursiveCall();
2600 tstate->frame = f->f_back;
2601
2602 return retval;
2603 }
2604
2605