?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Get rid of f_restricted too. Doc the other 4 ints that were already removed
[python.git] / Python / ceval.c
blob278604d86f6f708b66e67b73c8f212e814465404
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
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
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 *
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 *
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
217 PyEval_ThreadsInitialized(void)
218 {
219 return interpreter_lock != 0;
220 }
221
222 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
233 PyEval_AcquireLock(void)
234 {
235 PyThread_acquire_lock(interpreter_lock, 1);
236 }
237
238 void
239 PyEval_ReleaseLock(void)
240 {
241 PyThread_release_lock(interpreter_lock);
242 }
243
244 void
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
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
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 *
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
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
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
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
431 Py_GetRecursionLimit(void)
432 {
433 return recursion_limit;
434 }
435
436 void
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
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 *
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 *
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 *
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 /* This is gonna seem *real weird*, but if you put some other code between
2606 PyEval_EvalFrame() and PyEval_EvalCodeEx() you will need to adjust
2607 the test in the if statements in Misc/gdbinit (pystack and pystackv). */
2608
2609 PyObject *
2610 PyEval_EvalCodeEx(PyCodeObject *co, PyObject *globals, PyObject *locals,
2611 PyObject **args, int argcount, PyObject **kws, int kwcount,
2612 PyObject **defs, int defcount, PyObject *closure)
2613 {
2614 register PyFrameObject *f;
2615 register PyObject *retval = NULL;
2616 register PyObject **fastlocals, **freevars;
2617 PyThreadState *tstate = PyThreadState_GET();
2618 PyObject *x, *u;
2619
2620 if (globals == NULL) {
2621 PyErr_SetString(PyExc_SystemError,
2622 "PyEval_EvalCodeEx: NULL globals");
2623 return NULL;
2624 }
2625
2626 assert(globals != NULL);
2627 f = PyFrame_New(tstate, co, globals, locals);
2628 if (f == NULL)
2629 return NULL;
2630
2631 fastlocals = f->f_localsplus;
2632 freevars = f->f_localsplus + co->co_nlocals;
2633
2634 if (co->co_argcount > 0 ||
2635 co->co_flags & (CO_VARARGS | CO_VARKEYWORDS)) {
2636 int i;
2637 int n = argcount;
2638 PyObject *kwdict = NULL;
2639 if (co->co_flags & CO_VARKEYWORDS) {
2640 kwdict = PyDict_New();
2641 if (kwdict == NULL)
2642 goto fail;
2643 i = co->co_argcount;
2644 if (co->co_flags & CO_VARARGS)
2645 i++;
2646 SETLOCAL(i, kwdict);
2647 }
2648 if (argcount > co->co_argcount) {
2649 if (!(co->co_flags & CO_VARARGS)) {
2650 PyErr_Format(PyExc_TypeError,
2651 "%.200s() takes %s %d "
2652 "%sargument%s (%d given)",
2653 PyString_AsString(co->co_name),
2654 defcount ? "at most" : "exactly",
2655 co->co_argcount,
2656 kwcount ? "non-keyword " : "",
2657 co->co_argcount == 1 ? "" : "s",
2658 argcount);
2659 goto fail;
2660 }
2661 n = co->co_argcount;
2662 }
2663 for (i = 0; i < n; i++) {
2664 x = args[i];
2665 Py_INCREF(x);
2666 SETLOCAL(i, x);
2667 }
2668 if (co->co_flags & CO_VARARGS) {
2669 u = PyTuple_New(argcount - n);
2670 if (u == NULL)
2671 goto fail;
2672 SETLOCAL(co->co_argcount, u);
2673 for (i = n; i < argcount; i++) {
2674 x = args[i];
2675 Py_INCREF(x);
2676 PyTuple_SET_ITEM(u, i-n, x);
2677 }
2678 }
2679 for (i = 0; i < kwcount; i++) {
2680 PyObject *keyword = kws[2*i];
2681 PyObject *value = kws[2*i + 1];
2682 int j;
2683 if (keyword == NULL || !PyString_Check(keyword)) {
2684 PyErr_Format(PyExc_TypeError,
2685 "%.200s() keywords must be strings",
2686 PyString_AsString(co->co_name));
2687 goto fail;
2688 }
2689 /* XXX slow -- speed up using dictionary? */
2690 for (j = 0; j < co->co_argcount; j++) {
2691 PyObject *nm = PyTuple_GET_ITEM(
2692 co->co_varnames, j);
2693 int cmp = PyObject_RichCompareBool(
2694 keyword, nm, Py_EQ);
2695 if (cmp > 0)
2696 break;
2697 else if (cmp < 0)
2698 goto fail;
2699 }
2700 /* Check errors from Compare */
2701 if (PyErr_Occurred())
2702 goto fail;
2703 if (j >= co->co_argcount) {
2704 if (kwdict == NULL) {
2705 PyErr_Format(PyExc_TypeError,
2706 "%.200s() got an unexpected "
2707 "keyword argument '%.400s'",
2708 PyString_AsString(co->co_name),
2709 PyString_AsString(keyword));
2710 goto fail;
2711 }
2712 PyDict_SetItem(kwdict, keyword, value);
2713 }
2714 else {
2715 if (GETLOCAL(j) != NULL) {
2716 PyErr_Format(PyExc_TypeError,
2717 "%.200s() got multiple "
2718 "values for keyword "
2719 "argument '%.400s'",
2720 PyString_AsString(co->co_name),
2721 PyString_AsString(keyword));
2722 goto fail;
2723 }
2724 Py_INCREF(value);
2725 SETLOCAL(j, value);
2726 }
2727 }
2728 if (argcount < co->co_argcount) {
2729 int m = co->co_argcount - defcount;
2730 for (i = argcount; i < m; i++) {
2731 if (GETLOCAL(i) == NULL) {
2732 PyErr_Format(PyExc_TypeError,
2733 "%.200s() takes %s %d "
2734 "%sargument%s (%d given)",
2735 PyString_AsString(co->co_name),
2736 ((co->co_flags & CO_VARARGS) ||
2737 defcount) ? "at least"
2738 : "exactly",
2739 m, kwcount ? "non-keyword " : "",
2740 m == 1 ? "" : "s", i);
2741 goto fail;
2742 }
2743 }
2744 if (n > m)
2745 i = n - m;
2746 else
2747 i = 0;
2748 for (; i < defcount; i++) {
2749 if (GETLOCAL(m+i) == NULL) {
2750 PyObject *def = defs[i];
2751 Py_INCREF(def);
2752 SETLOCAL(m+i, def);
2753 }
2754 }
2755 }
2756 }
2757 else {
2758 if (argcount > 0 || kwcount > 0) {
2759 PyErr_Format(PyExc_TypeError,
2760 "%.200s() takes no arguments (%d given)",
2761 PyString_AsString(co->co_name),
2762 argcount + kwcount);
2763 goto fail;
2764 }
2765 }
2766 /* Allocate and initialize storage for cell vars, and copy free
2767 vars into frame. This isn't too efficient right now. */
2768 if (PyTuple_GET_SIZE(co->co_cellvars)) {
2769 int i = 0, j = 0, nargs, found;
2770 char *cellname, *argname;
2771 PyObject *c;
2772
2773 nargs = co->co_argcount;
2774 if (co->co_flags & CO_VARARGS)
2775 nargs++;
2776 if (co->co_flags & CO_VARKEYWORDS)
2777 nargs++;
2778
2779 /* Initialize each cell var, taking into account
2780 cell vars that are initialized from arguments.
2781
2782 Should arrange for the compiler to put cellvars
2783 that are arguments at the beginning of the cellvars
2784 list so that we can march over it more efficiently?
2785 */
2786 for (i = 0; i < PyTuple_GET_SIZE(co->co_cellvars); ++i) {
2787 cellname = PyString_AS_STRING(
2788 PyTuple_GET_ITEM(co->co_cellvars, i));
2789 found = 0;
2790 for (j = 0; j < nargs; j++) {
2791 argname = PyString_AS_STRING(
2792 PyTuple_GET_ITEM(co->co_varnames, j));
2793 if (strcmp(cellname, argname) == 0) {
2794 c = PyCell_New(GETLOCAL(j));
2795 if (c == NULL)
2796 goto fail;
2797 GETLOCAL(co->co_nlocals + i) = c;
2798 found = 1;
2799 break;
2800 }
2801 }
2802 if (found == 0) {
2803 c = PyCell_New(NULL);
2804 if (c == NULL)
2805 goto fail;
2806 SETLOCAL(co->co_nlocals + i, c);
2807 }
2808 }
2809 }
2810 if (PyTuple_GET_SIZE(co->co_freevars)) {
2811 int i;
2812 for (i = 0; i < PyTuple_GET_SIZE(co->co_freevars); ++i) {
2813 PyObject *o = PyTuple_GET_ITEM(closure, i);
2814 Py_INCREF(o);
2815 freevars[PyTuple_GET_SIZE(co->co_cellvars) + i] = o;
2816 }
2817 }
2818
2819 if (co->co_flags & CO_GENERATOR) {
2820 /* Don't need to keep the reference to f_back, it will be set
2821 * when the generator is resumed. */
2822 Py_XDECREF(f->f_back);
2823 f->f_back = NULL;
2824
2825 PCALL(PCALL_GENERATOR);
2826
2827 /* Create a new generator that owns the ready to run frame
2828 * and return that as the value. */
2829 return PyGen_New(f);
2830 }
2831
2832 retval = PyEval_EvalFrameEx(f,0);
2833
2834 fail: /* Jump here from prelude on failure */
2835
2836 /* decref'ing the frame can cause __del__ methods to get invoked,
2837 which can call back into Python. While we're done with the
2838 current Python frame (f), the associated C stack is still in use,
2839 so recursion_depth must be boosted for the duration.
2840 */
2841 assert(tstate != NULL);
2842 ++tstate->recursion_depth;
2843 Py_DECREF(f);
2844 --tstate->recursion_depth;
2845 return retval;
2846 }
2847
2848
2849 /* Implementation notes for set_exc_info() and reset_exc_info():
2850
2851 - Below, 'exc_ZZZ' stands for 'exc_type', 'exc_value' and
2852 'exc_traceback'. These always travel together.
2853
2854 - tstate->curexc_ZZZ is the "hot" exception that is set by
2855 PyErr_SetString(), cleared by PyErr_Clear(), and so on.
2856
2857 - Once an exception is caught by an except clause, it is transferred
2858 from tstate->curexc_ZZZ to tstate->exc_ZZZ, from which sys.exc_info()
2859 can pick it up. This is the primary task of set_exc_info().
2860 XXX That can't be right: set_exc_info() doesn't look at tstate->curexc_ZZZ.
2861
2862 - Now let me explain the complicated dance with frame->f_exc_ZZZ.
2863
2864 Long ago, when none of this existed, there were just a few globals:
2865 one set corresponding to the "hot" exception, and one set
2866 corresponding to sys.exc_ZZZ. (Actually, the latter weren't C
2867 globals; they were simply stored as sys.exc_ZZZ. For backwards
2868 compatibility, they still are!) The problem was that in code like
2869 this:
2870
2871 try:
2872 "something that may fail"
2873 except "some exception":
2874 "do something else first"
2875 "print the exception from sys.exc_ZZZ."
2876
2877 if "do something else first" invoked something that raised and caught
2878 an exception, sys.exc_ZZZ were overwritten. That was a frequent
2879 cause of subtle bugs. I fixed this by changing the semantics as
2880 follows:
2881
2882 - Within one frame, sys.exc_ZZZ will hold the last exception caught
2883 *in that frame*.
2884
2885 - But initially, and as long as no exception is caught in a given
2886 frame, sys.exc_ZZZ will hold the last exception caught in the
2887 previous frame (or the frame before that, etc.).
2888
2889 The first bullet fixed the bug in the above example. The second
2890 bullet was for backwards compatibility: it was (and is) common to
2891 have a function that is called when an exception is caught, and to
2892 have that function access the caught exception via sys.exc_ZZZ.
2893 (Example: traceback.print_exc()).
2894
2895 At the same time I fixed the problem that sys.exc_ZZZ weren't
2896 thread-safe, by introducing sys.exc_info() which gets it from tstate;
2897 but that's really a separate improvement.
2898
2899 The reset_exc_info() function in ceval.c restores the tstate->exc_ZZZ
2900 variables to what they were before the current frame was called. The
2901 set_exc_info() function saves them on the frame so that
2902 reset_exc_info() can restore them. The invariant is that
2903 frame->f_exc_ZZZ is NULL iff the current frame never caught an
2904 exception (where "catching" an exception applies only to successful
2905 except clauses); and if the current frame ever caught an exception,
2906 frame->f_exc_ZZZ is the exception that was stored in tstate->exc_ZZZ
2907 at the start of the current frame.
2908
2909 */
2910
2911 static void
2912 set_exc_info(PyThreadState *tstate,
2913 PyObject *type, PyObject *value, PyObject *tb)
2914 {
2915 PyFrameObject *frame = tstate->frame;
2916 PyObject *tmp_type, *tmp_value, *tmp_tb;
2917
2918 assert(type != NULL);
2919 assert(frame != NULL);
2920 if (frame->f_exc_type == NULL) {
2921 assert(frame->f_exc_value == NULL);
2922 assert(frame->f_exc_traceback == NULL);
2923 /* This frame didn't catch an exception before. */
2924 /* Save previous exception of this thread in this frame. */
2925 if (tstate->exc_type == NULL) {
2926 /* XXX Why is this set to Py_None? */
2927 Py_INCREF(Py_None);
2928 tstate->exc_type = Py_None;
2929 }
2930 Py_INCREF(tstate->exc_type);
2931 Py_XINCREF(tstate->exc_value);
2932 Py_XINCREF(tstate->exc_traceback);
2933 frame->f_exc_type = tstate->exc_type;
2934 frame->f_exc_value = tstate->exc_value;
2935 frame->f_exc_traceback = tstate->exc_traceback;
2936 }
2937 /* Set new exception for this thread. */
2938 tmp_type = tstate->exc_type;
2939 tmp_value = tstate->exc_value;
2940 tmp_tb = tstate->exc_traceback;
2941 Py_INCREF(type);
2942 Py_XINCREF(value);
2943 Py_XINCREF(tb);
2944 tstate->exc_type = type;
2945 tstate->exc_value = value;
2946 tstate->exc_traceback = tb;
2947 Py_XDECREF(tmp_type);
2948 Py_XDECREF(tmp_value);
2949 Py_XDECREF(tmp_tb);
2950 /* For b/w compatibility */
2951 PySys_SetObject("exc_type", type);
2952 PySys_SetObject("exc_value", value);
2953 PySys_SetObject("exc_traceback", tb);
2954 }
2955
2956 static void
2957 reset_exc_info(PyThreadState *tstate)
2958 {
2959 PyFrameObject *frame;
2960 PyObject *tmp_type, *tmp_value, *tmp_tb;
2961
2962 /* It's a precondition that the thread state's frame caught an
2963 * exception -- verify in a debug build.
2964 */
2965 assert(tstate != NULL);
2966 frame = tstate->frame;
2967 assert(frame != NULL);
2968 assert(frame->f_exc_type != NULL);
2969
2970 /* Copy the frame's exception info back to the thread state. */
2971 tmp_type = tstate->exc_type;
2972 tmp_value = tstate->exc_value;
2973 tmp_tb = tstate->exc_traceback;
2974 Py_INCREF(frame->f_exc_type);
2975 Py_XINCREF(frame->f_exc_value);
2976 Py_XINCREF(frame->f_exc_traceback);
2977 tstate->exc_type = frame->f_exc_type;
2978 tstate->exc_value = frame->f_exc_value;
2979 tstate->exc_traceback = frame->f_exc_traceback;
2980 Py_XDECREF(tmp_type);
2981 Py_XDECREF(tmp_value);
2982 Py_XDECREF(tmp_tb);
2983
2984 /* For b/w compatibility */
2985 PySys_SetObject("exc_type", frame->f_exc_type);
2986 PySys_SetObject("exc_value", frame->f_exc_value);
2987 PySys_SetObject("exc_traceback", frame->f_exc_traceback);
2988
2989 /* Clear the frame's exception info. */
2990 tmp_type = frame->f_exc_type;
2991 tmp_value = frame->f_exc_value;
2992 tmp_tb = frame->f_exc_traceback;
2993 frame->f_exc_type = NULL;
2994 frame->f_exc_value = NULL;
2995 frame->f_exc_traceback = NULL;
2996 Py_DECREF(tmp_type);
2997 Py_XDECREF(tmp_value);
2998 Py_XDECREF(tmp_tb);
2999 }
3000
3001 /* Logic for the raise statement (too complicated for inlining).
3002 This *consumes* a reference count to each of its arguments. */
3003 static enum why_code
3004 do_raise(PyObject *type, PyObject *value, PyObject *tb)
3005 {
3006 if (type == NULL) {
3007 /* Reraise */
3008 PyThreadState *tstate = PyThreadState_GET();
3009 type = tstate->exc_type == NULL ? Py_None : tstate->exc_type;
3010 value = tstate->exc_value;
3011 tb = tstate->exc_traceback;
3012 Py_XINCREF(type);
3013 Py_XINCREF(value);
3014 Py_XINCREF(tb);
3015 }
3016
3017 /* We support the following forms of raise:
3018 raise <class>, <classinstance>
3019 raise <class>, <argument tuple>
3020 raise <class>, None
3021 raise <class>, <argument>
3022 raise <classinstance>, None
3023 raise <string>, <object>
3024 raise <string>, None
3025
3026 An omitted second argument is the same as None.
3027
3028 In addition, raise <tuple>, <anything> is the same as
3029 raising the tuple's first item (and it better have one!);
3030 this rule is applied recursively.
3031
3032 Finally, an optional third argument can be supplied, which
3033 gives the traceback to be substituted (useful when
3034 re-raising an exception after examining it). */
3035
3036 /* First, check the traceback argument, replacing None with
3037 NULL. */
3038 if (tb == Py_None) {
3039 Py_DECREF(tb);
3040 tb = NULL;
3041 }
3042 else if (tb != NULL && !PyTraceBack_Check(tb)) {
3043 PyErr_SetString(PyExc_TypeError,
3044 "raise: arg 3 must be a traceback or None");
3045 goto raise_error;
3046 }
3047
3048 /* Next, replace a missing value with None */
3049 if (value == NULL) {
3050 value = Py_None;
3051 Py_INCREF(value);
3052 }
3053
3054 /* Next, repeatedly, replace a tuple exception with its first item */
3055 while (PyTuple_Check(type) && PyTuple_Size(type) > 0) {
3056 PyObject *tmp = type;
3057 type = PyTuple_GET_ITEM(type, 0);
3058 Py_INCREF(type);
3059 Py_DECREF(tmp);
3060 }
3061
3062 if (PyString_CheckExact(type)) {
3063 /* Raising builtin string is deprecated but still allowed --
3064 * do nothing. Raising an instance of a new-style str
3065 * subclass is right out. */
3066 if (PyErr_Warn(PyExc_DeprecationWarning,
3067 "raising a string exception is deprecated"))
3068 goto raise_error;
3069 }
3070 else if (PyExceptionClass_Check(type))
3071 PyErr_NormalizeException(&type, &value, &tb);
3072
3073 else if (PyExceptionInstance_Check(type)) {
3074 /* Raising an instance. The value should be a dummy. */
3075 if (value != Py_None) {
3076 PyErr_SetString(PyExc_TypeError,
3077 "instance exception may not have a separate value");
3078 goto raise_error;
3079 }
3080 else {
3081 /* Normalize to raise <class>, <instance> */
3082 Py_DECREF(value);
3083 value = type;
3084 type = PyExceptionInstance_Class(type);
3085 Py_INCREF(type);
3086 }
3087 }
3088 else {
3089 /* Not something you can raise. You get an exception
3090 anyway, just not what you specified :-) */
3091 PyErr_Format(PyExc_TypeError,
3092 "exceptions must be classes, instances, or "
3093 "strings (deprecated), not %s",
3094 type->ob_type->tp_name);
3095 goto raise_error;
3096 }
3097 PyErr_Restore(type, value, tb);
3098 if (tb == NULL)
3099 return WHY_EXCEPTION;
3100 else
3101 return WHY_RERAISE;
3102 raise_error:
3103 Py_XDECREF(value);
3104 Py_XDECREF(type);
3105 Py_XDECREF(tb);
3106 return WHY_EXCEPTION;
3107 }
3108
3109 /* Iterate v argcnt times and store the results on the stack (via decreasing
3110 sp). Return 1 for success, 0 if error. */
3111
3112 static int
3113 unpack_iterable(PyObject *v, int argcnt, PyObject **sp)
3114 {
3115 int i = 0;
3116 PyObject *it; /* iter(v) */
3117 PyObject *w;
3118
3119 assert(v != NULL);
3120
3121 it = PyObject_GetIter(v);
3122 if (it == NULL)
3123 goto Error;
3124
3125 for (; i < argcnt; i++) {
3126 w = PyIter_Next(it);
3127 if (w == NULL) {
3128 /* Iterator done, via error or exhaustion. */
3129 if (!PyErr_Occurred()) {
3130 PyErr_Format(PyExc_ValueError,
3131 "need more than %d value%s to unpack",
3132 i, i == 1 ? "" : "s");
3133 }
3134 goto Error;
3135 }
3136 *--sp = w;
3137 }
3138
3139 /* We better have exhausted the iterator now. */
3140 w = PyIter_Next(it);
3141 if (w == NULL) {
3142 if (PyErr_Occurred())
3143 goto Error;
3144 Py_DECREF(it);
3145 return 1;
3146 }
3147 Py_DECREF(w);
3148 PyErr_SetString(PyExc_ValueError, "too many values to unpack");
3149 /* fall through */
3150 Error:
3151 for (; i > 0; i--, sp++)
3152 Py_DECREF(*sp);
3153 Py_XDECREF(it);
3154 return 0;
3155 }
3156
3157
3158 #ifdef LLTRACE
3159 static int
3160 prtrace(PyObject *v, char *str)
3161 {
3162 printf("%s ", str);
3163 if (PyObject_Print(v, stdout, 0) != 0)
3164 PyErr_Clear(); /* Don't know what else to do */
3165 printf("\n");
3166 return 1;
3167 }
3168 #endif
3169
3170 static void
3171 call_exc_trace(Py_tracefunc func, PyObject *self, PyFrameObject *f)
3172 {
3173 PyObject *type, *value, *traceback, *arg;
3174 int err;
3175 PyErr_Fetch(&type, &value, &traceback);
3176 if (value == NULL) {
3177 value = Py_None;
3178 Py_INCREF(value);
3179 }
3180 arg = PyTuple_Pack(3, type, value, traceback);
3181 if (arg == NULL) {
3182 PyErr_Restore(type, value, traceback);
3183 return;
3184 }
3185 err = call_trace(func, self, f, PyTrace_EXCEPTION, arg);
3186 Py_DECREF(arg);
3187 if (err == 0)
3188 PyErr_Restore(type, value, traceback);
3189 else {
3190 Py_XDECREF(type);
3191 Py_XDECREF(value);
3192 Py_XDECREF(traceback);
3193 }
3194 }
3195
3196 static void
3197 call_trace_protected(Py_tracefunc func, PyObject *obj, PyFrameObject *frame,
3198 int what, PyObject *arg)
3199 {
3200 PyObject *type, *value, *traceback;
3201 int err;
3202 PyErr_Fetch(&type, &value, &traceback);
3203 err = call_trace(func, obj, frame, what, arg);
3204 if (err == 0)
3205 PyErr_Restore(type, value, traceback);
3206 else {
3207 Py_XDECREF(type);
3208 Py_XDECREF(value);
3209 Py_XDECREF(traceback);
3210 }
3211 }
3212
3213 static int
3214 call_trace(Py_tracefunc func, PyObject *obj, PyFrameObject *frame,
3215 int what, PyObject *arg)
3216 {
3217 register PyThreadState *tstate = frame->f_tstate;
3218 int result;
3219 if (tstate->tracing)
3220 return 0;
3221 tstate->tracing++;
3222 tstate->use_tracing = 0;
3223 result = func(obj, frame, what, arg);
3224 tstate->use_tracing = ((tstate->c_tracefunc != NULL)
3225 || (tstate->c_profilefunc != NULL));
3226 tstate->tracing--;
3227 return result;
3228 }
3229
3230 PyObject *
3231 _PyEval_CallTracing(PyObject *func, PyObject *args)
3232 {
3233 PyFrameObject *frame = PyEval_GetFrame();
3234 PyThreadState *tstate = frame->f_tstate;
3235 int save_tracing = tstate->tracing;
3236 int save_use_tracing = tstate->use_tracing;
3237 PyObject *result;
3238
3239 tstate->tracing = 0;
3240 tstate->use_tracing = ((tstate->c_tracefunc != NULL)
3241 || (tstate->c_profilefunc != NULL));
3242 result = PyObject_Call(func, args, NULL);
3243 tstate->tracing = save_tracing;
3244 tstate->use_tracing = save_use_tracing;
3245 return result;
3246 }
3247
3248 static int
3249 maybe_call_line_trace(Py_tracefunc func, PyObject *obj,
3250 PyFrameObject *frame, int *instr_lb, int *instr_ub,
3251 int *instr_prev)
3252 {
3253 int result = 0;
3254
3255 /* If the last instruction executed isn't in the current
3256 instruction window, reset the window. If the last
3257 instruction happens to fall at the start of a line or if it
3258 represents a jump backwards, call the trace function.
3259 */
3260 if ((frame->f_lasti < *instr_lb || frame->f_lasti >= *instr_ub)) {
3261 int line;
3262 PyAddrPair bounds;
3263
3264 line = PyCode_CheckLineNumber(frame->f_code, frame->f_lasti,
3265 &bounds);
3266 if (line >= 0) {
3267 frame->f_lineno = line;
3268 result = call_trace(func, obj, frame,
3269 PyTrace_LINE, Py_None);
3270 }
3271 *instr_lb = bounds.ap_lower;
3272 *instr_ub = bounds.ap_upper;
3273 }
3274 else if (frame->f_lasti <= *instr_prev) {
3275 result = call_trace(func, obj, frame, PyTrace_LINE, Py_None);
3276 }
3277 *instr_prev = frame->f_lasti;
3278 return result;
3279 }
3280
3281 void
3282 PyEval_SetProfile(Py_tracefunc func, PyObject *arg)
3283 {
3284 PyThreadState *tstate = PyThreadState_GET();
3285 PyObject *temp = tstate->c_profileobj;
3286 Py_XINCREF(arg);
3287 tstate->c_profilefunc = NULL;
3288 tstate->c_profileobj = NULL;
3289 /* Must make sure that tracing is not ignored if 'temp' is freed */
3290 tstate->use_tracing = tstate->c_tracefunc != NULL;
3291 Py_XDECREF(temp);
3292 tstate->c_profilefunc = func;
3293 tstate->c_profileobj = arg;
3294 /* Flag that tracing or profiling is turned on */
3295 tstate->use_tracing = (func != NULL) || (tstate->c_tracefunc != NULL);
3296 }
3297
3298 void
3299 PyEval_SetTrace(Py_tracefunc func, PyObject *arg)
3300 {
3301 PyThreadState *tstate = PyThreadState_GET();
3302 PyObject *temp = tstate->c_traceobj;
3303 Py_XINCREF(arg);
3304 tstate->c_tracefunc = NULL;
3305 tstate->c_traceobj = NULL;
3306 /* Must make sure that profiling is not ignored if 'temp' is freed */
3307 tstate->use_tracing = tstate->c_profilefunc != NULL;
3308 Py_XDECREF(temp);
3309 tstate->c_tracefunc = func;
3310 tstate->c_traceobj = arg;
3311 /* Flag that tracing or profiling is turned on */
3312 tstate->use_tracing = ((func != NULL)
3313 || (tstate->c_profilefunc != NULL));
3314 }
3315
3316 PyObject *
3317 PyEval_GetBuiltins(void)
3318 {
3319 PyFrameObject *current_frame = PyEval_GetFrame();
3320 if (current_frame == NULL)
3321 return PyThreadState_GET()->interp->builtins;
3322 else
3323 return current_frame->f_builtins;
3324 }
3325
3326 PyObject *
3327 PyEval_GetLocals(void)
3328 {
3329 PyFrameObject *current_frame = PyEval_GetFrame();
3330 if (current_frame == NULL)
3331 return NULL;
3332 PyFrame_FastToLocals(current_frame);
3333 return current_frame->f_locals;
3334 }
3335
3336 PyObject *
3337 PyEval_GetGlobals(void)
3338 {
3339 PyFrameObject *current_frame = PyEval_GetFrame();
3340 if (current_frame == NULL)
3341 return NULL;
3342 else
3343 return current_frame->f_globals;
3344 }
3345
3346 PyFrameObject *
3347 PyEval_GetFrame(void)
3348 {
3349 PyThreadState *tstate = PyThreadState_GET();
3350 return _PyThreadState_GetFrame(tstate);
3351 }
3352
3353 int
3354 PyEval_GetRestricted(void)
3355 {
3356 PyFrameObject *current_frame = PyEval_GetFrame();
3357 return current_frame == NULL ? 0 : PyFrame_IsRestricted(current_frame);
3358 }
3359
3360 int
3361 PyEval_MergeCompilerFlags(PyCompilerFlags *cf)
3362 {
3363 PyFrameObject *current_frame = PyEval_GetFrame();
3364 int result = cf->cf_flags != 0;
3365
3366 if (current_frame != NULL) {
3367 const int codeflags = current_frame->f_code->co_flags;
3368 const int compilerflags = codeflags & PyCF_MASK;
3369 if (compilerflags) {
3370 result = 1;
3371 cf->cf_flags |= compilerflags;
3372 }
3373 #if 0 /* future keyword */
3374 if (codeflags & CO_GENERATOR_ALLOWED) {
3375 result = 1;
3376 cf->cf_flags |= CO_GENERATOR_ALLOWED;
3377 }
3378 #endif
3379 }
3380 return result;
3381 }
3382
3383 int
3384 Py_FlushLine(void)
3385 {
3386 PyObject *f = PySys_GetObject("stdout");
3387 if (f == NULL)
3388 return 0;
3389 if (!PyFile_SoftSpace(f, 0))
3390 return 0;
3391 return PyFile_WriteString("\n", f);
3392 }
3393
3394
3395 /* External interface to call any callable object.
3396 The arg must be a tuple or NULL. */
3397
3398 #undef PyEval_CallObject
3399 /* for backward compatibility: export this interface */
3400
3401 PyObject *
3402 PyEval_CallObject(PyObject *func, PyObject *arg)
3403 {
3404 return PyEval_CallObjectWithKeywords(func, arg, (PyObject *)NULL);
3405 }
3406 #define PyEval_CallObject(func,arg) \
3407 PyEval_CallObjectWithKeywords(func, arg, (PyObject *)NULL)
3408
3409 PyObject *
3410 PyEval_CallObjectWithKeywords(PyObject *func, PyObject *arg, PyObject *kw)
3411 {
3412 PyObject *result;
3413
3414 if (arg == NULL) {
3415 arg = PyTuple_New(0);
3416 if (arg == NULL)
3417 return NULL;
3418 }
3419 else if (!PyTuple_Check(arg)) {
3420 PyErr_SetString(PyExc_TypeError,
3421 "argument list must be a tuple");
3422 return NULL;
3423 }
3424 else
3425 Py_INCREF(arg);
3426
3427 if (kw != NULL && !PyDict_Check(kw)) {
3428 PyErr_SetString(PyExc_TypeError,
3429 "keyword list must be a dictionary");
3430 Py_DECREF(arg);
3431 return NULL;
3432 }
3433
3434 result = PyObject_Call(func, arg, kw);
3435 Py_DECREF(arg);
3436 return result;
3437 }
3438
3439 const char *
3440 PyEval_GetFuncName(PyObject *func)
3441 {
3442 if (PyMethod_Check(func))
3443 return PyEval_GetFuncName(PyMethod_GET_FUNCTION(func));
3444 else if (PyFunction_Check(func))
3445 return PyString_AsString(((PyFunctionObject*)func)->func_name);
3446 else if (PyCFunction_Check(func))
3447 return ((PyCFunctionObject*)func)->m_ml->ml_name;
3448 else if (PyClass_Check(func))
3449 return PyString_AsString(((PyClassObject*)func)->cl_name);
3450 else if (PyInstance_Check(func)) {
3451 return PyString_AsString(
3452 ((PyInstanceObject*)func)->in_class->cl_name);
3453 } else {
3454 return func->ob_type->tp_name;
3455 }
3456 }
3457
3458 const char *
3459 PyEval_GetFuncDesc(PyObject *func)
3460 {
3461 if (PyMethod_Check(func))
3462 return "()";
3463 else if (PyFunction_Check(func))
3464 return "()";
3465 else if (PyCFunction_Check(func))
3466 return "()";
3467 else if (PyClass_Check(func))
3468 return " constructor";
3469 else if (PyInstance_Check(func)) {
3470 return " instance";
3471 } else {
3472 return " object";
3473 }
3474 }
3475
3476 static void
3477 err_args(PyObject *func, int flags, int nargs)
3478 {
3479 if (flags & METH_NOARGS)
3480 PyErr_Format(PyExc_TypeError,
3481 "%.200s() takes no arguments (%d given)",
3482 ((PyCFunctionObject *)func)->m_ml->ml_name,
3483 nargs);
3484 else
3485 PyErr_Format(PyExc_TypeError,
3486 "%.200s() takes exactly one argument (%d given)",
3487 ((PyCFunctionObject *)func)->m_ml->ml_name,
3488 nargs);
3489 }
3490
3491 #define C_TRACE(x, call) \
3492 if (tstate->use_tracing && tstate->c_profilefunc) { \
3493 if (call_trace(tstate->c_profilefunc, \
3494 tstate->c_profileobj, \
3495 tstate->frame, PyTrace_C_CALL, \
3496 func)) { \
3497 x = NULL; \
3498 } \
3499 else { \
3500 x = call; \
3501 if (tstate->c_profilefunc != NULL) { \
3502 if (x == NULL) { \
3503 call_trace_protected(tstate->c_profilefunc, \
3504 tstate->c_profileobj, \
3505 tstate->frame, PyTrace_C_EXCEPTION, \
3506 func); \
3507 /* XXX should pass (type, value, tb) */ \
3508 } else { \
3509 if (call_trace(tstate->c_profilefunc, \
3510 tstate->c_profileobj, \
3511 tstate->frame, PyTrace_C_RETURN, \
3512 func)) { \
3513 Py_DECREF(x); \
3514 x = NULL; \
3515 } \
3516 } \
3517 } \
3518 } \
3519 } else { \
3520 x = call; \
3521 }
3522
3523 static PyObject *
3524 call_function(PyObject ***pp_stack, int oparg
3525 #ifdef WITH_TSC
3526 , uint64* pintr0, uint64* pintr1
3527 #endif
3528 )
3529 {
3530 int na = oparg & 0xff;
3531 int nk = (oparg>>8) & 0xff;
3532 int n = na + 2 * nk;
3533 PyObject **pfunc = (*pp_stack) - n - 1;
3534 PyObject *func = *pfunc;
3535 PyObject *x, *w;
3536
3537 /* Always dispatch PyCFunction first, because these are
3538 presumed to be the most frequent callable object.
3539 */
3540 if (PyCFunction_Check(func) && nk == 0) {
3541 int flags = PyCFunction_GET_FLAGS(func);
3542 PyThreadState *tstate = PyThreadState_GET();
3543
3544 PCALL(PCALL_CFUNCTION);
3545 if (flags & (METH_NOARGS | METH_O)) {
3546 PyCFunction meth = PyCFunction_GET_FUNCTION(func);
3547 PyObject *self = PyCFunction_GET_SELF(func);
3548 if (flags & METH_NOARGS && na == 0) {
3549 C_TRACE(x, (*meth)(self,NULL));
3550 }
3551 else if (flags & METH_O && na == 1) {
3552 PyObject *arg = EXT_POP(*pp_stack);
3553 C_TRACE(x, (*meth)(self,arg));
3554 Py_DECREF(arg);
3555 }
3556 else {
3557 err_args(func, flags, na);
3558 x = NULL;
3559 }
3560 }
3561 else {
3562 PyObject *callargs;
3563 callargs = load_args(pp_stack, na);
3564 READ_TIMESTAMP(*pintr0);
3565 C_TRACE(x, PyCFunction_Call(func,callargs,NULL));
3566 READ_TIMESTAMP(*pintr1);
3567 Py_XDECREF(callargs);
3568 }
3569 } else {
3570 if (PyMethod_Check(func) && PyMethod_GET_SELF(func) != NULL) {
3571 /* optimize access to bound methods */
3572 PyObject *self = PyMethod_GET_SELF(func);
3573 PCALL(PCALL_METHOD);
3574 PCALL(PCALL_BOUND_METHOD);
3575 Py_INCREF(self);
3576 func = PyMethod_GET_FUNCTION(func);
3577 Py_INCREF(func);
3578 Py_DECREF(*pfunc);
3579 *pfunc = self;
3580 na++;
3581 n++;
3582 } else
3583 Py_INCREF(func);
3584 READ_TIMESTAMP(*pintr0);
3585 if (PyFunction_Check(func))
3586 x = fast_function(func, pp_stack, n, na, nk);
3587 else
3588 x = do_call(func, pp_stack, na, nk);
3589 READ_TIMESTAMP(*pintr1);
3590 Py_DECREF(func);
3591 }
3592
3593 /* Clear the stack of the function object. Also removes
3594 the arguments in case they weren't consumed already
3595 (fast_function() and err_args() leave them on the stack).
3596 */
3597 while ((*pp_stack) > pfunc) {
3598 w = EXT_POP(*pp_stack);
3599 Py_DECREF(w);
3600 PCALL(PCALL_POP);
3601 }
3602 return x;
3603 }
3604
3605 /* The fast_function() function optimize calls for which no argument
3606 tuple is necessary; the objects are passed directly from the stack.
3607 For the simplest case -- a function that takes only positional
3608 arguments and is called with only positional arguments -- it
3609 inlines the most primitive frame setup code from
3610 PyEval_EvalCodeEx(), which vastly reduces the checks that must be
3611 done before evaluating the frame.
3612 */
3613
3614 static PyObject *
3615 fast_function(PyObject *func, PyObject ***pp_stack, int n, int na, int nk)
3616 {
3617 PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
3618 PyObject *globals = PyFunction_GET_GLOBALS(func);
3619 PyObject *argdefs = PyFunction_GET_DEFAULTS(func);
3620 PyObject **d = NULL;
3621 int nd = 0;
3622
3623 PCALL(PCALL_FUNCTION);
3624 PCALL(PCALL_FAST_FUNCTION);
3625 if (argdefs == NULL && co->co_argcount == n && nk==0 &&
3626 co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) {
3627 PyFrameObject *f;
3628 PyObject *retval = NULL;
3629 PyThreadState *tstate = PyThreadState_GET();
3630 PyObject **fastlocals, **stack;
3631 int i;
3632
3633 PCALL(PCALL_FASTER_FUNCTION);
3634 assert(globals != NULL);
3635 /* XXX Perhaps we should create a specialized
3636 PyFrame_New() that doesn't take locals, but does
3637 take builtins without sanity checking them.
3638 */
3639 f = PyFrame_New(tstate, co, globals, NULL);
3640 if (f == NULL)
3641 return NULL;
3642
3643 fastlocals = f->f_localsplus;
3644 stack = (*pp_stack) - n;
3645
3646 for (i = 0; i < n; i++) {
3647 Py_INCREF(*stack);
3648 fastlocals[i] = *stack++;
3649 }
3650 retval = PyEval_EvalFrameEx(f,0);
3651 assert(tstate != NULL);
3652 ++tstate->recursion_depth;
3653 Py_DECREF(f);
3654 --tstate->recursion_depth;
3655 return retval;
3656 }
3657 if (argdefs != NULL) {
3658 d = &PyTuple_GET_ITEM(argdefs, 0);
3659 nd = ((PyTupleObject *)argdefs)->ob_size;
3660 }
3661 return PyEval_EvalCodeEx(co, globals,
3662 (PyObject *)NULL, (*pp_stack)-n, na,
3663 (*pp_stack)-2*nk, nk, d, nd,
3664 PyFunction_GET_CLOSURE(func));
3665 }
3666
3667 static PyObject *
3668 update_keyword_args(PyObject *orig_kwdict, int nk, PyObject ***pp_stack,
3669 PyObject *func)
3670 {
3671 PyObject *kwdict = NULL;
3672 if (orig_kwdict == NULL)
3673 kwdict = PyDict_New();
3674 else {
3675 kwdict = PyDict_Copy(orig_kwdict);
3676 Py_DECREF(orig_kwdict);
3677 }
3678 if (kwdict == NULL)
3679 return NULL;
3680 while (--nk >= 0) {
3681 int err;
3682 PyObject *value = EXT_POP(*pp_stack);
3683 PyObject *key = EXT_POP(*pp_stack);
3684 if (PyDict_GetItem(kwdict, key) != NULL) {
3685 PyErr_Format(PyExc_TypeError,
3686 "%.200s%s got multiple values "
3687 "for keyword argument '%.200s'",
3688 PyEval_GetFuncName(func),
3689 PyEval_GetFuncDesc(func),
3690 PyString_AsString(key));
3691 Py_DECREF(key);
3692 Py_DECREF(value);
3693 Py_DECREF(kwdict);
3694 return NULL;
3695 }
3696 err = PyDict_SetItem(kwdict, key, value);
3697 Py_DECREF(key);
3698 Py_DECREF(value);
3699 if (err) {
3700 Py_DECREF(kwdict);
3701 return NULL;
3702 }
3703 }
3704 return kwdict;
3705 }
3706
3707 static PyObject *
3708 update_star_args(int nstack, int nstar, PyObject *stararg,
3709 PyObject ***pp_stack)
3710 {
3711 PyObject *callargs, *w;
3712
3713 callargs = PyTuple_New(nstack + nstar);
3714 if (callargs == NULL) {
3715 return NULL;
3716 }
3717 if (nstar) {
3718 int i;
3719 for (i = 0; i < nstar; i++) {
3720 PyObject *a = PyTuple_GET_ITEM(stararg, i);
3721 Py_INCREF(a);
3722 PyTuple_SET_ITEM(callargs, nstack + i, a);
3723 }
3724 }
3725 while (--nstack >= 0) {
3726 w = EXT_POP(*pp_stack);
3727 PyTuple_SET_ITEM(callargs, nstack, w);
3728 }
3729 return callargs;
3730 }
3731
3732 static PyObject *
3733 load_args(PyObject ***pp_stack, int na)
3734 {
3735 PyObject *args = PyTuple_New(na);
3736 PyObject *w;
3737
3738 if (args == NULL)
3739 return NULL;
3740 while (--na >= 0) {
3741 w = EXT_POP(*pp_stack);
3742 PyTuple_SET_ITEM(args, na, w);
3743 }
3744 return args;
3745 }
3746
3747 static PyObject *
3748 do_call(PyObject *func, PyObject ***pp_stack, int na, int nk)
3749 {
3750 PyObject *callargs = NULL;
3751 PyObject *kwdict = NULL;
3752 PyObject *result = NULL;
3753
3754 if (nk > 0) {
3755 kwdict = update_keyword_args(NULL, nk, pp_stack, func);
3756 if (kwdict == NULL)
3757 goto call_fail;
3758 }
3759 callargs = load_args(pp_stack, na);
3760 if (callargs == NULL)
3761 goto call_fail;
3762 #ifdef CALL_PROFILE
3763 /* At this point, we have to look at the type of func to
3764 update the call stats properly. Do it here so as to avoid
3765 exposing the call stats machinery outside ceval.c
3766 */
3767 if (PyFunction_Check(func))
3768 PCALL(PCALL_FUNCTION);
3769 else if (PyMethod_Check(func))
3770 PCALL(PCALL_METHOD);
3771 else if (PyType_Check(func))
3772 PCALL(PCALL_TYPE);
3773 else
3774 PCALL(PCALL_OTHER);
3775 #endif
3776 result = PyObject_Call(func, callargs, kwdict);
3777 call_fail:
3778 Py_XDECREF(callargs);
3779 Py_XDECREF(kwdict);
3780 return result;
3781 }
3782
3783 static PyObject *
3784 ext_do_call(PyObject *func, PyObject ***pp_stack, int flags, int na, int nk)
3785 {
3786 int nstar = 0;
3787 PyObject *callargs = NULL;
3788 PyObject *stararg = NULL;
3789 PyObject *kwdict = NULL;
3790 PyObject *result = NULL;
3791
3792 if (flags & CALL_FLAG_KW) {
3793 kwdict = EXT_POP(*pp_stack);
3794 if (!(kwdict && PyDict_Check(kwdict))) {
3795 PyErr_Format(PyExc_TypeError,
3796 "%s%s argument after ** "
3797 "must be a dictionary",
3798 PyEval_GetFuncName(func),
3799 PyEval_GetFuncDesc(func));
3800 goto ext_call_fail;
3801 }
3802 }
3803 if (flags & CALL_FLAG_VAR) {
3804 stararg = EXT_POP(*pp_stack);
3805 if (!PyTuple_Check(stararg)) {
3806 PyObject *t = NULL;
3807 t = PySequence_Tuple(stararg);
3808 if (t == NULL) {
3809 if (PyErr_ExceptionMatches(PyExc_TypeError)) {
3810 PyErr_Format(PyExc_TypeError,
3811 "%s%s argument after * "
3812 "must be a sequence",
3813 PyEval_GetFuncName(func),
3814 PyEval_GetFuncDesc(func));
3815 }
3816 goto ext_call_fail;
3817 }
3818 Py_DECREF(stararg);
3819 stararg = t;
3820 }
3821 nstar = PyTuple_GET_SIZE(stararg);
3822 }
3823 if (nk > 0) {
3824 kwdict = update_keyword_args(kwdict, nk, pp_stack, func);
3825 if (kwdict == NULL)
3826 goto ext_call_fail;
3827 }
3828 callargs = update_star_args(na, nstar, stararg, pp_stack);
3829 if (callargs == NULL)
3830 goto ext_call_fail;
3831 #ifdef CALL_PROFILE
3832 /* At this point, we have to look at the type of func to
3833 update the call stats properly. Do it here so as to avoid
3834 exposing the call stats machinery outside ceval.c
3835 */
3836 if (PyFunction_Check(func))
3837 PCALL(PCALL_FUNCTION);
3838 else if (PyMethod_Check(func))
3839 PCALL(PCALL_METHOD);
3840 else if (PyType_Check(func))
3841 PCALL(PCALL_TYPE);
3842 else
3843 PCALL(PCALL_OTHER);
3844 #endif
3845 result = PyObject_Call(func, callargs, kwdict);
3846 ext_call_fail:
3847 Py_XDECREF(callargs);
3848 Py_XDECREF(kwdict);
3849 Py_XDECREF(stararg);
3850 return result;
3851 }
3852
3853 /* Extract a slice index from a PyInt or PyLong or an object with the
3854 nb_index slot defined, and store in *pi.
3855 Silently reduce values larger than PY_SSIZE_T_MAX to PY_SSIZE_T_MAX,
3856 and silently boost values less than -PY_SSIZE_T_MAX-1 to -PY_SSIZE_T_MAX-1.
3857 Return 0 on error, 1 on success.
3858 */
3859 /* Note: If v is NULL, return success without storing into *pi. This
3860 is because_PyEval_SliceIndex() is called by apply_slice(), which can be
3861 called by the SLICE opcode with v and/or w equal to NULL.
3862 */
3863 int
3864 _PyEval_SliceIndex(PyObject *v, Py_ssize_t *pi)
3865 {
3866 if (v != NULL) {
3867 Py_ssize_t x;
3868 if (PyInt_Check(v)) {
3869 x = PyInt_AsSsize_t(v);
3870 }
3871 else if (v->ob_type->tp_as_number &&
3872 PyType_HasFeature(v->ob_type, Py_TPFLAGS_HAVE_INDEX)
3873 && v->ob_type->tp_as_number->nb_index) {
3874 x = v->ob_type->tp_as_number->nb_index(v);
3875 if (x == -1 && PyErr_Occurred())
3876 return 0;
3877 }
3878 else {
3879 PyErr_SetString(PyExc_TypeError,
3880 "slice indices must be integers or "
3881 "None or have an __index__ method");
3882 return 0;
3883 }
3884 *pi = x;
3885 }
3886 return 1;
3887 }
3888
3889 #undef ISINDEX
3890 #define ISINDEX(x) ((x) == NULL || PyInt_Check(x) || PyLong_Check(x) || \
3891 ((x)->ob_type->tp_as_number && \
3892 PyType_HasFeature((x)->ob_type, Py_TPFLAGS_HAVE_INDEX) \
3893 && (x)->ob_type->tp_as_number->nb_index))
3894
3895 static PyObject *
3896 apply_slice(PyObject *u, PyObject *v, PyObject *w) /* return u[v:w] */
3897 {
3898 PyTypeObject *tp = u->ob_type;
3899 PySequenceMethods *sq = tp->tp_as_sequence;
3900
3901 if (sq && sq->sq_slice && ISINDEX(v) && ISINDEX(w)) {
3902 Py_ssize_t ilow = 0, ihigh = PY_SSIZE_T_MAX;
3903 if (!_PyEval_SliceIndex(v, &ilow))
3904 return NULL;
3905 if (!_PyEval_SliceIndex(w, &ihigh))
3906 return NULL;
3907 return PySequence_GetSlice(u, ilow, ihigh);
3908 }
3909 else {
3910 PyObject *slice = PySlice_New(v, w, NULL);
3911 if (slice != NULL) {
3912 PyObject *res = PyObject_GetItem(u, slice);
3913 Py_DECREF(slice);
3914 return res;
3915 }
3916 else
3917 return NULL;
3918 }
3919 }
3920
3921 static int
3922 assign_slice(PyObject *u, PyObject *v, PyObject *w, PyObject *x)
3923 /* u[v:w] = x */
3924 {
3925 PyTypeObject *tp = u->ob_type;
3926 PySequenceMethods *sq = tp->tp_as_sequence;
3927
3928 if (sq && sq->sq_slice && ISINDEX(v) && ISINDEX(w)) {
3929 Py_ssize_t ilow = 0, ihigh = PY_SSIZE_T_MAX;
3930 if (!_PyEval_SliceIndex(v, &ilow))
3931 return -1;
3932 if (!_PyEval_SliceIndex(w, &ihigh))
3933 return -1;
3934 if (x == NULL)
3935 return PySequence_DelSlice(u, ilow, ihigh);
3936 else
3937 return PySequence_SetSlice(u, ilow, ihigh, x);
3938 }
3939 else {
3940 PyObject *slice = PySlice_New(v, w, NULL);
3941 if (slice != NULL) {
3942 int res;
3943 if (x != NULL)
3944 res = PyObject_SetItem(u, slice, x);
3945 else
3946 res = PyObject_DelItem(u, slice);
3947 Py_DECREF(slice);
3948 return res;
3949 }
3950 else
3951 return -1;
3952 }
3953 }
3954
3955 static PyObject *
3956 cmp_outcome(int op, register PyObject *v, register PyObject *w)
3957 {
3958 int res = 0;
3959 switch (op) {
3960 case PyCmp_IS:
3961 res = (v == w);
3962 break;
3963 case PyCmp_IS_NOT:
3964 res = (v != w);
3965 break;
3966 case PyCmp_IN:
3967 res = PySequence_Contains(w, v);
3968 if (res < 0)
3969 return NULL;
3970 break;
3971 case PyCmp_NOT_IN:
3972 res = PySequence_Contains(w, v);
3973 if (res < 0)
3974 return NULL;
3975 res = !res;
3976 break;
3977 case PyCmp_EXC_MATCH:
3978 res = PyErr_GivenExceptionMatches(v, w);
3979 break;
3980 default:
3981 return PyObject_RichCompare(v, w, op);
3982 }
3983 v = res ? Py_True : Py_False;
3984 Py_INCREF(v);
3985 return v;
3986 }
3987
3988 static PyObject *
3989 import_from(PyObject *v, PyObject *name)
3990 {
3991 PyObject *x;
3992
3993 x = PyObject_GetAttr(v, name);
3994 if (x == NULL && PyErr_ExceptionMatches(PyExc_AttributeError)) {
3995 PyErr_Format(PyExc_ImportError,
3996 "cannot import name %.230s",
3997 PyString_AsString(name));
3998 }
3999 return x;
4000 }
4001
4002 static int
4003 import_all_from(PyObject *locals, PyObject *v)
4004 {
4005 PyObject *all = PyObject_GetAttrString(v, "__all__");
4006 PyObject *dict, *name, *value;
4007 int skip_leading_underscores = 0;
4008 int pos, err;
4009
4010 if (all == NULL) {
4011 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
4012 return -1; /* Unexpected error */
4013 PyErr_Clear();
4014 dict = PyObject_GetAttrString(v, "__dict__");
4015 if (dict == NULL) {
4016 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
4017 return -1;
4018 PyErr_SetString(PyExc_ImportError,
4019 "from-import-* object has no __dict__ and no __all__");
4020 return -1;
4021 }
4022 all = PyMapping_Keys(dict);
4023 Py_DECREF(dict);
4024 if (all == NULL)
4025 return -1;
4026 skip_leading_underscores = 1;
4027 }
4028
4029 for (pos = 0, err = 0; ; pos++) {
4030 name = PySequence_GetItem(all, pos);
4031 if (name == NULL) {
4032 if (!PyErr_ExceptionMatches(PyExc_IndexError))
4033 err = -1;
4034 else
4035 PyErr_Clear();
4036 break;
4037 }
4038 if (skip_leading_underscores &&
4039 PyString_Check(name) &&
4040 PyString_AS_STRING(name)[0] == '_')
4041 {
4042 Py_DECREF(name);
4043 continue;
4044 }
4045 value = PyObject_GetAttr(v, name);
4046 if (value == NULL)
4047 err = -1;
4048 else
4049 err = PyDict_SetItem(locals, name, value);
4050 Py_DECREF(name);
4051 Py_XDECREF(value);
4052 if (err != 0)
4053 break;
4054 }
4055 Py_DECREF(all);
4056 return err;
4057 }
4058
4059 static PyObject *
4060 build_class(PyObject *methods, PyObject *bases, PyObject *name)
4061 {
4062 PyObject *metaclass = NULL, *result, *base;
4063
4064 if (PyDict_Check(methods))
4065 metaclass = PyDict_GetItemString(methods, "__metaclass__");
4066 if (metaclass != NULL)
4067 Py_INCREF(metaclass);
4068 else if (PyTuple_Check(bases) && PyTuple_GET_SIZE(bases) > 0) {
4069 base = PyTuple_GET_ITEM(bases, 0);
4070 metaclass = PyObject_GetAttrString(base, "__class__");
4071 if (metaclass == NULL) {
4072 PyErr_Clear();
4073 metaclass = (PyObject *)base->ob_type;
4074 Py_INCREF(metaclass);
4075 }
4076 }
4077 else {
4078 PyObject *g = PyEval_GetGlobals();
4079 if (g != NULL && PyDict_Check(g))
4080 metaclass = PyDict_GetItemString(g, "__metaclass__");
4081 if (metaclass == NULL)
4082 metaclass = (PyObject *) &PyClass_Type;
4083 Py_INCREF(metaclass);
4084 }
4085 result = PyObject_CallFunctionObjArgs(metaclass, name, bases, methods, NULL);
4086 Py_DECREF(metaclass);
4087 if (result == NULL && PyErr_ExceptionMatches(PyExc_TypeError)) {
4088 /* A type error here likely means that the user passed
4089 in a base that was not a class (such the random module
4090 instead of the random.random type). Help them out with
4091 by augmenting the error message with more information.*/
4092
4093 PyObject *ptype, *pvalue, *ptraceback;
4094
4095 PyErr_Fetch(&ptype, &pvalue, &ptraceback);
4096 if (PyString_Check(pvalue)) {
4097 PyObject *newmsg;
4098 newmsg = PyString_FromFormat(
4099 "Error when calling the metaclass bases\n %s",
4100 PyString_AS_STRING(pvalue));
4101 if (newmsg != NULL) {
4102 Py_DECREF(pvalue);
4103 pvalue = newmsg;
4104 }
4105 }
4106 PyErr_Restore(ptype, pvalue, ptraceback);
4107 }
4108 return result;
4109 }
4110
4111 static int
4112 exec_statement(PyFrameObject *f, PyObject *prog, PyObject *globals,
4113 PyObject *locals)
4114 {
4115 int n;
4116 PyObject *v;
4117 int plain = 0;
4118
4119 if (PyTuple_Check(prog) && globals == Py_None && locals == Py_None &&
4120 ((n = PyTuple_Size(prog)) == 2 || n == 3)) {
4121 /* Backward compatibility hack */
4122 globals = PyTuple_GetItem(prog, 1);
4123 if (n == 3)
4124 locals = PyTuple_GetItem(prog, 2);
4125 prog = PyTuple_GetItem(prog, 0);
4126 }
4127 if (globals == Py_None) {
4128 globals = PyEval_GetGlobals();
4129 if (locals == Py_None) {
4130 locals = PyEval_GetLocals();
4131 plain = 1;
4132 }
4133 }
4134 else if (locals == Py_None)
4135 locals = globals;
4136 if (!PyString_Check(prog) &&
4137 !PyUnicode_Check(prog) &&
4138 !PyCode_Check(prog) &&
4139 !PyFile_Check(prog)) {
4140 PyErr_SetString(PyExc_TypeError,
4141 "exec: arg 1 must be a string, file, or code object");
4142 return -1;
4143 }
4144 if (!PyDict_Check(globals)) {
4145 PyErr_SetString(PyExc_TypeError,
4146 "exec: arg 2 must be a dictionary or None");
4147 return -1;
4148 }
4149 if (!PyMapping_Check(locals)) {
4150 PyErr_SetString(PyExc_TypeError,
4151 "exec: arg 3 must be a mapping or None");
4152 return -1;
4153 }
4154 if (PyDict_GetItemString(globals, "__builtins__") == NULL)
4155 PyDict_SetItemString(globals, "__builtins__", f->f_builtins);
4156 if (PyCode_Check(prog)) {
4157 if (PyCode_GetNumFree((PyCodeObject *)prog) > 0) {
4158 PyErr_SetString(PyExc_TypeError,
4159 "code object passed to exec may not contain free variables");
4160 return -1;
4161 }
4162 v = PyEval_EvalCode((PyCodeObject *) prog, globals, locals);
4163 }
4164 else if (PyFile_Check(prog)) {
4165 FILE *fp = PyFile_AsFile(prog);
4166 char *name = PyString_AsString(PyFile_Name(prog));
4167 PyCompilerFlags cf;
4168 cf.cf_flags = 0;
4169 if (PyEval_MergeCompilerFlags(&cf))
4170 v = PyRun_FileFlags(fp, name, Py_file_input, globals,
4171 locals, &cf);
4172 else
4173 v = PyRun_File(fp, name, Py_file_input, globals,
4174 locals);
4175 }
4176 else {
4177 PyObject *tmp = NULL;
4178 char *str;
4179 PyCompilerFlags cf;
4180 cf.cf_flags = 0;
4181 #ifdef Py_USING_UNICODE
4182 if (PyUnicode_Check(prog)) {
4183 tmp = PyUnicode_AsUTF8String(prog);
4184 if (tmp == NULL)
4185 return -1;
4186 prog = tmp;
4187 cf.cf_flags |= PyCF_SOURCE_IS_UTF8;
4188 }
4189 #endif
4190 if (PyString_AsStringAndSize(prog, &str, NULL))
4191 return -1;
4192 if (PyEval_MergeCompilerFlags(&cf))
4193 v = PyRun_StringFlags(str, Py_file_input, globals,
4194 locals, &cf);
4195 else
4196 v = PyRun_String(str, Py_file_input, globals, locals);
4197 Py_XDECREF(tmp);
4198 }
4199 if (plain)
4200 PyFrame_LocalsToFast(f, 0);
4201 if (v == NULL)
4202 return -1;
4203 Py_DECREF(v);
4204 return 0;
4205 }
4206
4207 static void
4208 format_exc_check_arg(PyObject *exc, char *format_str, PyObject *obj)
4209 {
4210 char *obj_str;
4211
4212 if (!obj)
4213 return;
4214
4215 obj_str = PyString_AsString(obj);
4216 if (!obj_str)
4217 return;
4218
4219 PyErr_Format(exc, format_str, obj_str);
4220 }
4221
4222 static PyObject *
4223 string_concatenate(PyObject *v, PyObject *w,
4224 PyFrameObject *f, unsigned char *next_instr)
4225 {
4226 /* This function implements 'variable += expr' when both arguments
4227 are strings. */
4228
4229 if (v->ob_refcnt == 2) {
4230 /* In the common case, there are 2 references to the value
4231 * stored in 'variable' when the += is performed: one on the
4232 * value stack (in 'v') and one still stored in the 'variable'.
4233 * We try to delete the variable now to reduce the refcnt to 1.
4234 */
4235 switch (*next_instr) {
4236 case STORE_FAST:
4237 {
4238 int oparg = PEEKARG();
4239 PyObject **fastlocals = f->f_localsplus;
4240 if (GETLOCAL(oparg) == v)
4241 SETLOCAL(oparg, NULL);
4242 break;
4243 }
4244 case STORE_DEREF:
4245 {
4246 PyObject **freevars = f->f_localsplus + f->f_code->co_nlocals;
4247 PyObject *c = freevars[PEEKARG()];
4248 if (PyCell_GET(c) == v)
4249 PyCell_Set(c, NULL);
4250 break;
4251 }
4252 case STORE_NAME:
4253 {
4254 PyObject *names = f->f_code->co_names;
4255 PyObject *name = GETITEM(names, PEEKARG());
4256 PyObject *locals = f->f_locals;
4257 if (PyDict_CheckExact(locals) &&
4258 PyDict_GetItem(locals, name) == v) {
4259 if (PyDict_DelItem(locals, name) != 0) {
4260 PyErr_Clear();
4261 }
4262 }
4263 break;
4264 }
4265 }
4266 }
4267
4268 if (v->ob_refcnt == 1 && !PyString_CHECK_INTERNED(v)) {
4269 /* Now we own the last reference to 'v', so we can resize it
4270 * in-place.
4271 */
4272 Py_ssize_t v_len = PyString_GET_SIZE(v);
4273 Py_ssize_t w_len = PyString_GET_SIZE(w);
4274 if (_PyString_Resize(&v, v_len + w_len) != 0) {
4275 /* XXX if _PyString_Resize() fails, 'v' has been
4276 * deallocated so it cannot be put back into 'variable'.
4277 * The MemoryError is raised when there is no value in
4278 * 'variable', which might (very remotely) be a cause
4279 * of incompatibilities.
4280 */
4281 return NULL;
4282 }
4283 /* copy 'w' into the newly allocated area of 'v' */
4284 memcpy(PyString_AS_STRING(v) + v_len,
4285 PyString_AS_STRING(w), w_len);
4286 return v;
4287 }
4288 else {
4289 /* When in-place resizing is not an option. */
4290 PyString_Concat(&v, w);
4291 return v;
4292 }
4293 }
4294
4295 #ifdef DYNAMIC_EXECUTION_PROFILE
4296
4297 static PyObject *
4298 getarray(long a[256])
4299 {
4300 int i;
4301 PyObject *l = PyList_New(256);
4302 if (l == NULL) return NULL;
4303 for (i = 0; i < 256; i++) {
4304 PyObject *x = PyInt_FromLong(a[i]);
4305 if (x == NULL) {
4306 Py_DECREF(l);
4307 return NULL;
4308 }
4309 PyList_SetItem(l, i, x);
4310 }
4311 for (i = 0; i < 256; i++)
4312 a[i] = 0;
4313 return l;
4314 }
4315
4316 PyObject *
4317 _Py_GetDXProfile(PyObject *self, PyObject *args)
4318 {
4319 #ifndef DXPAIRS
4320 return getarray(dxp);
4321 #else
4322 int i;
4323 PyObject *l = PyList_New(257);
4324 if (l == NULL) return NULL;
4325 for (i = 0; i < 257; i++) {
4326 PyObject *x = getarray(dxpairs[i]);
4327 if (x == NULL) {
4328 Py_DECREF(l);
4329 return NULL;
4330 }
4331 PyList_SetItem(l, i, x);
4332 }
4333 return l;
4334 #endif
4335 }
4336
4337 #endif
python git mirror