2 /* Execute compiled code */
5 XXX speed up searching for keywords by using a dictionary
9 /* enable more aggressive intra-module optimizations, where available */
10 #define PY_LOCAL_AGGRESSIVE
15 #include "frameobject.h"
18 #include "structmember.h"
24 #define READ_TIMESTAMP(var)
28 typedef unsigned long long uint64
;
30 #if defined(__ppc__) /* <- Don't know if this is the correct symbol; this
31 section should work for GCC on any PowerPC
32 platform, irrespective of OS.
33 POWER? Who knows :-) */
35 #define READ_TIMESTAMP(var) ppc_getcounter(&var)
38 ppc_getcounter(uint64
*v
)
40 register unsigned long tbu
, tb
, tbu2
;
43 asm volatile ("mftbu %0" : "=r" (tbu
) );
44 asm volatile ("mftb %0" : "=r" (tb
) );
45 asm volatile ("mftbu %0" : "=r" (tbu2
));
46 if (__builtin_expect(tbu
!= tbu2
, 0)) goto loop
;
48 /* The slightly peculiar way of writing the next lines is
49 compiled better by GCC than any other way I tried. */
50 ((long*)(v
))[0] = tbu
;
54 #else /* this is for linux/x86 (and probably any other GCC/x86 combo) */
56 #define READ_TIMESTAMP(val) \
57 __asm__ __volatile__("rdtsc" : "=A" (val))
61 void dump_tsc(int opcode
, int ticked
, uint64 inst0
, uint64 inst1
,
62 uint64 loop0
, uint64 loop1
, uint64 intr0
, uint64 intr1
)
64 uint64 intr
, inst
, loop
;
65 PyThreadState
*tstate
= PyThreadState_Get();
66 if (!tstate
->interp
->tscdump
)
69 inst
= inst1
- inst0
- intr
;
70 loop
= loop1
- loop0
- intr
;
71 fprintf(stderr
, "opcode=%03d t=%d inst=%06lld loop=%06lld\n",
72 opcode
, ticked
, inst
, loop
);
77 /* Turn this on if your compiler chokes on the big switch: */
78 /* #define CASE_TOO_BIG 1 */
81 /* For debugging the interpreter: */
82 #define LLTRACE 1 /* Low-level trace feature */
83 #define CHECKEXC 1 /* Double-check exception checking */
86 typedef PyObject
*(*callproc
)(PyObject
*, PyObject
*, PyObject
*);
88 /* Forward declarations */
90 static PyObject
* call_function(PyObject
***, int, uint64
*, uint64
*);
92 static PyObject
* call_function(PyObject
***, int);
94 static PyObject
* fast_function(PyObject
*, PyObject
***, int, int, int);
95 static PyObject
* do_call(PyObject
*, PyObject
***, int, int);
96 static PyObject
* ext_do_call(PyObject
*, PyObject
***, int, int, int);
97 static PyObject
* update_keyword_args(PyObject
*, int, PyObject
***,
99 static PyObject
* update_star_args(int, int, PyObject
*, PyObject
***);
100 static PyObject
* load_args(PyObject
***, int);
101 #define CALL_FLAG_VAR 1
102 #define CALL_FLAG_KW 2
106 static int prtrace(PyObject
*, char *);
108 static int call_trace(Py_tracefunc
, PyObject
*, PyFrameObject
*,
110 static int call_trace_protected(Py_tracefunc
, PyObject
*,
111 PyFrameObject
*, int, PyObject
*);
112 static void call_exc_trace(Py_tracefunc
, PyObject
*, PyFrameObject
*);
113 static int maybe_call_line_trace(Py_tracefunc
, PyObject
*,
114 PyFrameObject
*, int *, int *, int *);
116 static PyObject
* apply_slice(PyObject
*, PyObject
*, PyObject
*);
117 static int assign_slice(PyObject
*, PyObject
*,
118 PyObject
*, PyObject
*);
119 static PyObject
* cmp_outcome(int, PyObject
*, PyObject
*);
120 static PyObject
* import_from(PyObject
*, PyObject
*);
121 static int import_all_from(PyObject
*, PyObject
*);
122 static PyObject
* build_class(PyObject
*, PyObject
*, PyObject
*);
123 static int exec_statement(PyFrameObject
*,
124 PyObject
*, PyObject
*, PyObject
*);
125 static void set_exc_info(PyThreadState
*, PyObject
*, PyObject
*, PyObject
*);
126 static void reset_exc_info(PyThreadState
*);
127 static void format_exc_check_arg(PyObject
*, char *, PyObject
*);
128 static PyObject
* string_concatenate(PyObject
*, PyObject
*,
129 PyFrameObject
*, unsigned char *);
131 #define NAME_ERROR_MSG \
132 "name '%.200s' is not defined"
133 #define GLOBAL_NAME_ERROR_MSG \
134 "global name '%.200s' is not defined"
135 #define UNBOUNDLOCAL_ERROR_MSG \
136 "local variable '%.200s' referenced before assignment"
137 #define UNBOUNDFREE_ERROR_MSG \
138 "free variable '%.200s' referenced before assignment" \
139 " in enclosing scope"
141 /* Dynamic execution profile */
142 #ifdef DYNAMIC_EXECUTION_PROFILE
144 static long dxpairs
[257][256];
145 #define dxp dxpairs[256]
147 static long dxp
[256];
151 /* Function call profile */
154 static int pcall
[PCALL_NUM
];
157 #define PCALL_FUNCTION 1
158 #define PCALL_FAST_FUNCTION 2
159 #define PCALL_FASTER_FUNCTION 3
160 #define PCALL_METHOD 4
161 #define PCALL_BOUND_METHOD 5
162 #define PCALL_CFUNCTION 6
164 #define PCALL_GENERATOR 8
165 #define PCALL_OTHER 9
168 /* Notes about the statistics
172 FAST_FUNCTION means no argument tuple needs to be created.
173 FASTER_FUNCTION means that the fast-path frame setup code is used.
175 If there is a method call where the call can be optimized by changing
176 the argument tuple and calling the function directly, it gets recorded
179 As a result, the relationship among the statistics appears to be
180 PCALL_ALL == PCALL_FUNCTION + PCALL_METHOD - PCALL_BOUND_METHOD +
181 PCALL_CFUNCTION + PCALL_TYPE + PCALL_GENERATOR + PCALL_OTHER
182 PCALL_FUNCTION > PCALL_FAST_FUNCTION > PCALL_FASTER_FUNCTION
183 PCALL_METHOD > PCALL_BOUND_METHOD
186 #define PCALL(POS) pcall[POS]++
189 PyEval_GetCallStats(PyObject
*self
)
191 return Py_BuildValue("iiiiiiiiiii",
192 pcall
[0], pcall
[1], pcall
[2], pcall
[3],
193 pcall
[4], pcall
[5], pcall
[6], pcall
[7],
194 pcall
[8], pcall
[9], pcall
[10]);
200 PyEval_GetCallStats(PyObject
*self
)
213 #include "pythread.h"
215 static PyThread_type_lock interpreter_lock
= 0; /* This is the GIL */
216 static long main_thread
= 0;
219 PyEval_ThreadsInitialized(void)
221 return interpreter_lock
!= 0;
225 PyEval_InitThreads(void)
227 if (interpreter_lock
)
229 interpreter_lock
= PyThread_allocate_lock();
230 PyThread_acquire_lock(interpreter_lock
, 1);
231 main_thread
= PyThread_get_thread_ident();
235 PyEval_AcquireLock(void)
237 PyThread_acquire_lock(interpreter_lock
, 1);
241 PyEval_ReleaseLock(void)
243 PyThread_release_lock(interpreter_lock
);
247 PyEval_AcquireThread(PyThreadState
*tstate
)
250 Py_FatalError("PyEval_AcquireThread: NULL new thread state");
251 /* Check someone has called PyEval_InitThreads() to create the lock */
252 assert(interpreter_lock
);
253 PyThread_acquire_lock(interpreter_lock
, 1);
254 if (PyThreadState_Swap(tstate
) != NULL
)
256 "PyEval_AcquireThread: non-NULL old thread state");
260 PyEval_ReleaseThread(PyThreadState
*tstate
)
263 Py_FatalError("PyEval_ReleaseThread: NULL thread state");
264 if (PyThreadState_Swap(NULL
) != tstate
)
265 Py_FatalError("PyEval_ReleaseThread: wrong thread state");
266 PyThread_release_lock(interpreter_lock
);
269 /* This function is called from PyOS_AfterFork to ensure that newly
270 created child processes don't hold locks referring to threads which
271 are not running in the child process. (This could also be done using
272 pthread_atfork mechanism, at least for the pthreads implementation.) */
275 PyEval_ReInitThreads(void)
277 PyObject
*threading
, *result
;
278 PyThreadState
*tstate
;
280 if (!interpreter_lock
)
282 /*XXX Can't use PyThread_free_lock here because it does too
283 much error-checking. Doing this cleanly would require
284 adding a new function to each thread_*.h. Instead, just
285 create a new lock and waste a little bit of memory */
286 interpreter_lock
= PyThread_allocate_lock();
287 PyThread_acquire_lock(interpreter_lock
, 1);
288 main_thread
= PyThread_get_thread_ident();
290 /* Update the threading module with the new state.
292 tstate
= PyThreadState_GET();
293 threading
= PyMapping_GetItemString(tstate
->interp
->modules
,
295 if (threading
== NULL
) {
296 /* threading not imported */
300 result
= PyObject_CallMethod(threading
, "_after_fork", NULL
);
302 PyErr_WriteUnraisable(threading
);
305 Py_DECREF(threading
);
309 /* Functions save_thread and restore_thread are always defined so
310 dynamically loaded modules needn't be compiled separately for use
311 with and without threads: */
314 PyEval_SaveThread(void)
316 PyThreadState
*tstate
= PyThreadState_Swap(NULL
);
318 Py_FatalError("PyEval_SaveThread: NULL tstate");
320 if (interpreter_lock
)
321 PyThread_release_lock(interpreter_lock
);
327 PyEval_RestoreThread(PyThreadState
*tstate
)
330 Py_FatalError("PyEval_RestoreThread: NULL tstate");
332 if (interpreter_lock
) {
334 PyThread_acquire_lock(interpreter_lock
, 1);
338 PyThreadState_Swap(tstate
);
342 /* Mechanism whereby asynchronously executing callbacks (e.g. UNIX
343 signal handlers or Mac I/O completion routines) can schedule calls
344 to a function to be called synchronously.
345 The synchronous function is called with one void* argument.
346 It should return 0 for success or -1 for failure -- failure should
347 be accompanied by an exception.
349 If registry succeeds, the registry function returns 0; if it fails
350 (e.g. due to too many pending calls) it returns -1 (without setting
351 an exception condition).
353 Note that because registry may occur from within signal handlers,
354 or other asynchronous events, calling malloc() is unsafe!
357 Any thread can schedule pending calls, but only the main thread
361 XXX WARNING! ASYNCHRONOUSLY EXECUTING CODE!
362 There are two possible race conditions:
363 (1) nested asynchronous registry calls;
364 (2) registry calls made while pending calls are being processed.
365 While (1) is very unlikely, (2) is a real possibility.
366 The current code is safe against (2), but not against (1).
367 The safety against (2) is derived from the fact that only one
368 thread (the main thread) ever takes things out of the queue.
370 XXX Darn! With the advent of thread state, we should have an array
371 of pending calls per thread in the thread state! Later...
374 #define NPENDINGCALLS 32
378 } pendingcalls
[NPENDINGCALLS
];
379 static volatile int pendingfirst
= 0;
380 static volatile int pendinglast
= 0;
381 static volatile int things_to_do
= 0;
384 Py_AddPendingCall(int (*func
)(void *), void *arg
)
386 static volatile int busy
= 0;
388 /* XXX Begin critical section */
389 /* XXX If you want this to be safe against nested
390 XXX asynchronous calls, you'll have to work harder! */
395 j
= (i
+ 1) % NPENDINGCALLS
;
396 if (j
== pendingfirst
) {
398 return -1; /* Queue full */
400 pendingcalls
[i
].func
= func
;
401 pendingcalls
[i
].arg
= arg
;
405 things_to_do
= 1; /* Signal main loop */
407 /* XXX End critical section */
412 Py_MakePendingCalls(void)
416 if (main_thread
&& PyThread_get_thread_ident() != main_thread
)
428 if (i
== pendinglast
)
429 break; /* Queue empty */
430 func
= pendingcalls
[i
].func
;
431 arg
= pendingcalls
[i
].arg
;
432 pendingfirst
= (i
+ 1) % NPENDINGCALLS
;
435 things_to_do
= 1; /* We're not done yet */
444 /* The interpreter's recursion limit */
446 #ifndef Py_DEFAULT_RECURSION_LIMIT
447 #define Py_DEFAULT_RECURSION_LIMIT 1000
449 static int recursion_limit
= Py_DEFAULT_RECURSION_LIMIT
;
450 int _Py_CheckRecursionLimit
= Py_DEFAULT_RECURSION_LIMIT
;
453 Py_GetRecursionLimit(void)
455 return recursion_limit
;
459 Py_SetRecursionLimit(int new_limit
)
461 recursion_limit
= new_limit
;
462 _Py_CheckRecursionLimit
= recursion_limit
;
465 /* the macro Py_EnterRecursiveCall() only calls _Py_CheckRecursiveCall()
466 if the recursion_depth reaches _Py_CheckRecursionLimit.
467 If USE_STACKCHECK, the macro decrements _Py_CheckRecursionLimit
468 to guarantee that _Py_CheckRecursiveCall() is regularly called.
469 Without USE_STACKCHECK, there is no need for this. */
471 _Py_CheckRecursiveCall(char *where
)
473 PyThreadState
*tstate
= PyThreadState_GET();
475 #ifdef USE_STACKCHECK
476 if (PyOS_CheckStack()) {
477 --tstate
->recursion_depth
;
478 PyErr_SetString(PyExc_MemoryError
, "Stack overflow");
482 if (tstate
->recursion_depth
> recursion_limit
) {
483 --tstate
->recursion_depth
;
484 PyErr_Format(PyExc_RuntimeError
,
485 "maximum recursion depth exceeded%s",
489 _Py_CheckRecursionLimit
= recursion_limit
;
493 /* Status code for main loop (reason for stack unwind) */
495 WHY_NOT
= 0x0001, /* No error */
496 WHY_EXCEPTION
= 0x0002, /* Exception occurred */
497 WHY_RERAISE
= 0x0004, /* Exception re-raised by 'finally' */
498 WHY_RETURN
= 0x0008, /* 'return' statement */
499 WHY_BREAK
= 0x0010, /* 'break' statement */
500 WHY_CONTINUE
= 0x0020, /* 'continue' statement */
501 WHY_YIELD
= 0x0040 /* 'yield' operator */
504 static enum why_code
do_raise(PyObject
*, PyObject
*, PyObject
*);
505 static int unpack_iterable(PyObject
*, int, PyObject
**);
507 /* for manipulating the thread switch and periodic "stuff" - used to be
508 per thread, now just a pair o' globals */
509 int _Py_CheckInterval
= 100;
510 volatile int _Py_Ticker
= 100;
513 PyEval_EvalCode(PyCodeObject
*co
, PyObject
*globals
, PyObject
*locals
)
515 return PyEval_EvalCodeEx(co
,
517 (PyObject
**)NULL
, 0,
518 (PyObject
**)NULL
, 0,
519 (PyObject
**)NULL
, 0,
524 /* Interpreter main loop */
527 PyEval_EvalFrame(PyFrameObject
*f
) {
528 /* This is for backward compatibility with extension modules that
529 used this API; core interpreter code should call
530 PyEval_EvalFrameEx() */
531 return PyEval_EvalFrameEx(f
, 0);
535 PyEval_EvalFrameEx(PyFrameObject
*f
, int throwflag
)
540 register PyObject
**stack_pointer
; /* Next free slot in value stack */
541 register unsigned char *next_instr
;
542 register int opcode
; /* Current opcode */
543 register int oparg
; /* Current opcode argument, if any */
544 register enum why_code why
; /* Reason for block stack unwind */
545 register int err
; /* Error status -- nonzero if error */
546 register PyObject
*x
; /* Result object -- NULL if error */
547 register PyObject
*v
; /* Temporary objects popped off stack */
548 register PyObject
*w
;
549 register PyObject
*u
;
550 register PyObject
*t
;
551 register PyObject
*stream
= NULL
; /* for PRINT opcodes */
552 register PyObject
**fastlocals
, **freevars
;
553 PyObject
*retval
= NULL
; /* Return value */
554 PyThreadState
*tstate
= PyThreadState_GET();
557 /* when tracing we set things up so that
559 not (instr_lb <= current_bytecode_offset < instr_ub)
561 is true when the line being executed has changed. The
562 initial values are such as to make this false the first
563 time it is tested. */
564 int instr_ub
= -1, instr_lb
= 0, instr_prev
= -1;
566 unsigned char *first_instr
;
569 #if defined(Py_DEBUG) || defined(LLTRACE)
570 /* Make it easier to find out where we are with a debugger */
574 /* Tuple access macros */
577 #define GETITEM(v, i) PyTuple_GET_ITEM((PyTupleObject *)(v), (i))
579 #define GETITEM(v, i) PyTuple_GetItem((v), (i))
583 /* Use Pentium timestamp counter to mark certain events:
584 inst0 -- beginning of switch statement for opcode dispatch
585 inst1 -- end of switch statement (may be skipped)
586 loop0 -- the top of the mainloop
587 loop1 -- place where control returns again to top of mainloop
589 intr1 -- beginning of long interruption
590 intr2 -- end of long interruption
592 Many opcodes call out to helper C functions. In some cases, the
593 time in those functions should be counted towards the time for the
594 opcode, but not in all cases. For example, a CALL_FUNCTION opcode
595 calls another Python function; there's no point in charge all the
596 bytecode executed by the called function to the caller.
598 It's hard to make a useful judgement statically. In the presence
599 of operator overloading, it's impossible to tell if a call will
600 execute new Python code or not.
602 It's a case-by-case judgement. I'll use intr1 for the following
608 CALL_FUNCTION (and friends)
611 uint64 inst0
, inst1
, loop0
, loop1
, intr0
= 0, intr1
= 0;
614 READ_TIMESTAMP(inst0
);
615 READ_TIMESTAMP(inst1
);
616 READ_TIMESTAMP(loop0
);
617 READ_TIMESTAMP(loop1
);
619 /* shut up the compiler */
623 /* Code access macros */
625 #define INSTR_OFFSET() ((int)(next_instr - first_instr))
626 #define NEXTOP() (*next_instr++)
627 #define NEXTARG() (next_instr += 2, (next_instr[-1]<<8) + next_instr[-2])
628 #define PEEKARG() ((next_instr[2]<<8) + next_instr[1])
629 #define JUMPTO(x) (next_instr = first_instr + (x))
630 #define JUMPBY(x) (next_instr += (x))
632 /* OpCode prediction macros
633 Some opcodes tend to come in pairs thus making it possible to
634 predict the second code when the first is run. For example,
635 COMPARE_OP is often followed by JUMP_IF_FALSE or JUMP_IF_TRUE. And,
636 those opcodes are often followed by a POP_TOP.
638 Verifying the prediction costs a single high-speed test of a register
639 variable against a constant. If the pairing was good, then the
640 processor's own internal branch predication has a high likelihood of
641 success, resulting in a nearly zero-overhead transition to the
642 next opcode. A successful prediction saves a trip through the eval-loop
643 including its two unpredictable branches, the HAS_ARG test and the
644 switch-case. Combined with the processor's internal branch prediction,
645 a successful PREDICT has the effect of making the two opcodes run as if
646 they were a single new opcode with the bodies combined.
648 If collecting opcode statistics, your choices are to either keep the
649 predictions turned-on and interpret the results as if some opcodes
650 had been combined or turn-off predictions so that the opcode frequency
651 counter updates for both opcodes.
654 #ifdef DYNAMIC_EXECUTION_PROFILE
655 #define PREDICT(op) if (0) goto PRED_##op
657 #define PREDICT(op) if (*next_instr == op) goto PRED_##op
660 #define PREDICTED(op) PRED_##op: next_instr++
661 #define PREDICTED_WITH_ARG(op) PRED_##op: oparg = PEEKARG(); next_instr += 3
663 /* Stack manipulation macros */
665 /* The stack can grow at most MAXINT deep, as co_nlocals and
666 co_stacksize are ints. */
667 #define STACK_LEVEL() ((int)(stack_pointer - f->f_valuestack))
668 #define EMPTY() (STACK_LEVEL() == 0)
669 #define TOP() (stack_pointer[-1])
670 #define SECOND() (stack_pointer[-2])
671 #define THIRD() (stack_pointer[-3])
672 #define FOURTH() (stack_pointer[-4])
673 #define SET_TOP(v) (stack_pointer[-1] = (v))
674 #define SET_SECOND(v) (stack_pointer[-2] = (v))
675 #define SET_THIRD(v) (stack_pointer[-3] = (v))
676 #define SET_FOURTH(v) (stack_pointer[-4] = (v))
677 #define BASIC_STACKADJ(n) (stack_pointer += n)
678 #define BASIC_PUSH(v) (*stack_pointer++ = (v))
679 #define BASIC_POP() (*--stack_pointer)
682 #define PUSH(v) { (void)(BASIC_PUSH(v), \
683 lltrace && prtrace(TOP(), "push")); \
684 assert(STACK_LEVEL() <= co->co_stacksize); }
685 #define POP() ((void)(lltrace && prtrace(TOP(), "pop")), \
687 #define STACKADJ(n) { (void)(BASIC_STACKADJ(n), \
688 lltrace && prtrace(TOP(), "stackadj")); \
689 assert(STACK_LEVEL() <= co->co_stacksize); }
690 #define EXT_POP(STACK_POINTER) ((void)(lltrace && \
691 prtrace((STACK_POINTER)[-1], "ext_pop")), \
694 #define PUSH(v) BASIC_PUSH(v)
695 #define POP() BASIC_POP()
696 #define STACKADJ(n) BASIC_STACKADJ(n)
697 #define EXT_POP(STACK_POINTER) (*--(STACK_POINTER))
700 /* Local variable macros */
702 #define GETLOCAL(i) (fastlocals[i])
704 /* The SETLOCAL() macro must not DECREF the local variable in-place and
705 then store the new value; it must copy the old value to a temporary
706 value, then store the new value, and then DECREF the temporary value.
707 This is because it is possible that during the DECREF the frame is
708 accessed by other code (e.g. a __del__ method or gc.collect()) and the
709 variable would be pointing to already-freed memory. */
710 #define SETLOCAL(i, value) do { PyObject *tmp = GETLOCAL(i); \
711 GETLOCAL(i) = value; \
712 Py_XDECREF(tmp); } while (0)
720 if (Py_EnterRecursiveCall(""))
725 if (tstate
->use_tracing
) {
726 if (tstate
->c_tracefunc
!= NULL
) {
727 /* tstate->c_tracefunc, if defined, is a
728 function that will be called on *every* entry
729 to a code block. Its return value, if not
730 None, is a function that will be called at
731 the start of each executed line of code.
732 (Actually, the function must return itself
733 in order to continue tracing.) The trace
734 functions are called with three arguments:
735 a pointer to the current frame, a string
736 indicating why the function is called, and
737 an argument which depends on the situation.
738 The global trace function is also called
739 whenever an exception is detected. */
740 if (call_trace_protected(tstate
->c_tracefunc
,
742 f
, PyTrace_CALL
, Py_None
)) {
743 /* Trace function raised an error */
744 goto exit_eval_frame
;
747 if (tstate
->c_profilefunc
!= NULL
) {
748 /* Similar for c_profilefunc, except it needn't
749 return itself and isn't called for "line" events */
750 if (call_trace_protected(tstate
->c_profilefunc
,
751 tstate
->c_profileobj
,
752 f
, PyTrace_CALL
, Py_None
)) {
753 /* Profile function raised an error */
754 goto exit_eval_frame
;
760 names
= co
->co_names
;
761 consts
= co
->co_consts
;
762 fastlocals
= f
->f_localsplus
;
763 freevars
= f
->f_localsplus
+ co
->co_nlocals
;
764 first_instr
= (unsigned char*) PyString_AS_STRING(co
->co_code
);
765 /* An explanation is in order for the next line.
767 f->f_lasti now refers to the index of the last instruction
768 executed. You might think this was obvious from the name, but
769 this wasn't always true before 2.3! PyFrame_New now sets
770 f->f_lasti to -1 (i.e. the index *before* the first instruction)
771 and YIELD_VALUE doesn't fiddle with f_lasti any more. So this
774 When the PREDICT() macros are enabled, some opcode pairs follow in
775 direct succession without updating f->f_lasti. A successful
776 prediction effectively links the two codes together as if they
777 were a single new opcode; accordingly,f->f_lasti will point to
778 the first code in the pair (for instance, GET_ITER followed by
779 FOR_ITER is effectively a single opcode and f->f_lasti will point
780 at to the beginning of the combined pair.)
782 next_instr
= first_instr
+ f
->f_lasti
+ 1;
783 stack_pointer
= f
->f_stacktop
;
784 assert(stack_pointer
!= NULL
);
785 f
->f_stacktop
= NULL
; /* remains NULL unless yield suspends frame */
788 lltrace
= PyDict_GetItemString(f
->f_globals
, "__lltrace__") != NULL
;
790 #if defined(Py_DEBUG) || defined(LLTRACE)
791 filename
= PyString_AsString(co
->co_filename
);
796 x
= Py_None
; /* Not a reference, just anything non-NULL */
799 if (throwflag
) { /* support for generator.throw() */
807 /* Almost surely, the opcode executed a break
808 or a continue, preventing inst1 from being set
809 on the way out of the loop.
811 READ_TIMESTAMP(inst1
);
814 dump_tsc(opcode
, ticked
, inst0
, inst1
, loop0
, loop1
,
820 READ_TIMESTAMP(loop0
);
822 assert(stack_pointer
>= f
->f_valuestack
); /* else underflow */
823 assert(STACK_LEVEL() <= co
->co_stacksize
); /* else overflow */
825 /* Do periodic things. Doing this every time through
826 the loop would add too much overhead, so we do it
827 only every Nth instruction. We also do it if
828 ``things_to_do'' is set, i.e. when an asynchronous
829 event needs attention (e.g. a signal handler or
830 async I/O handler); see Py_AddPendingCall() and
831 Py_MakePendingCalls() above. */
833 if (--_Py_Ticker
< 0) {
834 if (*next_instr
== SETUP_FINALLY
) {
835 /* Make the last opcode before
836 a try: finally: block uninterruptable. */
837 goto fast_next_opcode
;
839 _Py_Ticker
= _Py_CheckInterval
;
840 tstate
->tick_counter
++;
845 if (Py_MakePendingCalls() < 0) {
850 /* MakePendingCalls() didn't succeed.
851 Force early re-execution of this
852 "periodic" code, possibly after
857 if (interpreter_lock
) {
858 /* Give another thread a chance */
860 if (PyThreadState_Swap(NULL
) != tstate
)
861 Py_FatalError("ceval: tstate mix-up");
862 PyThread_release_lock(interpreter_lock
);
864 /* Other threads may run now */
866 PyThread_acquire_lock(interpreter_lock
, 1);
867 if (PyThreadState_Swap(tstate
) != NULL
)
868 Py_FatalError("ceval: orphan tstate");
870 /* Check for thread interrupts */
872 if (tstate
->async_exc
!= NULL
) {
873 x
= tstate
->async_exc
;
874 tstate
->async_exc
= NULL
;
885 f
->f_lasti
= INSTR_OFFSET();
887 /* line-by-line tracing support */
889 if (tstate
->c_tracefunc
!= NULL
&& !tstate
->tracing
) {
890 /* see maybe_call_line_trace
891 for expository comments */
892 f
->f_stacktop
= stack_pointer
;
894 err
= maybe_call_line_trace(tstate
->c_tracefunc
,
896 f
, &instr_lb
, &instr_ub
,
898 /* Reload possibly changed frame fields */
900 if (f
->f_stacktop
!= NULL
) {
901 stack_pointer
= f
->f_stacktop
;
902 f
->f_stacktop
= NULL
;
905 /* trace function raised an exception */
910 /* Extract opcode and argument */
913 oparg
= 0; /* allows oparg to be stored in a register because
914 it doesn't have to be remembered across a full loop */
918 #ifdef DYNAMIC_EXECUTION_PROFILE
920 dxpairs
[lastopcode
][opcode
]++;
927 /* Instruction tracing */
930 if (HAS_ARG(opcode
)) {
931 printf("%d: %d, %d\n",
932 f
->f_lasti
, opcode
, oparg
);
941 /* Main switch on opcode */
942 READ_TIMESTAMP(inst0
);
947 It is essential that any operation that fails sets either
948 x to NULL, err to nonzero, or why to anything but WHY_NOT,
949 and that no operation that succeeds does this! */
951 /* case STOP_CODE: this is an error! */
954 goto fast_next_opcode
;
961 goto fast_next_opcode
;
963 format_exc_check_arg(PyExc_UnboundLocalError
,
964 UNBOUNDLOCAL_ERROR_MSG
,
965 PyTuple_GetItem(co
->co_varnames
, oparg
));
969 x
= GETITEM(consts
, oparg
);
972 goto fast_next_opcode
;
974 PREDICTED_WITH_ARG(STORE_FAST
);
978 goto fast_next_opcode
;
984 goto fast_next_opcode
;
991 goto fast_next_opcode
;
1000 goto fast_next_opcode
;
1011 goto fast_next_opcode
;
1017 goto fast_next_opcode
;
1028 goto fast_next_opcode
;
1029 } else if (oparg
== 3) {
1040 goto fast_next_opcode
;
1042 Py_FatalError("invalid argument to DUP_TOPX"
1043 " (bytecode corruption?)");
1046 case UNARY_POSITIVE
:
1048 x
= PyNumber_Positive(v
);
1051 if (x
!= NULL
) continue;
1054 case UNARY_NEGATIVE
:
1056 x
= PyNumber_Negative(v
);
1059 if (x
!= NULL
) continue;
1064 err
= PyObject_IsTrue(v
);
1072 Py_INCREF(Py_False
);
1082 x
= PyObject_Repr(v
);
1085 if (x
!= NULL
) continue;
1090 x
= PyNumber_Invert(v
);
1093 if (x
!= NULL
) continue;
1099 x
= PyNumber_Power(v
, w
, Py_None
);
1103 if (x
!= NULL
) continue;
1106 case BINARY_MULTIPLY
:
1109 x
= PyNumber_Multiply(v
, w
);
1113 if (x
!= NULL
) continue;
1117 if (!_Py_QnewFlag
) {
1120 x
= PyNumber_Divide(v
, w
);
1124 if (x
!= NULL
) continue;
1127 /* -Qnew is in effect: fall through to
1128 BINARY_TRUE_DIVIDE */
1129 case BINARY_TRUE_DIVIDE
:
1132 x
= PyNumber_TrueDivide(v
, w
);
1136 if (x
!= NULL
) continue;
1139 case BINARY_FLOOR_DIVIDE
:
1142 x
= PyNumber_FloorDivide(v
, w
);
1146 if (x
!= NULL
) continue;
1152 x
= PyNumber_Remainder(v
, w
);
1156 if (x
!= NULL
) continue;
1162 if (PyInt_CheckExact(v
) && PyInt_CheckExact(w
)) {
1163 /* INLINE: int + int */
1164 register long a
, b
, i
;
1165 a
= PyInt_AS_LONG(v
);
1166 b
= PyInt_AS_LONG(w
);
1168 if ((i
^a
) < 0 && (i
^b
) < 0)
1170 x
= PyInt_FromLong(i
);
1172 else if (PyString_CheckExact(v
) &&
1173 PyString_CheckExact(w
)) {
1174 x
= string_concatenate(v
, w
, f
, next_instr
);
1175 /* string_concatenate consumed the ref to v */
1176 goto skip_decref_vx
;
1180 x
= PyNumber_Add(v
, w
);
1186 if (x
!= NULL
) continue;
1189 case BINARY_SUBTRACT
:
1192 if (PyInt_CheckExact(v
) && PyInt_CheckExact(w
)) {
1193 /* INLINE: int - int */
1194 register long a
, b
, i
;
1195 a
= PyInt_AS_LONG(v
);
1196 b
= PyInt_AS_LONG(w
);
1198 if ((i
^a
) < 0 && (i
^~b
) < 0)
1200 x
= PyInt_FromLong(i
);
1204 x
= PyNumber_Subtract(v
, w
);
1209 if (x
!= NULL
) continue;
1215 if (PyList_CheckExact(v
) && PyInt_CheckExact(w
)) {
1216 /* INLINE: list[int] */
1217 Py_ssize_t i
= PyInt_AsSsize_t(w
);
1219 i
+= PyList_GET_SIZE(v
);
1220 if (i
>= 0 && i
< PyList_GET_SIZE(v
)) {
1221 x
= PyList_GET_ITEM(v
, i
);
1229 x
= PyObject_GetItem(v
, w
);
1233 if (x
!= NULL
) continue;
1239 x
= PyNumber_Lshift(v
, w
);
1243 if (x
!= NULL
) continue;
1249 x
= PyNumber_Rshift(v
, w
);
1253 if (x
!= NULL
) continue;
1259 x
= PyNumber_And(v
, w
);
1263 if (x
!= NULL
) continue;
1269 x
= PyNumber_Xor(v
, w
);
1273 if (x
!= NULL
) continue;
1279 x
= PyNumber_Or(v
, w
);
1283 if (x
!= NULL
) continue;
1289 err
= PyList_Append(v
, w
);
1293 PREDICT(JUMP_ABSOLUTE
);
1301 x
= PyNumber_InPlacePower(v
, w
, Py_None
);
1305 if (x
!= NULL
) continue;
1308 case INPLACE_MULTIPLY
:
1311 x
= PyNumber_InPlaceMultiply(v
, w
);
1315 if (x
!= NULL
) continue;
1318 case INPLACE_DIVIDE
:
1319 if (!_Py_QnewFlag
) {
1322 x
= PyNumber_InPlaceDivide(v
, w
);
1326 if (x
!= NULL
) continue;
1329 /* -Qnew is in effect: fall through to
1330 INPLACE_TRUE_DIVIDE */
1331 case INPLACE_TRUE_DIVIDE
:
1334 x
= PyNumber_InPlaceTrueDivide(v
, w
);
1338 if (x
!= NULL
) continue;
1341 case INPLACE_FLOOR_DIVIDE
:
1344 x
= PyNumber_InPlaceFloorDivide(v
, w
);
1348 if (x
!= NULL
) continue;
1351 case INPLACE_MODULO
:
1354 x
= PyNumber_InPlaceRemainder(v
, w
);
1358 if (x
!= NULL
) continue;
1364 if (PyInt_CheckExact(v
) && PyInt_CheckExact(w
)) {
1365 /* INLINE: int + int */
1366 register long a
, b
, i
;
1367 a
= PyInt_AS_LONG(v
);
1368 b
= PyInt_AS_LONG(w
);
1370 if ((i
^a
) < 0 && (i
^b
) < 0)
1372 x
= PyInt_FromLong(i
);
1374 else if (PyString_CheckExact(v
) &&
1375 PyString_CheckExact(w
)) {
1376 x
= string_concatenate(v
, w
, f
, next_instr
);
1377 /* string_concatenate consumed the ref to v */
1382 x
= PyNumber_InPlaceAdd(v
, w
);
1388 if (x
!= NULL
) continue;
1391 case INPLACE_SUBTRACT
:
1394 if (PyInt_CheckExact(v
) && PyInt_CheckExact(w
)) {
1395 /* INLINE: int - int */
1396 register long a
, b
, i
;
1397 a
= PyInt_AS_LONG(v
);
1398 b
= PyInt_AS_LONG(w
);
1400 if ((i
^a
) < 0 && (i
^~b
) < 0)
1402 x
= PyInt_FromLong(i
);
1406 x
= PyNumber_InPlaceSubtract(v
, w
);
1411 if (x
!= NULL
) continue;
1414 case INPLACE_LSHIFT
:
1417 x
= PyNumber_InPlaceLshift(v
, w
);
1421 if (x
!= NULL
) continue;
1424 case INPLACE_RSHIFT
:
1427 x
= PyNumber_InPlaceRshift(v
, w
);
1431 if (x
!= NULL
) continue;
1437 x
= PyNumber_InPlaceAnd(v
, w
);
1441 if (x
!= NULL
) continue;
1447 x
= PyNumber_InPlaceXor(v
, w
);
1451 if (x
!= NULL
) continue;
1457 x
= PyNumber_InPlaceOr(v
, w
);
1461 if (x
!= NULL
) continue;
1468 if ((opcode
-SLICE
) & 2)
1472 if ((opcode
-SLICE
) & 1)
1477 x
= apply_slice(u
, v
, w
);
1482 if (x
!= NULL
) continue;
1489 if ((opcode
-STORE_SLICE
) & 2)
1493 if ((opcode
-STORE_SLICE
) & 1)
1499 err
= assign_slice(u
, v
, w
, t
); /* u[v:w] = t */
1504 if (err
== 0) continue;
1507 case DELETE_SLICE
+0:
1508 case DELETE_SLICE
+1:
1509 case DELETE_SLICE
+2:
1510 case DELETE_SLICE
+3:
1511 if ((opcode
-DELETE_SLICE
) & 2)
1515 if ((opcode
-DELETE_SLICE
) & 1)
1520 err
= assign_slice(u
, v
, w
, (PyObject
*)NULL
);
1525 if (err
== 0) continue;
1534 err
= PyObject_SetItem(v
, w
, u
);
1538 if (err
== 0) continue;
1546 err
= PyObject_DelItem(v
, w
);
1549 if (err
== 0) continue;
1554 w
= PySys_GetObject("displayhook");
1556 PyErr_SetString(PyExc_RuntimeError
,
1557 "lost sys.displayhook");
1562 x
= PyTuple_Pack(1, v
);
1567 w
= PyEval_CallObject(w
, x
);
1578 /* fall through to PRINT_ITEM */
1582 if (stream
== NULL
|| stream
== Py_None
) {
1583 w
= PySys_GetObject("stdout");
1585 PyErr_SetString(PyExc_RuntimeError
,
1590 /* PyFile_SoftSpace() can exececute arbitrary code
1591 if sys.stdout is an instance with a __getattr__.
1592 If __getattr__ raises an exception, w will
1593 be freed, so we need to prevent that temporarily. */
1595 if (w
!= NULL
&& PyFile_SoftSpace(w
, 0))
1596 err
= PyFile_WriteString(" ", w
);
1598 err
= PyFile_WriteObject(v
, w
, Py_PRINT_RAW
);
1600 /* XXX move into writeobject() ? */
1601 if (PyString_Check(v
)) {
1602 char *s
= PyString_AS_STRING(v
);
1603 Py_ssize_t len
= PyString_GET_SIZE(v
);
1605 !isspace(Py_CHARMASK(s
[len
-1])) ||
1607 PyFile_SoftSpace(w
, 1);
1609 #ifdef Py_USING_UNICODE
1610 else if (PyUnicode_Check(v
)) {
1611 Py_UNICODE
*s
= PyUnicode_AS_UNICODE(v
);
1612 Py_ssize_t len
= PyUnicode_GET_SIZE(v
);
1614 !Py_UNICODE_ISSPACE(s
[len
-1]) ||
1616 PyFile_SoftSpace(w
, 1);
1620 PyFile_SoftSpace(w
, 1);
1630 case PRINT_NEWLINE_TO
:
1632 /* fall through to PRINT_NEWLINE */
1635 if (stream
== NULL
|| stream
== Py_None
) {
1636 w
= PySys_GetObject("stdout");
1638 PyErr_SetString(PyExc_RuntimeError
,
1642 /* w.write() may replace sys.stdout, so we
1643 * have to keep our reference to it */
1645 err
= PyFile_WriteString("\n", w
);
1647 PyFile_SoftSpace(w
, 0);
1656 default: switch (opcode
) {
1662 u
= POP(); /* traceback */
1665 v
= POP(); /* value */
1668 w
= POP(); /* exc */
1669 case 0: /* Fallthrough */
1670 why
= do_raise(w
, v
, u
);
1673 PyErr_SetString(PyExc_SystemError
,
1674 "bad RAISE_VARARGS oparg");
1675 why
= WHY_EXCEPTION
;
1681 if ((x
= f
->f_locals
) != NULL
) {
1686 PyErr_SetString(PyExc_SystemError
, "no locals");
1692 goto fast_block_end
;
1696 f
->f_stacktop
= stack_pointer
;
1705 READ_TIMESTAMP(intr0
);
1706 err
= exec_statement(f
, u
, v
, w
);
1707 READ_TIMESTAMP(intr1
);
1715 PyTryBlock
*b
= PyFrame_BlockPop(f
);
1716 while (STACK_LEVEL() > b
->b_level
) {
1723 PREDICTED(END_FINALLY
);
1726 if (PyInt_Check(v
)) {
1727 why
= (enum why_code
) PyInt_AS_LONG(v
);
1728 assert(why
!= WHY_YIELD
);
1729 if (why
== WHY_RETURN
||
1730 why
== WHY_CONTINUE
)
1733 else if (PyExceptionClass_Check(v
) ||
1734 PyString_Check(v
)) {
1737 PyErr_Restore(v
, w
, u
);
1741 else if (v
!= Py_None
) {
1742 PyErr_SetString(PyExc_SystemError
,
1743 "'finally' pops bad exception");
1744 why
= WHY_EXCEPTION
;
1754 x
= build_class(u
, v
, w
);
1762 w
= GETITEM(names
, oparg
);
1764 if ((x
= f
->f_locals
) != NULL
) {
1765 if (PyDict_CheckExact(x
))
1766 err
= PyDict_SetItem(x
, w
, v
);
1768 err
= PyObject_SetItem(x
, w
, v
);
1770 if (err
== 0) continue;
1773 PyErr_Format(PyExc_SystemError
,
1774 "no locals found when storing %s",
1779 w
= GETITEM(names
, oparg
);
1780 if ((x
= f
->f_locals
) != NULL
) {
1781 if ((err
= PyObject_DelItem(x
, w
)) != 0)
1782 format_exc_check_arg(PyExc_NameError
,
1787 PyErr_Format(PyExc_SystemError
,
1788 "no locals when deleting %s",
1792 PREDICTED_WITH_ARG(UNPACK_SEQUENCE
);
1793 case UNPACK_SEQUENCE
:
1795 if (PyTuple_CheckExact(v
) &&
1796 PyTuple_GET_SIZE(v
) == oparg
) {
1797 PyObject
**items
= \
1798 ((PyTupleObject
*)v
)->ob_item
;
1806 } else if (PyList_CheckExact(v
) &&
1807 PyList_GET_SIZE(v
) == oparg
) {
1808 PyObject
**items
= \
1809 ((PyListObject
*)v
)->ob_item
;
1815 } else if (unpack_iterable(v
, oparg
,
1816 stack_pointer
+ oparg
)) {
1817 stack_pointer
+= oparg
;
1819 /* unpack_iterable() raised an exception */
1820 why
= WHY_EXCEPTION
;
1826 w
= GETITEM(names
, oparg
);
1830 err
= PyObject_SetAttr(v
, w
, u
); /* v.w = u */
1833 if (err
== 0) continue;
1837 w
= GETITEM(names
, oparg
);
1839 err
= PyObject_SetAttr(v
, w
, (PyObject
*)NULL
);
1845 w
= GETITEM(names
, oparg
);
1847 err
= PyDict_SetItem(f
->f_globals
, w
, v
);
1849 if (err
== 0) continue;
1853 w
= GETITEM(names
, oparg
);
1854 if ((err
= PyDict_DelItem(f
->f_globals
, w
)) != 0)
1855 format_exc_check_arg(
1856 PyExc_NameError
, GLOBAL_NAME_ERROR_MSG
, w
);
1860 w
= GETITEM(names
, oparg
);
1861 if ((v
= f
->f_locals
) == NULL
) {
1862 PyErr_Format(PyExc_SystemError
,
1863 "no locals when loading %s",
1867 if (PyDict_CheckExact(v
)) {
1868 x
= PyDict_GetItem(v
, w
);
1872 x
= PyObject_GetItem(v
, w
);
1873 if (x
== NULL
&& PyErr_Occurred()) {
1874 if (!PyErr_ExceptionMatches(
1881 x
= PyDict_GetItem(f
->f_globals
, w
);
1883 x
= PyDict_GetItem(f
->f_builtins
, w
);
1885 format_exc_check_arg(
1897 w
= GETITEM(names
, oparg
);
1898 if (PyString_CheckExact(w
)) {
1899 /* Inline the PyDict_GetItem() calls.
1900 WARNING: this is an extreme speed hack.
1901 Do not try this at home. */
1902 long hash
= ((PyStringObject
*)w
)->ob_shash
;
1906 d
= (PyDictObject
*)(f
->f_globals
);
1907 e
= d
->ma_lookup(d
, w
, hash
);
1918 d
= (PyDictObject
*)(f
->f_builtins
);
1919 e
= d
->ma_lookup(d
, w
, hash
);
1930 goto load_global_error
;
1933 /* This is the un-inlined version of the code above */
1934 x
= PyDict_GetItem(f
->f_globals
, w
);
1936 x
= PyDict_GetItem(f
->f_builtins
, w
);
1939 format_exc_check_arg(
1941 GLOBAL_NAME_ERROR_MSG
, w
);
1950 x
= GETLOCAL(oparg
);
1952 SETLOCAL(oparg
, NULL
);
1955 format_exc_check_arg(
1956 PyExc_UnboundLocalError
,
1957 UNBOUNDLOCAL_ERROR_MSG
,
1958 PyTuple_GetItem(co
->co_varnames
, oparg
)
1963 x
= freevars
[oparg
];
1966 if (x
!= NULL
) continue;
1970 x
= freevars
[oparg
];
1977 /* Don't stomp existing exception */
1978 if (PyErr_Occurred())
1980 if (oparg
< PyTuple_GET_SIZE(co
->co_cellvars
)) {
1981 v
= PyTuple_GET_ITEM(co
->co_cellvars
,
1983 format_exc_check_arg(
1984 PyExc_UnboundLocalError
,
1985 UNBOUNDLOCAL_ERROR_MSG
,
1988 v
= PyTuple_GET_ITEM(co
->co_freevars
, oparg
-
1989 PyTuple_GET_SIZE(co
->co_cellvars
));
1990 format_exc_check_arg(PyExc_NameError
,
1991 UNBOUNDFREE_ERROR_MSG
, v
);
1997 x
= freevars
[oparg
];
2003 x
= PyTuple_New(oparg
);
2005 for (; --oparg
>= 0;) {
2007 PyTuple_SET_ITEM(x
, oparg
, w
);
2015 x
= PyList_New(oparg
);
2017 for (; --oparg
>= 0;) {
2019 PyList_SET_ITEM(x
, oparg
, w
);
2027 x
= _PyDict_NewPresized((Py_ssize_t
)oparg
);
2029 if (x
!= NULL
) continue;
2033 w
= TOP(); /* key */
2034 u
= SECOND(); /* value */
2035 v
= THIRD(); /* dict */
2037 assert (PyDict_CheckExact(v
));
2038 err
= PyDict_SetItem(v
, w
, u
); /* v[w] = u */
2041 if (err
== 0) continue;
2045 w
= GETITEM(names
, oparg
);
2047 x
= PyObject_GetAttr(v
, w
);
2050 if (x
!= NULL
) continue;
2056 if (PyInt_CheckExact(w
) && PyInt_CheckExact(v
)) {
2057 /* INLINE: cmp(int, int) */
2060 a
= PyInt_AS_LONG(v
);
2061 b
= PyInt_AS_LONG(w
);
2063 case PyCmp_LT
: res
= a
< b
; break;
2064 case PyCmp_LE
: res
= a
<= b
; break;
2065 case PyCmp_EQ
: res
= a
== b
; break;
2066 case PyCmp_NE
: res
= a
!= b
; break;
2067 case PyCmp_GT
: res
= a
> b
; break;
2068 case PyCmp_GE
: res
= a
>= b
; break;
2069 case PyCmp_IS
: res
= v
== w
; break;
2070 case PyCmp_IS_NOT
: res
= v
!= w
; break;
2071 default: goto slow_compare
;
2073 x
= res
? Py_True
: Py_False
;
2078 x
= cmp_outcome(oparg
, v
, w
);
2083 if (x
== NULL
) break;
2084 PREDICT(JUMP_IF_FALSE
);
2085 PREDICT(JUMP_IF_TRUE
);
2089 w
= GETITEM(names
, oparg
);
2090 x
= PyDict_GetItemString(f
->f_builtins
, "__import__");
2092 PyErr_SetString(PyExc_ImportError
,
2093 "__import__ not found");
2099 if (PyInt_AsLong(u
) != -1 || PyErr_Occurred())
2103 f
->f_locals
== NULL
?
2104 Py_None
: f
->f_locals
,
2111 f
->f_locals
== NULL
?
2112 Py_None
: f
->f_locals
,
2122 READ_TIMESTAMP(intr0
);
2124 x
= PyEval_CallObject(v
, w
);
2126 READ_TIMESTAMP(intr1
);
2129 if (x
!= NULL
) continue;
2134 PyFrame_FastToLocals(f
);
2135 if ((x
= f
->f_locals
) == NULL
) {
2136 PyErr_SetString(PyExc_SystemError
,
2137 "no locals found during 'import *'");
2140 READ_TIMESTAMP(intr0
);
2141 err
= import_all_from(x
, v
);
2142 READ_TIMESTAMP(intr1
);
2143 PyFrame_LocalsToFast(f
, 0);
2145 if (err
== 0) continue;
2149 w
= GETITEM(names
, oparg
);
2151 READ_TIMESTAMP(intr0
);
2152 x
= import_from(v
, w
);
2153 READ_TIMESTAMP(intr1
);
2155 if (x
!= NULL
) continue;
2160 goto fast_next_opcode
;
2162 PREDICTED_WITH_ARG(JUMP_IF_FALSE
);
2167 goto fast_next_opcode
;
2169 if (w
== Py_False
) {
2171 goto fast_next_opcode
;
2173 err
= PyObject_IsTrue(w
);
2182 PREDICTED_WITH_ARG(JUMP_IF_TRUE
);
2185 if (w
== Py_False
) {
2187 goto fast_next_opcode
;
2191 goto fast_next_opcode
;
2193 err
= PyObject_IsTrue(w
);
2204 PREDICTED_WITH_ARG(JUMP_ABSOLUTE
);
2208 /* Enabling this path speeds-up all while and for-loops by bypassing
2209 the per-loop checks for signals. By default, this should be turned-off
2210 because it prevents detection of a control-break in tight loops like
2211 "while 1: pass". Compile with this option turned-on when you need
2212 the speed-up and do not need break checking inside tight loops (ones
2213 that contain only instructions ending with goto fast_next_opcode).
2215 goto fast_next_opcode
;
2221 /* before: [obj]; after [getiter(obj)] */
2223 x
= PyObject_GetIter(v
);
2233 PREDICTED_WITH_ARG(FOR_ITER
);
2235 /* before: [iter]; after: [iter, iter()] *or* [] */
2237 x
= (*v
->ob_type
->tp_iternext
)(v
);
2240 PREDICT(STORE_FAST
);
2241 PREDICT(UNPACK_SEQUENCE
);
2244 if (PyErr_Occurred()) {
2245 if (!PyErr_ExceptionMatches(
2246 PyExc_StopIteration
))
2250 /* iterator ended normally */
2258 goto fast_block_end
;
2261 retval
= PyInt_FromLong(oparg
);
2267 goto fast_block_end
;
2272 /* NOTE: If you add any new block-setup opcodes that
2273 are not try/except/finally handlers, you may need
2274 to update the PyGen_NeedsFinalizing() function.
2277 PyFrame_BlockSetup(f
, opcode
, INSTR_OFFSET() + oparg
,
2283 /* At the top of the stack are 1-3 values indicating
2284 how/why we entered the finally clause:
2286 - (TOP, SECOND) = (WHY_{RETURN,CONTINUE}), retval
2287 - TOP = WHY_*; no retval below it
2288 - (TOP, SECOND, THIRD) = exc_info()
2289 Below them is EXIT, the context.__exit__ bound method.
2290 In the last case, we must call
2291 EXIT(TOP, SECOND, THIRD)
2292 otherwise we must call
2293 EXIT(None, None, None)
2295 In all cases, we remove EXIT from the stack, leaving
2296 the rest in the same order.
2298 In addition, if the stack represents an exception,
2299 *and* the function call returns a 'true' value, we
2300 "zap" this information, to prevent END_FINALLY from
2301 re-raising the exception. (But non-local gotos
2302 should still be resumed.)
2305 PyObject
*exit_func
;
2313 else if (PyInt_Check(u
)) {
2314 switch(PyInt_AS_LONG(u
)) {
2317 /* Retval in TOP. */
2318 exit_func
= SECOND();
2327 u
= v
= w
= Py_None
;
2332 exit_func
= THIRD();
2337 /* XXX Not the fastest way to call it... */
2338 x
= PyObject_CallFunctionObjArgs(exit_func
, u
, v
, w
,
2341 Py_DECREF(exit_func
);
2342 break; /* Go to error exit */
2344 if (u
!= Py_None
&& PyObject_IsTrue(x
)) {
2345 /* There was an exception and a true return */
2353 /* The stack was rearranged to remove EXIT
2354 above. Let END_FINALLY do its thing */
2357 Py_DECREF(exit_func
);
2358 PREDICT(END_FINALLY
);
2368 x
= call_function(&sp
, oparg
, &intr0
, &intr1
);
2370 x
= call_function(&sp
, oparg
);
2379 case CALL_FUNCTION_VAR
:
2380 case CALL_FUNCTION_KW
:
2381 case CALL_FUNCTION_VAR_KW
:
2383 int na
= oparg
& 0xff;
2384 int nk
= (oparg
>>8) & 0xff;
2385 int flags
= (opcode
- CALL_FUNCTION
) & 3;
2386 int n
= na
+ 2 * nk
;
2387 PyObject
**pfunc
, *func
, **sp
;
2389 if (flags
& CALL_FLAG_VAR
)
2391 if (flags
& CALL_FLAG_KW
)
2393 pfunc
= stack_pointer
- n
- 1;
2396 if (PyMethod_Check(func
)
2397 && PyMethod_GET_SELF(func
) != NULL
) {
2398 PyObject
*self
= PyMethod_GET_SELF(func
);
2400 func
= PyMethod_GET_FUNCTION(func
);
2409 READ_TIMESTAMP(intr0
);
2410 x
= ext_do_call(func
, &sp
, flags
, na
, nk
);
2411 READ_TIMESTAMP(intr1
);
2415 while (stack_pointer
> pfunc
) {
2426 v
= POP(); /* code object */
2427 x
= PyFunction_New(v
, f
->f_globals
);
2429 /* XXX Maybe this should be a separate opcode? */
2430 if (x
!= NULL
&& oparg
> 0) {
2431 v
= PyTuple_New(oparg
);
2437 while (--oparg
>= 0) {
2439 PyTuple_SET_ITEM(v
, oparg
, w
);
2441 err
= PyFunction_SetDefaults(x
, v
);
2449 v
= POP(); /* code object */
2450 x
= PyFunction_New(v
, f
->f_globals
);
2454 err
= PyFunction_SetClosure(x
, v
);
2457 if (x
!= NULL
&& oparg
> 0) {
2458 v
= PyTuple_New(oparg
);
2464 while (--oparg
>= 0) {
2466 PyTuple_SET_ITEM(v
, oparg
, w
);
2468 err
= PyFunction_SetDefaults(x
, v
);
2482 x
= PySlice_New(u
, v
, w
);
2487 if (x
!= NULL
) continue;
2492 oparg
= oparg
<<16 | NEXTARG();
2493 goto dispatch_opcode
;
2497 "XXX lineno: %d, opcode: %d\n",
2498 PyCode_Addr2Line(f
->f_code
, f
->f_lasti
),
2500 PyErr_SetString(PyExc_SystemError
, "unknown opcode");
2501 why
= WHY_EXCEPTION
;
2512 READ_TIMESTAMP(inst1
);
2514 /* Quickly continue if no error occurred */
2516 if (why
== WHY_NOT
) {
2517 if (err
== 0 && x
!= NULL
) {
2519 /* This check is expensive! */
2520 if (PyErr_Occurred())
2522 "XXX undetected error\n");
2525 READ_TIMESTAMP(loop1
);
2526 continue; /* Normal, fast path */
2531 why
= WHY_EXCEPTION
;
2536 /* Double-check exception status */
2538 if (why
== WHY_EXCEPTION
|| why
== WHY_RERAISE
) {
2539 if (!PyErr_Occurred()) {
2540 PyErr_SetString(PyExc_SystemError
,
2541 "error return without exception set");
2542 why
= WHY_EXCEPTION
;
2547 /* This check is expensive! */
2548 if (PyErr_Occurred()) {
2550 sprintf(buf
, "Stack unwind with exception "
2551 "set and why=%d", why
);
2557 /* Log traceback info if this is a real exception */
2559 if (why
== WHY_EXCEPTION
) {
2560 PyTraceBack_Here(f
);
2562 if (tstate
->c_tracefunc
!= NULL
)
2563 call_exc_trace(tstate
->c_tracefunc
,
2564 tstate
->c_traceobj
, f
);
2567 /* For the rest, treat WHY_RERAISE as WHY_EXCEPTION */
2569 if (why
== WHY_RERAISE
)
2570 why
= WHY_EXCEPTION
;
2572 /* Unwind stacks if a (pseudo) exception occurred */
2575 while (why
!= WHY_NOT
&& f
->f_iblock
> 0) {
2576 PyTryBlock
*b
= PyFrame_BlockPop(f
);
2578 assert(why
!= WHY_YIELD
);
2579 if (b
->b_type
== SETUP_LOOP
&& why
== WHY_CONTINUE
) {
2580 /* For a continue inside a try block,
2581 don't pop the block for the loop. */
2582 PyFrame_BlockSetup(f
, b
->b_type
, b
->b_handler
,
2585 JUMPTO(PyInt_AS_LONG(retval
));
2590 while (STACK_LEVEL() > b
->b_level
) {
2594 if (b
->b_type
== SETUP_LOOP
&& why
== WHY_BREAK
) {
2596 JUMPTO(b
->b_handler
);
2599 if (b
->b_type
== SETUP_FINALLY
||
2600 (b
->b_type
== SETUP_EXCEPT
&&
2601 why
== WHY_EXCEPTION
)) {
2602 if (why
== WHY_EXCEPTION
) {
2603 PyObject
*exc
, *val
, *tb
;
2604 PyErr_Fetch(&exc
, &val
, &tb
);
2609 /* Make the raw exception data
2610 available to the handler,
2611 so a program can emulate the
2612 Python main loop. Don't do
2613 this for 'finally'. */
2614 if (b
->b_type
== SETUP_EXCEPT
) {
2615 PyErr_NormalizeException(
2617 set_exc_info(tstate
,
2629 if (why
& (WHY_RETURN
| WHY_CONTINUE
))
2631 v
= PyInt_FromLong((long)why
);
2635 JUMPTO(b
->b_handler
);
2638 } /* unwind stack */
2640 /* End the loop if we still have an error (or return) */
2644 READ_TIMESTAMP(loop1
);
2648 assert(why
!= WHY_YIELD
);
2649 /* Pop remaining stack entries. */
2655 if (why
!= WHY_RETURN
)
2659 if (tstate
->use_tracing
) {
2660 if (tstate
->c_tracefunc
) {
2661 if (why
== WHY_RETURN
|| why
== WHY_YIELD
) {
2662 if (call_trace(tstate
->c_tracefunc
,
2663 tstate
->c_traceobj
, f
,
2664 PyTrace_RETURN
, retval
)) {
2667 why
= WHY_EXCEPTION
;
2670 else if (why
== WHY_EXCEPTION
) {
2671 call_trace_protected(tstate
->c_tracefunc
,
2672 tstate
->c_traceobj
, f
,
2673 PyTrace_RETURN
, NULL
);
2676 if (tstate
->c_profilefunc
) {
2677 if (why
== WHY_EXCEPTION
)
2678 call_trace_protected(tstate
->c_profilefunc
,
2679 tstate
->c_profileobj
, f
,
2680 PyTrace_RETURN
, NULL
);
2681 else if (call_trace(tstate
->c_profilefunc
,
2682 tstate
->c_profileobj
, f
,
2683 PyTrace_RETURN
, retval
)) {
2686 why
= WHY_EXCEPTION
;
2691 if (tstate
->frame
->f_exc_type
!= NULL
)
2692 reset_exc_info(tstate
);
2694 assert(tstate
->frame
->f_exc_value
== NULL
);
2695 assert(tstate
->frame
->f_exc_traceback
== NULL
);
2700 Py_LeaveRecursiveCall();
2701 tstate
->frame
= f
->f_back
;
2706 /* This is gonna seem *real weird*, but if you put some other code between
2707 PyEval_EvalFrame() and PyEval_EvalCodeEx() you will need to adjust
2708 the test in the if statements in Misc/gdbinit (pystack and pystackv). */
2711 PyEval_EvalCodeEx(PyCodeObject
*co
, PyObject
*globals
, PyObject
*locals
,
2712 PyObject
**args
, int argcount
, PyObject
**kws
, int kwcount
,
2713 PyObject
**defs
, int defcount
, PyObject
*closure
)
2715 register PyFrameObject
*f
;
2716 register PyObject
*retval
= NULL
;
2717 register PyObject
**fastlocals
, **freevars
;
2718 PyThreadState
*tstate
= PyThreadState_GET();
2721 if (globals
== NULL
) {
2722 PyErr_SetString(PyExc_SystemError
,
2723 "PyEval_EvalCodeEx: NULL globals");
2727 assert(tstate
!= NULL
);
2728 assert(globals
!= NULL
);
2729 f
= PyFrame_New(tstate
, co
, globals
, locals
);
2733 fastlocals
= f
->f_localsplus
;
2734 freevars
= f
->f_localsplus
+ co
->co_nlocals
;
2736 if (co
->co_argcount
> 0 ||
2737 co
->co_flags
& (CO_VARARGS
| CO_VARKEYWORDS
)) {
2740 PyObject
*kwdict
= NULL
;
2741 if (co
->co_flags
& CO_VARKEYWORDS
) {
2742 kwdict
= PyDict_New();
2745 i
= co
->co_argcount
;
2746 if (co
->co_flags
& CO_VARARGS
)
2748 SETLOCAL(i
, kwdict
);
2750 if (argcount
> co
->co_argcount
) {
2751 if (!(co
->co_flags
& CO_VARARGS
)) {
2752 PyErr_Format(PyExc_TypeError
,
2753 "%.200s() takes %s %d "
2754 "%sargument%s (%d given)",
2755 PyString_AsString(co
->co_name
),
2756 defcount
? "at most" : "exactly",
2758 kwcount
? "non-keyword " : "",
2759 co
->co_argcount
== 1 ? "" : "s",
2763 n
= co
->co_argcount
;
2765 for (i
= 0; i
< n
; i
++) {
2770 if (co
->co_flags
& CO_VARARGS
) {
2771 u
= PyTuple_New(argcount
- n
);
2774 SETLOCAL(co
->co_argcount
, u
);
2775 for (i
= n
; i
< argcount
; i
++) {
2778 PyTuple_SET_ITEM(u
, i
-n
, x
);
2781 for (i
= 0; i
< kwcount
; i
++) {
2782 PyObject
**co_varnames
;
2783 PyObject
*keyword
= kws
[2*i
];
2784 PyObject
*value
= kws
[2*i
+ 1];
2786 if (keyword
== NULL
|| !PyString_Check(keyword
)) {
2787 PyErr_Format(PyExc_TypeError
,
2788 "%.200s() keywords must be strings",
2789 PyString_AsString(co
->co_name
));
2792 /* Speed hack: do raw pointer compares. As names are
2793 normally interned this should almost always hit. */
2794 co_varnames
= PySequence_Fast_ITEMS(co
->co_varnames
);
2795 for (j
= 0; j
< co
->co_argcount
; j
++) {
2796 PyObject
*nm
= co_varnames
[j
];
2800 /* Slow fallback, just in case */
2801 for (j
= 0; j
< co
->co_argcount
; j
++) {
2802 PyObject
*nm
= co_varnames
[j
];
2803 int cmp
= PyObject_RichCompareBool(
2804 keyword
, nm
, Py_EQ
);
2810 /* Check errors from Compare */
2811 if (PyErr_Occurred())
2813 if (j
>= co
->co_argcount
) {
2814 if (kwdict
== NULL
) {
2815 PyErr_Format(PyExc_TypeError
,
2816 "%.200s() got an unexpected "
2817 "keyword argument '%.400s'",
2818 PyString_AsString(co
->co_name
),
2819 PyString_AsString(keyword
));
2822 PyDict_SetItem(kwdict
, keyword
, value
);
2826 if (GETLOCAL(j
) != NULL
) {
2827 PyErr_Format(PyExc_TypeError
,
2828 "%.200s() got multiple "
2829 "values for keyword "
2830 "argument '%.400s'",
2831 PyString_AsString(co
->co_name
),
2832 PyString_AsString(keyword
));
2838 if (argcount
< co
->co_argcount
) {
2839 int m
= co
->co_argcount
- defcount
;
2840 for (i
= argcount
; i
< m
; i
++) {
2841 if (GETLOCAL(i
) == NULL
) {
2842 PyErr_Format(PyExc_TypeError
,
2843 "%.200s() takes %s %d "
2844 "%sargument%s (%d given)",
2845 PyString_AsString(co
->co_name
),
2846 ((co
->co_flags
& CO_VARARGS
) ||
2847 defcount
) ? "at least"
2849 m
, kwcount
? "non-keyword " : "",
2850 m
== 1 ? "" : "s", i
);
2858 for (; i
< defcount
; i
++) {
2859 if (GETLOCAL(m
+i
) == NULL
) {
2860 PyObject
*def
= defs
[i
];
2868 if (argcount
> 0 || kwcount
> 0) {
2869 PyErr_Format(PyExc_TypeError
,
2870 "%.200s() takes no arguments (%d given)",
2871 PyString_AsString(co
->co_name
),
2872 argcount
+ kwcount
);
2876 /* Allocate and initialize storage for cell vars, and copy free
2877 vars into frame. This isn't too efficient right now. */
2878 if (PyTuple_GET_SIZE(co
->co_cellvars
)) {
2879 int i
, j
, nargs
, found
;
2880 char *cellname
, *argname
;
2883 nargs
= co
->co_argcount
;
2884 if (co
->co_flags
& CO_VARARGS
)
2886 if (co
->co_flags
& CO_VARKEYWORDS
)
2889 /* Initialize each cell var, taking into account
2890 cell vars that are initialized from arguments.
2892 Should arrange for the compiler to put cellvars
2893 that are arguments at the beginning of the cellvars
2894 list so that we can march over it more efficiently?
2896 for (i
= 0; i
< PyTuple_GET_SIZE(co
->co_cellvars
); ++i
) {
2897 cellname
= PyString_AS_STRING(
2898 PyTuple_GET_ITEM(co
->co_cellvars
, i
));
2900 for (j
= 0; j
< nargs
; j
++) {
2901 argname
= PyString_AS_STRING(
2902 PyTuple_GET_ITEM(co
->co_varnames
, j
));
2903 if (strcmp(cellname
, argname
) == 0) {
2904 c
= PyCell_New(GETLOCAL(j
));
2907 GETLOCAL(co
->co_nlocals
+ i
) = c
;
2913 c
= PyCell_New(NULL
);
2916 SETLOCAL(co
->co_nlocals
+ i
, c
);
2920 if (PyTuple_GET_SIZE(co
->co_freevars
)) {
2922 for (i
= 0; i
< PyTuple_GET_SIZE(co
->co_freevars
); ++i
) {
2923 PyObject
*o
= PyTuple_GET_ITEM(closure
, i
);
2925 freevars
[PyTuple_GET_SIZE(co
->co_cellvars
) + i
] = o
;
2929 if (co
->co_flags
& CO_GENERATOR
) {
2930 /* Don't need to keep the reference to f_back, it will be set
2931 * when the generator is resumed. */
2932 Py_XDECREF(f
->f_back
);
2935 PCALL(PCALL_GENERATOR
);
2937 /* Create a new generator that owns the ready to run frame
2938 * and return that as the value. */
2939 return PyGen_New(f
);
2942 retval
= PyEval_EvalFrameEx(f
,0);
2944 fail
: /* Jump here from prelude on failure */
2946 /* decref'ing the frame can cause __del__ methods to get invoked,
2947 which can call back into Python. While we're done with the
2948 current Python frame (f), the associated C stack is still in use,
2949 so recursion_depth must be boosted for the duration.
2951 assert(tstate
!= NULL
);
2952 ++tstate
->recursion_depth
;
2954 --tstate
->recursion_depth
;
2959 /* Implementation notes for set_exc_info() and reset_exc_info():
2961 - Below, 'exc_ZZZ' stands for 'exc_type', 'exc_value' and
2962 'exc_traceback'. These always travel together.
2964 - tstate->curexc_ZZZ is the "hot" exception that is set by
2965 PyErr_SetString(), cleared by PyErr_Clear(), and so on.
2967 - Once an exception is caught by an except clause, it is transferred
2968 from tstate->curexc_ZZZ to tstate->exc_ZZZ, from which sys.exc_info()
2969 can pick it up. This is the primary task of set_exc_info().
2970 XXX That can't be right: set_exc_info() doesn't look at tstate->curexc_ZZZ.
2972 - Now let me explain the complicated dance with frame->f_exc_ZZZ.
2974 Long ago, when none of this existed, there were just a few globals:
2975 one set corresponding to the "hot" exception, and one set
2976 corresponding to sys.exc_ZZZ. (Actually, the latter weren't C
2977 globals; they were simply stored as sys.exc_ZZZ. For backwards
2978 compatibility, they still are!) The problem was that in code like
2982 "something that may fail"
2983 except "some exception":
2984 "do something else first"
2985 "print the exception from sys.exc_ZZZ."
2987 if "do something else first" invoked something that raised and caught
2988 an exception, sys.exc_ZZZ were overwritten. That was a frequent
2989 cause of subtle bugs. I fixed this by changing the semantics as
2992 - Within one frame, sys.exc_ZZZ will hold the last exception caught
2995 - But initially, and as long as no exception is caught in a given
2996 frame, sys.exc_ZZZ will hold the last exception caught in the
2997 previous frame (or the frame before that, etc.).
2999 The first bullet fixed the bug in the above example. The second
3000 bullet was for backwards compatibility: it was (and is) common to
3001 have a function that is called when an exception is caught, and to
3002 have that function access the caught exception via sys.exc_ZZZ.
3003 (Example: traceback.print_exc()).
3005 At the same time I fixed the problem that sys.exc_ZZZ weren't
3006 thread-safe, by introducing sys.exc_info() which gets it from tstate;
3007 but that's really a separate improvement.
3009 The reset_exc_info() function in ceval.c restores the tstate->exc_ZZZ
3010 variables to what they were before the current frame was called. The
3011 set_exc_info() function saves them on the frame so that
3012 reset_exc_info() can restore them. The invariant is that
3013 frame->f_exc_ZZZ is NULL iff the current frame never caught an
3014 exception (where "catching" an exception applies only to successful
3015 except clauses); and if the current frame ever caught an exception,
3016 frame->f_exc_ZZZ is the exception that was stored in tstate->exc_ZZZ
3017 at the start of the current frame.
3022 set_exc_info(PyThreadState
*tstate
,
3023 PyObject
*type
, PyObject
*value
, PyObject
*tb
)
3025 PyFrameObject
*frame
= tstate
->frame
;
3026 PyObject
*tmp_type
, *tmp_value
, *tmp_tb
;
3028 assert(type
!= NULL
);
3029 assert(frame
!= NULL
);
3030 if (frame
->f_exc_type
== NULL
) {
3031 assert(frame
->f_exc_value
== NULL
);
3032 assert(frame
->f_exc_traceback
== NULL
);
3033 /* This frame didn't catch an exception before. */
3034 /* Save previous exception of this thread in this frame. */
3035 if (tstate
->exc_type
== NULL
) {
3036 /* XXX Why is this set to Py_None? */
3038 tstate
->exc_type
= Py_None
;
3040 Py_INCREF(tstate
->exc_type
);
3041 Py_XINCREF(tstate
->exc_value
);
3042 Py_XINCREF(tstate
->exc_traceback
);
3043 frame
->f_exc_type
= tstate
->exc_type
;
3044 frame
->f_exc_value
= tstate
->exc_value
;
3045 frame
->f_exc_traceback
= tstate
->exc_traceback
;
3047 /* Set new exception for this thread. */
3048 tmp_type
= tstate
->exc_type
;
3049 tmp_value
= tstate
->exc_value
;
3050 tmp_tb
= tstate
->exc_traceback
;
3054 tstate
->exc_type
= type
;
3055 tstate
->exc_value
= value
;
3056 tstate
->exc_traceback
= tb
;
3057 Py_XDECREF(tmp_type
);
3058 Py_XDECREF(tmp_value
);
3060 /* For b/w compatibility */
3061 PySys_SetObject("exc_type", type
);
3062 PySys_SetObject("exc_value", value
);
3063 PySys_SetObject("exc_traceback", tb
);
3067 reset_exc_info(PyThreadState
*tstate
)
3069 PyFrameObject
*frame
;
3070 PyObject
*tmp_type
, *tmp_value
, *tmp_tb
;
3072 /* It's a precondition that the thread state's frame caught an
3073 * exception -- verify in a debug build.
3075 assert(tstate
!= NULL
);
3076 frame
= tstate
->frame
;
3077 assert(frame
!= NULL
);
3078 assert(frame
->f_exc_type
!= NULL
);
3080 /* Copy the frame's exception info back to the thread state. */
3081 tmp_type
= tstate
->exc_type
;
3082 tmp_value
= tstate
->exc_value
;
3083 tmp_tb
= tstate
->exc_traceback
;
3084 Py_INCREF(frame
->f_exc_type
);
3085 Py_XINCREF(frame
->f_exc_value
);
3086 Py_XINCREF(frame
->f_exc_traceback
);
3087 tstate
->exc_type
= frame
->f_exc_type
;
3088 tstate
->exc_value
= frame
->f_exc_value
;
3089 tstate
->exc_traceback
= frame
->f_exc_traceback
;
3090 Py_XDECREF(tmp_type
);
3091 Py_XDECREF(tmp_value
);
3094 /* For b/w compatibility */
3095 PySys_SetObject("exc_type", frame
->f_exc_type
);
3096 PySys_SetObject("exc_value", frame
->f_exc_value
);
3097 PySys_SetObject("exc_traceback", frame
->f_exc_traceback
);
3099 /* Clear the frame's exception info. */
3100 tmp_type
= frame
->f_exc_type
;
3101 tmp_value
= frame
->f_exc_value
;
3102 tmp_tb
= frame
->f_exc_traceback
;
3103 frame
->f_exc_type
= NULL
;
3104 frame
->f_exc_value
= NULL
;
3105 frame
->f_exc_traceback
= NULL
;
3106 Py_DECREF(tmp_type
);
3107 Py_XDECREF(tmp_value
);
3111 /* Logic for the raise statement (too complicated for inlining).
3112 This *consumes* a reference count to each of its arguments. */
3113 static enum why_code
3114 do_raise(PyObject
*type
, PyObject
*value
, PyObject
*tb
)
3118 PyThreadState
*tstate
= PyThreadState_GET();
3119 type
= tstate
->exc_type
== NULL
? Py_None
: tstate
->exc_type
;
3120 value
= tstate
->exc_value
;
3121 tb
= tstate
->exc_traceback
;
3127 /* We support the following forms of raise:
3128 raise <class>, <classinstance>
3129 raise <class>, <argument tuple>
3131 raise <class>, <argument>
3132 raise <classinstance>, None
3133 raise <string>, <object>
3134 raise <string>, None
3136 An omitted second argument is the same as None.
3138 In addition, raise <tuple>, <anything> is the same as
3139 raising the tuple's first item (and it better have one!);
3140 this rule is applied recursively.
3142 Finally, an optional third argument can be supplied, which
3143 gives the traceback to be substituted (useful when
3144 re-raising an exception after examining it). */
3146 /* First, check the traceback argument, replacing None with
3148 if (tb
== Py_None
) {
3152 else if (tb
!= NULL
&& !PyTraceBack_Check(tb
)) {
3153 PyErr_SetString(PyExc_TypeError
,
3154 "raise: arg 3 must be a traceback or None");
3158 /* Next, replace a missing value with None */
3159 if (value
== NULL
) {
3164 /* Next, repeatedly, replace a tuple exception with its first item */
3165 while (PyTuple_Check(type
) && PyTuple_Size(type
) > 0) {
3166 PyObject
*tmp
= type
;
3167 type
= PyTuple_GET_ITEM(type
, 0);
3172 if (PyExceptionClass_Check(type
))
3173 PyErr_NormalizeException(&type
, &value
, &tb
);
3175 else if (PyExceptionInstance_Check(type
)) {
3176 /* Raising an instance. The value should be a dummy. */
3177 if (value
!= Py_None
) {
3178 PyErr_SetString(PyExc_TypeError
,
3179 "instance exception may not have a separate value");
3183 /* Normalize to raise <class>, <instance> */
3186 type
= PyExceptionInstance_Class(type
);
3191 /* Not something you can raise. You get an exception
3192 anyway, just not what you specified :-) */
3193 PyErr_Format(PyExc_TypeError
,
3194 "exceptions must be classes or instances, not %s",
3195 type
->ob_type
->tp_name
);
3199 assert(PyExceptionClass_Check(type
));
3200 if (Py_Py3kWarningFlag
&& PyClass_Check(type
)) {
3201 if (PyErr_WarnEx(PyExc_DeprecationWarning
,
3202 "exceptions must derive from BaseException "
3207 PyErr_Restore(type
, value
, tb
);
3209 return WHY_EXCEPTION
;
3216 return WHY_EXCEPTION
;
3219 /* Iterate v argcnt times and store the results on the stack (via decreasing
3220 sp). Return 1 for success, 0 if error. */
3223 unpack_iterable(PyObject
*v
, int argcnt
, PyObject
**sp
)
3226 PyObject
*it
; /* iter(v) */
3231 it
= PyObject_GetIter(v
);
3235 for (; i
< argcnt
; i
++) {
3236 w
= PyIter_Next(it
);
3238 /* Iterator done, via error or exhaustion. */
3239 if (!PyErr_Occurred()) {
3240 PyErr_Format(PyExc_ValueError
,
3241 "need more than %d value%s to unpack",
3242 i
, i
== 1 ? "" : "s");
3249 /* We better have exhausted the iterator now. */
3250 w
= PyIter_Next(it
);
3252 if (PyErr_Occurred())
3258 PyErr_SetString(PyExc_ValueError
, "too many values to unpack");
3261 for (; i
> 0; i
--, sp
++)
3270 prtrace(PyObject
*v
, char *str
)
3273 if (PyObject_Print(v
, stdout
, 0) != 0)
3274 PyErr_Clear(); /* Don't know what else to do */
3281 call_exc_trace(Py_tracefunc func
, PyObject
*self
, PyFrameObject
*f
)
3283 PyObject
*type
, *value
, *traceback
, *arg
;
3285 PyErr_Fetch(&type
, &value
, &traceback
);
3286 if (value
== NULL
) {
3290 arg
= PyTuple_Pack(3, type
, value
, traceback
);
3292 PyErr_Restore(type
, value
, traceback
);
3295 err
= call_trace(func
, self
, f
, PyTrace_EXCEPTION
, arg
);
3298 PyErr_Restore(type
, value
, traceback
);
3302 Py_XDECREF(traceback
);
3307 call_trace_protected(Py_tracefunc func
, PyObject
*obj
, PyFrameObject
*frame
,
3308 int what
, PyObject
*arg
)
3310 PyObject
*type
, *value
, *traceback
;
3312 PyErr_Fetch(&type
, &value
, &traceback
);
3313 err
= call_trace(func
, obj
, frame
, what
, arg
);
3316 PyErr_Restore(type
, value
, traceback
);
3322 Py_XDECREF(traceback
);
3328 call_trace(Py_tracefunc func
, PyObject
*obj
, PyFrameObject
*frame
,
3329 int what
, PyObject
*arg
)
3331 register PyThreadState
*tstate
= frame
->f_tstate
;
3333 if (tstate
->tracing
)
3336 tstate
->use_tracing
= 0;
3337 result
= func(obj
, frame
, what
, arg
);
3338 tstate
->use_tracing
= ((tstate
->c_tracefunc
!= NULL
)
3339 || (tstate
->c_profilefunc
!= NULL
));
3345 _PyEval_CallTracing(PyObject
*func
, PyObject
*args
)
3347 PyFrameObject
*frame
= PyEval_GetFrame();
3348 PyThreadState
*tstate
= frame
->f_tstate
;
3349 int save_tracing
= tstate
->tracing
;
3350 int save_use_tracing
= tstate
->use_tracing
;
3353 tstate
->tracing
= 0;
3354 tstate
->use_tracing
= ((tstate
->c_tracefunc
!= NULL
)
3355 || (tstate
->c_profilefunc
!= NULL
));
3356 result
= PyObject_Call(func
, args
, NULL
);
3357 tstate
->tracing
= save_tracing
;
3358 tstate
->use_tracing
= save_use_tracing
;
3363 maybe_call_line_trace(Py_tracefunc func
, PyObject
*obj
,
3364 PyFrameObject
*frame
, int *instr_lb
, int *instr_ub
,
3369 /* If the last instruction executed isn't in the current
3370 instruction window, reset the window. If the last
3371 instruction happens to fall at the start of a line or if it
3372 represents a jump backwards, call the trace function.
3374 if ((frame
->f_lasti
< *instr_lb
|| frame
->f_lasti
>= *instr_ub
)) {
3378 line
= PyCode_CheckLineNumber(frame
->f_code
, frame
->f_lasti
,
3381 frame
->f_lineno
= line
;
3382 result
= call_trace(func
, obj
, frame
,
3383 PyTrace_LINE
, Py_None
);
3385 *instr_lb
= bounds
.ap_lower
;
3386 *instr_ub
= bounds
.ap_upper
;
3388 else if (frame
->f_lasti
<= *instr_prev
) {
3389 result
= call_trace(func
, obj
, frame
, PyTrace_LINE
, Py_None
);
3391 *instr_prev
= frame
->f_lasti
;
3396 PyEval_SetProfile(Py_tracefunc func
, PyObject
*arg
)
3398 PyThreadState
*tstate
= PyThreadState_GET();
3399 PyObject
*temp
= tstate
->c_profileobj
;
3401 tstate
->c_profilefunc
= NULL
;
3402 tstate
->c_profileobj
= NULL
;
3403 /* Must make sure that tracing is not ignored if 'temp' is freed */
3404 tstate
->use_tracing
= tstate
->c_tracefunc
!= NULL
;
3406 tstate
->c_profilefunc
= func
;
3407 tstate
->c_profileobj
= arg
;
3408 /* Flag that tracing or profiling is turned on */
3409 tstate
->use_tracing
= (func
!= NULL
) || (tstate
->c_tracefunc
!= NULL
);
3413 PyEval_SetTrace(Py_tracefunc func
, PyObject
*arg
)
3415 PyThreadState
*tstate
= PyThreadState_GET();
3416 PyObject
*temp
= tstate
->c_traceobj
;
3418 tstate
->c_tracefunc
= NULL
;
3419 tstate
->c_traceobj
= NULL
;
3420 /* Must make sure that profiling is not ignored if 'temp' is freed */
3421 tstate
->use_tracing
= tstate
->c_profilefunc
!= NULL
;
3423 tstate
->c_tracefunc
= func
;
3424 tstate
->c_traceobj
= arg
;
3425 /* Flag that tracing or profiling is turned on */
3426 tstate
->use_tracing
= ((func
!= NULL
)
3427 || (tstate
->c_profilefunc
!= NULL
));
3431 PyEval_GetBuiltins(void)
3433 PyFrameObject
*current_frame
= PyEval_GetFrame();
3434 if (current_frame
== NULL
)
3435 return PyThreadState_GET()->interp
->builtins
;
3437 return current_frame
->f_builtins
;
3441 PyEval_GetLocals(void)
3443 PyFrameObject
*current_frame
= PyEval_GetFrame();
3444 if (current_frame
== NULL
)
3446 PyFrame_FastToLocals(current_frame
);
3447 return current_frame
->f_locals
;
3451 PyEval_GetGlobals(void)
3453 PyFrameObject
*current_frame
= PyEval_GetFrame();
3454 if (current_frame
== NULL
)
3457 return current_frame
->f_globals
;
3461 PyEval_GetFrame(void)
3463 PyThreadState
*tstate
= PyThreadState_GET();
3464 return _PyThreadState_GetFrame(tstate
);
3468 PyEval_GetRestricted(void)
3470 PyFrameObject
*current_frame
= PyEval_GetFrame();
3471 return current_frame
== NULL
? 0 : PyFrame_IsRestricted(current_frame
);
3475 PyEval_MergeCompilerFlags(PyCompilerFlags
*cf
)
3477 PyFrameObject
*current_frame
= PyEval_GetFrame();
3478 int result
= cf
->cf_flags
!= 0;
3480 if (current_frame
!= NULL
) {
3481 const int codeflags
= current_frame
->f_code
->co_flags
;
3482 const int compilerflags
= codeflags
& PyCF_MASK
;
3483 if (compilerflags
) {
3485 cf
->cf_flags
|= compilerflags
;
3487 #if 0 /* future keyword */
3488 if (codeflags
& CO_GENERATOR_ALLOWED
) {
3490 cf
->cf_flags
|= CO_GENERATOR_ALLOWED
;
3500 PyObject
*f
= PySys_GetObject("stdout");
3503 if (!PyFile_SoftSpace(f
, 0))
3505 return PyFile_WriteString("\n", f
);
3509 /* External interface to call any callable object.
3510 The arg must be a tuple or NULL. */
3512 #undef PyEval_CallObject
3513 /* for backward compatibility: export this interface */
3516 PyEval_CallObject(PyObject
*func
, PyObject
*arg
)
3518 return PyEval_CallObjectWithKeywords(func
, arg
, (PyObject
*)NULL
);
3520 #define PyEval_CallObject(func,arg) \
3521 PyEval_CallObjectWithKeywords(func, arg, (PyObject *)NULL)
3524 PyEval_CallObjectWithKeywords(PyObject
*func
, PyObject
*arg
, PyObject
*kw
)
3529 arg
= PyTuple_New(0);
3533 else if (!PyTuple_Check(arg
)) {
3534 PyErr_SetString(PyExc_TypeError
,
3535 "argument list must be a tuple");
3541 if (kw
!= NULL
&& !PyDict_Check(kw
)) {
3542 PyErr_SetString(PyExc_TypeError
,
3543 "keyword list must be a dictionary");
3548 result
= PyObject_Call(func
, arg
, kw
);
3554 PyEval_GetFuncName(PyObject
*func
)
3556 if (PyMethod_Check(func
))
3557 return PyEval_GetFuncName(PyMethod_GET_FUNCTION(func
));
3558 else if (PyFunction_Check(func
))
3559 return PyString_AsString(((PyFunctionObject
*)func
)->func_name
);
3560 else if (PyCFunction_Check(func
))
3561 return ((PyCFunctionObject
*)func
)->m_ml
->ml_name
;
3562 else if (PyClass_Check(func
))
3563 return PyString_AsString(((PyClassObject
*)func
)->cl_name
);
3564 else if (PyInstance_Check(func
)) {
3565 return PyString_AsString(
3566 ((PyInstanceObject
*)func
)->in_class
->cl_name
);
3568 return func
->ob_type
->tp_name
;
3573 PyEval_GetFuncDesc(PyObject
*func
)
3575 if (PyMethod_Check(func
))
3577 else if (PyFunction_Check(func
))
3579 else if (PyCFunction_Check(func
))
3581 else if (PyClass_Check(func
))
3582 return " constructor";
3583 else if (PyInstance_Check(func
)) {
3591 err_args(PyObject
*func
, int flags
, int nargs
)
3593 if (flags
& METH_NOARGS
)
3594 PyErr_Format(PyExc_TypeError
,
3595 "%.200s() takes no arguments (%d given)",
3596 ((PyCFunctionObject
*)func
)->m_ml
->ml_name
,
3599 PyErr_Format(PyExc_TypeError
,
3600 "%.200s() takes exactly one argument (%d given)",
3601 ((PyCFunctionObject
*)func
)->m_ml
->ml_name
,
3605 #define C_TRACE(x, call) \
3606 if (tstate->use_tracing && tstate->c_profilefunc) { \
3607 if (call_trace(tstate->c_profilefunc, \
3608 tstate->c_profileobj, \
3609 tstate->frame, PyTrace_C_CALL, \
3615 if (tstate->c_profilefunc != NULL) { \
3617 call_trace_protected(tstate->c_profilefunc, \
3618 tstate->c_profileobj, \
3619 tstate->frame, PyTrace_C_EXCEPTION, \
3621 /* XXX should pass (type, value, tb) */ \
3623 if (call_trace(tstate->c_profilefunc, \
3624 tstate->c_profileobj, \
3625 tstate->frame, PyTrace_C_RETURN, \
3638 call_function(PyObject
***pp_stack
, int oparg
3640 , uint64
* pintr0
, uint64
* pintr1
3644 int na
= oparg
& 0xff;
3645 int nk
= (oparg
>>8) & 0xff;
3646 int n
= na
+ 2 * nk
;
3647 PyObject
**pfunc
= (*pp_stack
) - n
- 1;
3648 PyObject
*func
= *pfunc
;
3651 /* Always dispatch PyCFunction first, because these are
3652 presumed to be the most frequent callable object.
3654 if (PyCFunction_Check(func
) && nk
== 0) {
3655 int flags
= PyCFunction_GET_FLAGS(func
);
3656 PyThreadState
*tstate
= PyThreadState_GET();
3658 PCALL(PCALL_CFUNCTION
);
3659 if (flags
& (METH_NOARGS
| METH_O
)) {
3660 PyCFunction meth
= PyCFunction_GET_FUNCTION(func
);
3661 PyObject
*self
= PyCFunction_GET_SELF(func
);
3662 if (flags
& METH_NOARGS
&& na
== 0) {
3663 C_TRACE(x
, (*meth
)(self
,NULL
));
3665 else if (flags
& METH_O
&& na
== 1) {
3666 PyObject
*arg
= EXT_POP(*pp_stack
);
3667 C_TRACE(x
, (*meth
)(self
,arg
));
3671 err_args(func
, flags
, na
);
3677 callargs
= load_args(pp_stack
, na
);
3678 READ_TIMESTAMP(*pintr0
);
3679 C_TRACE(x
, PyCFunction_Call(func
,callargs
,NULL
));
3680 READ_TIMESTAMP(*pintr1
);
3681 Py_XDECREF(callargs
);
3684 if (PyMethod_Check(func
) && PyMethod_GET_SELF(func
) != NULL
) {
3685 /* optimize access to bound methods */
3686 PyObject
*self
= PyMethod_GET_SELF(func
);
3687 PCALL(PCALL_METHOD
);
3688 PCALL(PCALL_BOUND_METHOD
);
3690 func
= PyMethod_GET_FUNCTION(func
);
3698 READ_TIMESTAMP(*pintr0
);
3699 if (PyFunction_Check(func
))
3700 x
= fast_function(func
, pp_stack
, n
, na
, nk
);
3702 x
= do_call(func
, pp_stack
, na
, nk
);
3703 READ_TIMESTAMP(*pintr1
);
3707 /* Clear the stack of the function object. Also removes
3708 the arguments in case they weren't consumed already
3709 (fast_function() and err_args() leave them on the stack).
3711 while ((*pp_stack
) > pfunc
) {
3712 w
= EXT_POP(*pp_stack
);
3719 /* The fast_function() function optimize calls for which no argument
3720 tuple is necessary; the objects are passed directly from the stack.
3721 For the simplest case -- a function that takes only positional
3722 arguments and is called with only positional arguments -- it
3723 inlines the most primitive frame setup code from
3724 PyEval_EvalCodeEx(), which vastly reduces the checks that must be
3725 done before evaluating the frame.
3729 fast_function(PyObject
*func
, PyObject
***pp_stack
, int n
, int na
, int nk
)
3731 PyCodeObject
*co
= (PyCodeObject
*)PyFunction_GET_CODE(func
);
3732 PyObject
*globals
= PyFunction_GET_GLOBALS(func
);
3733 PyObject
*argdefs
= PyFunction_GET_DEFAULTS(func
);
3734 PyObject
**d
= NULL
;
3737 PCALL(PCALL_FUNCTION
);
3738 PCALL(PCALL_FAST_FUNCTION
);
3739 if (argdefs
== NULL
&& co
->co_argcount
== n
&& nk
==0 &&
3740 co
->co_flags
== (CO_OPTIMIZED
| CO_NEWLOCALS
| CO_NOFREE
)) {
3742 PyObject
*retval
= NULL
;
3743 PyThreadState
*tstate
= PyThreadState_GET();
3744 PyObject
**fastlocals
, **stack
;
3747 PCALL(PCALL_FASTER_FUNCTION
);
3748 assert(globals
!= NULL
);
3749 /* XXX Perhaps we should create a specialized
3750 PyFrame_New() that doesn't take locals, but does
3751 take builtins without sanity checking them.
3753 assert(tstate
!= NULL
);
3754 f
= PyFrame_New(tstate
, co
, globals
, NULL
);
3758 fastlocals
= f
->f_localsplus
;
3759 stack
= (*pp_stack
) - n
;
3761 for (i
= 0; i
< n
; i
++) {
3763 fastlocals
[i
] = *stack
++;
3765 retval
= PyEval_EvalFrameEx(f
,0);
3766 ++tstate
->recursion_depth
;
3768 --tstate
->recursion_depth
;
3771 if (argdefs
!= NULL
) {
3772 d
= &PyTuple_GET_ITEM(argdefs
, 0);
3773 nd
= Py_SIZE(argdefs
);
3775 return PyEval_EvalCodeEx(co
, globals
,
3776 (PyObject
*)NULL
, (*pp_stack
)-n
, na
,
3777 (*pp_stack
)-2*nk
, nk
, d
, nd
,
3778 PyFunction_GET_CLOSURE(func
));
3782 update_keyword_args(PyObject
*orig_kwdict
, int nk
, PyObject
***pp_stack
,
3785 PyObject
*kwdict
= NULL
;
3786 if (orig_kwdict
== NULL
)
3787 kwdict
= PyDict_New();
3789 kwdict
= PyDict_Copy(orig_kwdict
);
3790 Py_DECREF(orig_kwdict
);
3796 PyObject
*value
= EXT_POP(*pp_stack
);
3797 PyObject
*key
= EXT_POP(*pp_stack
);
3798 if (PyDict_GetItem(kwdict
, key
) != NULL
) {
3799 PyErr_Format(PyExc_TypeError
,
3800 "%.200s%s got multiple values "
3801 "for keyword argument '%.200s'",
3802 PyEval_GetFuncName(func
),
3803 PyEval_GetFuncDesc(func
),
3804 PyString_AsString(key
));
3810 err
= PyDict_SetItem(kwdict
, key
, value
);
3822 update_star_args(int nstack
, int nstar
, PyObject
*stararg
,
3823 PyObject
***pp_stack
)
3825 PyObject
*callargs
, *w
;
3827 callargs
= PyTuple_New(nstack
+ nstar
);
3828 if (callargs
== NULL
) {
3833 for (i
= 0; i
< nstar
; i
++) {
3834 PyObject
*a
= PyTuple_GET_ITEM(stararg
, i
);
3836 PyTuple_SET_ITEM(callargs
, nstack
+ i
, a
);
3839 while (--nstack
>= 0) {
3840 w
= EXT_POP(*pp_stack
);
3841 PyTuple_SET_ITEM(callargs
, nstack
, w
);
3847 load_args(PyObject
***pp_stack
, int na
)
3849 PyObject
*args
= PyTuple_New(na
);
3855 w
= EXT_POP(*pp_stack
);
3856 PyTuple_SET_ITEM(args
, na
, w
);
3862 do_call(PyObject
*func
, PyObject
***pp_stack
, int na
, int nk
)
3864 PyObject
*callargs
= NULL
;
3865 PyObject
*kwdict
= NULL
;
3866 PyObject
*result
= NULL
;
3869 kwdict
= update_keyword_args(NULL
, nk
, pp_stack
, func
);
3873 callargs
= load_args(pp_stack
, na
);
3874 if (callargs
== NULL
)
3877 /* At this point, we have to look at the type of func to
3878 update the call stats properly. Do it here so as to avoid
3879 exposing the call stats machinery outside ceval.c
3881 if (PyFunction_Check(func
))
3882 PCALL(PCALL_FUNCTION
);
3883 else if (PyMethod_Check(func
))
3884 PCALL(PCALL_METHOD
);
3885 else if (PyType_Check(func
))
3890 result
= PyObject_Call(func
, callargs
, kwdict
);
3892 Py_XDECREF(callargs
);
3898 ext_do_call(PyObject
*func
, PyObject
***pp_stack
, int flags
, int na
, int nk
)
3901 PyObject
*callargs
= NULL
;
3902 PyObject
*stararg
= NULL
;
3903 PyObject
*kwdict
= NULL
;
3904 PyObject
*result
= NULL
;
3906 if (flags
& CALL_FLAG_KW
) {
3907 kwdict
= EXT_POP(*pp_stack
);
3908 if (!PyDict_Check(kwdict
)) {
3913 if (PyDict_Update(d
, kwdict
) != 0) {
3915 /* PyDict_Update raises attribute
3916 * error (percolated from an attempt
3917 * to get 'keys' attribute) instead of
3918 * a type error if its second argument
3921 if (PyErr_ExceptionMatches(PyExc_AttributeError
)) {
3922 PyErr_Format(PyExc_TypeError
,
3923 "%.200s%.200s argument after ** "
3924 "must be a mapping, not %.200s",
3925 PyEval_GetFuncName(func
),
3926 PyEval_GetFuncDesc(func
),
3927 kwdict
->ob_type
->tp_name
);
3935 if (flags
& CALL_FLAG_VAR
) {
3936 stararg
= EXT_POP(*pp_stack
);
3937 if (!PyTuple_Check(stararg
)) {
3939 t
= PySequence_Tuple(stararg
);
3941 if (PyErr_ExceptionMatches(PyExc_TypeError
)) {
3942 PyErr_Format(PyExc_TypeError
,
3943 "%.200s%.200s argument after * "
3944 "must be a sequence, not %200s",
3945 PyEval_GetFuncName(func
),
3946 PyEval_GetFuncDesc(func
),
3947 stararg
->ob_type
->tp_name
);
3954 nstar
= PyTuple_GET_SIZE(stararg
);
3957 kwdict
= update_keyword_args(kwdict
, nk
, pp_stack
, func
);
3961 callargs
= update_star_args(na
, nstar
, stararg
, pp_stack
);
3962 if (callargs
== NULL
)
3965 /* At this point, we have to look at the type of func to
3966 update the call stats properly. Do it here so as to avoid
3967 exposing the call stats machinery outside ceval.c
3969 if (PyFunction_Check(func
))
3970 PCALL(PCALL_FUNCTION
);
3971 else if (PyMethod_Check(func
))
3972 PCALL(PCALL_METHOD
);
3973 else if (PyType_Check(func
))
3978 result
= PyObject_Call(func
, callargs
, kwdict
);
3980 Py_XDECREF(callargs
);
3982 Py_XDECREF(stararg
);
3986 /* Extract a slice index from a PyInt or PyLong or an object with the
3987 nb_index slot defined, and store in *pi.
3988 Silently reduce values larger than PY_SSIZE_T_MAX to PY_SSIZE_T_MAX,
3989 and silently boost values less than -PY_SSIZE_T_MAX-1 to -PY_SSIZE_T_MAX-1.
3990 Return 0 on error, 1 on success.
3992 /* Note: If v is NULL, return success without storing into *pi. This
3993 is because_PyEval_SliceIndex() is called by apply_slice(), which can be
3994 called by the SLICE opcode with v and/or w equal to NULL.
3997 _PyEval_SliceIndex(PyObject
*v
, Py_ssize_t
*pi
)
4001 if (PyInt_Check(v
)) {
4002 /* XXX(nnorwitz): I think PyInt_AS_LONG is correct,
4003 however, it looks like it should be AsSsize_t.
4004 There should be a comment here explaining why.
4006 x
= PyInt_AS_LONG(v
);
4008 else if (PyIndex_Check(v
)) {
4009 x
= PyNumber_AsSsize_t(v
, NULL
);
4010 if (x
== -1 && PyErr_Occurred())
4014 PyErr_SetString(PyExc_TypeError
,
4015 "slice indices must be integers or "
4016 "None or have an __index__ method");
4025 #define ISINDEX(x) ((x) == NULL || \
4026 PyInt_Check(x) || PyLong_Check(x) || PyIndex_Check(x))
4029 apply_slice(PyObject
*u
, PyObject
*v
, PyObject
*w
) /* return u[v:w] */
4031 PyTypeObject
*tp
= u
->ob_type
;
4032 PySequenceMethods
*sq
= tp
->tp_as_sequence
;
4034 if (sq
&& sq
->sq_slice
&& ISINDEX(v
) && ISINDEX(w
)) {
4035 Py_ssize_t ilow
= 0, ihigh
= PY_SSIZE_T_MAX
;
4036 if (!_PyEval_SliceIndex(v
, &ilow
))
4038 if (!_PyEval_SliceIndex(w
, &ihigh
))
4040 return PySequence_GetSlice(u
, ilow
, ihigh
);
4043 PyObject
*slice
= PySlice_New(v
, w
, NULL
);
4044 if (slice
!= NULL
) {
4045 PyObject
*res
= PyObject_GetItem(u
, slice
);
4055 assign_slice(PyObject
*u
, PyObject
*v
, PyObject
*w
, PyObject
*x
)
4058 PyTypeObject
*tp
= u
->ob_type
;
4059 PySequenceMethods
*sq
= tp
->tp_as_sequence
;
4061 if (sq
&& sq
->sq_ass_slice
&& ISINDEX(v
) && ISINDEX(w
)) {
4062 Py_ssize_t ilow
= 0, ihigh
= PY_SSIZE_T_MAX
;
4063 if (!_PyEval_SliceIndex(v
, &ilow
))
4065 if (!_PyEval_SliceIndex(w
, &ihigh
))
4068 return PySequence_DelSlice(u
, ilow
, ihigh
);
4070 return PySequence_SetSlice(u
, ilow
, ihigh
, x
);
4073 PyObject
*slice
= PySlice_New(v
, w
, NULL
);
4074 if (slice
!= NULL
) {
4077 res
= PyObject_SetItem(u
, slice
, x
);
4079 res
= PyObject_DelItem(u
, slice
);
4088 #define Py3kExceptionClass_Check(x) \
4089 (PyType_Check((x)) && \
4090 PyType_FastSubclass((PyTypeObject*)(x), Py_TPFLAGS_BASE_EXC_SUBCLASS))
4092 #define CANNOT_CATCH_MSG "catching classes that don't inherit from " \
4093 "BaseException is not allowed in 3.x"
4096 cmp_outcome(int op
, register PyObject
*v
, register PyObject
*w
)
4107 res
= PySequence_Contains(w
, v
);
4112 res
= PySequence_Contains(w
, v
);
4117 case PyCmp_EXC_MATCH
:
4118 if (PyTuple_Check(w
)) {
4119 Py_ssize_t i
, length
;
4120 length
= PyTuple_Size(w
);
4121 for (i
= 0; i
< length
; i
+= 1) {
4122 PyObject
*exc
= PyTuple_GET_ITEM(w
, i
);
4123 if (PyString_Check(exc
)) {
4125 ret_val
= PyErr_WarnEx(
4126 PyExc_DeprecationWarning
,
4127 "catching of string "
4128 "exceptions is deprecated", 1);
4132 else if (Py_Py3kWarningFlag
&&
4133 !PyTuple_Check(exc
) &&
4134 !Py3kExceptionClass_Check(exc
))
4137 ret_val
= PyErr_WarnEx(
4138 PyExc_DeprecationWarning
,
4139 CANNOT_CATCH_MSG
, 1);
4146 if (PyString_Check(w
)) {
4148 ret_val
= PyErr_WarnEx(
4149 PyExc_DeprecationWarning
,
4150 "catching of string "
4151 "exceptions is deprecated", 1);
4155 else if (Py_Py3kWarningFlag
&&
4156 !PyTuple_Check(w
) &&
4157 !Py3kExceptionClass_Check(w
))
4160 ret_val
= PyErr_WarnEx(
4161 PyExc_DeprecationWarning
,
4162 CANNOT_CATCH_MSG
, 1);
4167 res
= PyErr_GivenExceptionMatches(v
, w
);
4170 return PyObject_RichCompare(v
, w
, op
);
4172 v
= res
? Py_True
: Py_False
;
4178 import_from(PyObject
*v
, PyObject
*name
)
4182 x
= PyObject_GetAttr(v
, name
);
4183 if (x
== NULL
&& PyErr_ExceptionMatches(PyExc_AttributeError
)) {
4184 PyErr_Format(PyExc_ImportError
,
4185 "cannot import name %.230s",
4186 PyString_AsString(name
));
4192 import_all_from(PyObject
*locals
, PyObject
*v
)
4194 PyObject
*all
= PyObject_GetAttrString(v
, "__all__");
4195 PyObject
*dict
, *name
, *value
;
4196 int skip_leading_underscores
= 0;
4200 if (!PyErr_ExceptionMatches(PyExc_AttributeError
))
4201 return -1; /* Unexpected error */
4203 dict
= PyObject_GetAttrString(v
, "__dict__");
4205 if (!PyErr_ExceptionMatches(PyExc_AttributeError
))
4207 PyErr_SetString(PyExc_ImportError
,
4208 "from-import-* object has no __dict__ and no __all__");
4211 all
= PyMapping_Keys(dict
);
4215 skip_leading_underscores
= 1;
4218 for (pos
= 0, err
= 0; ; pos
++) {
4219 name
= PySequence_GetItem(all
, pos
);
4221 if (!PyErr_ExceptionMatches(PyExc_IndexError
))
4227 if (skip_leading_underscores
&&
4228 PyString_Check(name
) &&
4229 PyString_AS_STRING(name
)[0] == '_')
4234 value
= PyObject_GetAttr(v
, name
);
4237 else if (PyDict_CheckExact(locals
))
4238 err
= PyDict_SetItem(locals
, name
, value
);
4240 err
= PyObject_SetItem(locals
, name
, value
);
4251 build_class(PyObject
*methods
, PyObject
*bases
, PyObject
*name
)
4253 PyObject
*metaclass
= NULL
, *result
, *base
;
4255 if (PyDict_Check(methods
))
4256 metaclass
= PyDict_GetItemString(methods
, "__metaclass__");
4257 if (metaclass
!= NULL
)
4258 Py_INCREF(metaclass
);
4259 else if (PyTuple_Check(bases
) && PyTuple_GET_SIZE(bases
) > 0) {
4260 base
= PyTuple_GET_ITEM(bases
, 0);
4261 metaclass
= PyObject_GetAttrString(base
, "__class__");
4262 if (metaclass
== NULL
) {
4264 metaclass
= (PyObject
*)base
->ob_type
;
4265 Py_INCREF(metaclass
);
4269 PyObject
*g
= PyEval_GetGlobals();
4270 if (g
!= NULL
&& PyDict_Check(g
))
4271 metaclass
= PyDict_GetItemString(g
, "__metaclass__");
4272 if (metaclass
== NULL
)
4273 metaclass
= (PyObject
*) &PyClass_Type
;
4274 Py_INCREF(metaclass
);
4276 result
= PyObject_CallFunctionObjArgs(metaclass
, name
, bases
, methods
,
4278 Py_DECREF(metaclass
);
4279 if (result
== NULL
&& PyErr_ExceptionMatches(PyExc_TypeError
)) {
4280 /* A type error here likely means that the user passed
4281 in a base that was not a class (such the random module
4282 instead of the random.random type). Help them out with
4283 by augmenting the error message with more information.*/
4285 PyObject
*ptype
, *pvalue
, *ptraceback
;
4287 PyErr_Fetch(&ptype
, &pvalue
, &ptraceback
);
4288 if (PyString_Check(pvalue
)) {
4290 newmsg
= PyString_FromFormat(
4291 "Error when calling the metaclass bases\n"
4293 PyString_AS_STRING(pvalue
));
4294 if (newmsg
!= NULL
) {
4299 PyErr_Restore(ptype
, pvalue
, ptraceback
);
4305 exec_statement(PyFrameObject
*f
, PyObject
*prog
, PyObject
*globals
,
4312 if (PyTuple_Check(prog
) && globals
== Py_None
&& locals
== Py_None
&&
4313 ((n
= PyTuple_Size(prog
)) == 2 || n
== 3)) {
4314 /* Backward compatibility hack */
4315 globals
= PyTuple_GetItem(prog
, 1);
4317 locals
= PyTuple_GetItem(prog
, 2);
4318 prog
= PyTuple_GetItem(prog
, 0);
4320 if (globals
== Py_None
) {
4321 globals
= PyEval_GetGlobals();
4322 if (locals
== Py_None
) {
4323 locals
= PyEval_GetLocals();
4326 if (!globals
|| !locals
) {
4327 PyErr_SetString(PyExc_SystemError
,
4328 "globals and locals cannot be NULL");
4332 else if (locals
== Py_None
)
4334 if (!PyString_Check(prog
) &&
4335 !PyUnicode_Check(prog
) &&
4336 !PyCode_Check(prog
) &&
4337 !PyFile_Check(prog
)) {
4338 PyErr_SetString(PyExc_TypeError
,
4339 "exec: arg 1 must be a string, file, or code object");
4342 if (!PyDict_Check(globals
)) {
4343 PyErr_SetString(PyExc_TypeError
,
4344 "exec: arg 2 must be a dictionary or None");
4347 if (!PyMapping_Check(locals
)) {
4348 PyErr_SetString(PyExc_TypeError
,
4349 "exec: arg 3 must be a mapping or None");
4352 if (PyDict_GetItemString(globals
, "__builtins__") == NULL
)
4353 PyDict_SetItemString(globals
, "__builtins__", f
->f_builtins
);
4354 if (PyCode_Check(prog
)) {
4355 if (PyCode_GetNumFree((PyCodeObject
*)prog
) > 0) {
4356 PyErr_SetString(PyExc_TypeError
,
4357 "code object passed to exec may not contain free variables");
4360 v
= PyEval_EvalCode((PyCodeObject
*) prog
, globals
, locals
);
4362 else if (PyFile_Check(prog
)) {
4363 FILE *fp
= PyFile_AsFile(prog
);
4364 char *name
= PyString_AsString(PyFile_Name(prog
));
4369 if (PyEval_MergeCompilerFlags(&cf
))
4370 v
= PyRun_FileFlags(fp
, name
, Py_file_input
, globals
,
4373 v
= PyRun_File(fp
, name
, Py_file_input
, globals
,
4377 PyObject
*tmp
= NULL
;
4381 #ifdef Py_USING_UNICODE
4382 if (PyUnicode_Check(prog
)) {
4383 tmp
= PyUnicode_AsUTF8String(prog
);
4387 cf
.cf_flags
|= PyCF_SOURCE_IS_UTF8
;
4390 if (PyString_AsStringAndSize(prog
, &str
, NULL
))
4392 if (PyEval_MergeCompilerFlags(&cf
))
4393 v
= PyRun_StringFlags(str
, Py_file_input
, globals
,
4396 v
= PyRun_String(str
, Py_file_input
, globals
, locals
);
4400 PyFrame_LocalsToFast(f
, 0);
4408 format_exc_check_arg(PyObject
*exc
, char *format_str
, PyObject
*obj
)
4415 obj_str
= PyString_AsString(obj
);
4419 PyErr_Format(exc
, format_str
, obj_str
);
4423 string_concatenate(PyObject
*v
, PyObject
*w
,
4424 PyFrameObject
*f
, unsigned char *next_instr
)
4426 /* This function implements 'variable += expr' when both arguments
4428 Py_ssize_t v_len
= PyString_GET_SIZE(v
);
4429 Py_ssize_t w_len
= PyString_GET_SIZE(w
);
4430 Py_ssize_t new_len
= v_len
+ w_len
;
4432 PyErr_SetString(PyExc_OverflowError
,
4433 "strings are too large to concat");
4437 if (v
->ob_refcnt
== 2) {
4438 /* In the common case, there are 2 references to the value
4439 * stored in 'variable' when the += is performed: one on the
4440 * value stack (in 'v') and one still stored in the
4441 * 'variable'. We try to delete the variable now to reduce
4444 switch (*next_instr
) {
4447 int oparg
= PEEKARG();
4448 PyObject
**fastlocals
= f
->f_localsplus
;
4449 if (GETLOCAL(oparg
) == v
)
4450 SETLOCAL(oparg
, NULL
);
4455 PyObject
**freevars
= (f
->f_localsplus
+
4456 f
->f_code
->co_nlocals
);
4457 PyObject
*c
= freevars
[PEEKARG()];
4458 if (PyCell_GET(c
) == v
)
4459 PyCell_Set(c
, NULL
);
4464 PyObject
*names
= f
->f_code
->co_names
;
4465 PyObject
*name
= GETITEM(names
, PEEKARG());
4466 PyObject
*locals
= f
->f_locals
;
4467 if (PyDict_CheckExact(locals
) &&
4468 PyDict_GetItem(locals
, name
) == v
) {
4469 if (PyDict_DelItem(locals
, name
) != 0) {
4478 if (v
->ob_refcnt
== 1 && !PyString_CHECK_INTERNED(v
)) {
4479 /* Now we own the last reference to 'v', so we can resize it
4482 if (_PyString_Resize(&v
, new_len
) != 0) {
4483 /* XXX if _PyString_Resize() fails, 'v' has been
4484 * deallocated so it cannot be put back into
4485 * 'variable'. The MemoryError is raised when there
4486 * is no value in 'variable', which might (very
4487 * remotely) be a cause of incompatibilities.
4491 /* copy 'w' into the newly allocated area of 'v' */
4492 memcpy(PyString_AS_STRING(v
) + v_len
,
4493 PyString_AS_STRING(w
), w_len
);
4497 /* When in-place resizing is not an option. */
4498 PyString_Concat(&v
, w
);
4503 #ifdef DYNAMIC_EXECUTION_PROFILE
4506 getarray(long a
[256])
4509 PyObject
*l
= PyList_New(256);
4510 if (l
== NULL
) return NULL
;
4511 for (i
= 0; i
< 256; i
++) {
4512 PyObject
*x
= PyInt_FromLong(a
[i
]);
4517 PyList_SetItem(l
, i
, x
);
4519 for (i
= 0; i
< 256; i
++)
4525 _Py_GetDXProfile(PyObject
*self
, PyObject
*args
)
4528 return getarray(dxp
);
4531 PyObject
*l
= PyList_New(257);
4532 if (l
== NULL
) return NULL
;
4533 for (i
= 0; i
< 257; i
++) {
4534 PyObject
*x
= getarray(dxpairs
[i
]);
4539 PyList_SetItem(l
, i
, x
);