blob: 86dcea28c1d338d0c7df9206e7397dbcf5bc527a [file] [log] [blame]
Guido van Rossumf70e43a1991-02-19 12:39:46 +00001
Guido van Rossum3f5da241990-12-20 15:06:42 +00002/* Execute compiled code */
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003
Guido van Rossum681d79a1995-07-18 14:51:37 +00004/* XXX TO DO:
Guido van Rossum681d79a1995-07-18 14:51:37 +00005 XXX speed up searching for keywords by using a dictionary
Guido van Rossum681d79a1995-07-18 14:51:37 +00006 XXX document it!
7 */
8
Thomas Wouters477c8d52006-05-27 19:21:47 +00009/* enable more aggressive intra-module optimizations, where available */
10#define PY_LOCAL_AGGRESSIVE
11
Guido van Rossumb209a111997-04-29 18:18:01 +000012#include "Python.h"
Guido van Rossum10dc2e81990-11-18 17:27:39 +000013
Jeremy Hylton3e0055f2005-10-20 19:59:25 +000014#include "code.h"
Guido van Rossum3f5da241990-12-20 15:06:42 +000015#include "frameobject.h"
Guido van Rossumff4949e1992-08-05 19:58:53 +000016#include "eval.h"
Guido van Rossum10dc2e81990-11-18 17:27:39 +000017#include "opcode.h"
Tim Peters6d6c1a32001-08-02 04:15:00 +000018#include "structmember.h"
Guido van Rossum10dc2e81990-11-18 17:27:39 +000019
Guido van Rossumc6004111993-11-05 10:22:19 +000020#include <ctype.h>
21
Thomas Wouters477c8d52006-05-27 19:21:47 +000022#ifndef WITH_TSC
Michael W. Hudson75eabd22005-01-18 15:56:11 +000023
24#define READ_TIMESTAMP(var)
25
26#else
Martin v. Löwisf30d60e2004-06-08 08:17:44 +000027
28typedef unsigned long long uint64;
29
Michael W. Hudson800ba232004-08-12 18:19:17 +000030#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
Michael W. Hudson75eabd22005-01-18 15:56:11 +000034#define READ_TIMESTAMP(var) ppc_getcounter(&var)
Michael W. Hudson800ba232004-08-12 18:19:17 +000035
36static void
37ppc_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
Thomas Wouters477c8d52006-05-27 19:21:47 +000047 /* The slightly peculiar way of writing the next lines is
Michael W. Hudson800ba232004-08-12 18:19:17 +000048 compiled better by GCC than any other way I tried. */
49 ((long*)(v))[0] = tbu;
50 ((long*)(v))[1] = tb;
51}
52
Michael W. Hudson75eabd22005-01-18 15:56:11 +000053#else /* this is for linux/x86 (and probably any other GCC/x86 combo) */
Michael W. Hudson800ba232004-08-12 18:19:17 +000054
Michael W. Hudson75eabd22005-01-18 15:56:11 +000055#define READ_TIMESTAMP(val) \
56 __asm__ __volatile__("rdtsc" : "=A" (val))
Michael W. Hudson800ba232004-08-12 18:19:17 +000057
58#endif
59
Thomas Wouters477c8d52006-05-27 19:21:47 +000060void dump_tsc(int opcode, int ticked, uint64 inst0, uint64 inst1,
Martin v. Löwisf30d60e2004-06-08 08:17:44 +000061 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}
Michael W. Hudson800ba232004-08-12 18:19:17 +000073
Martin v. Löwisf30d60e2004-06-08 08:17:44 +000074#endif
75
Guido van Rossum04691fc1992-08-12 15:35:34 +000076/* Turn this on if your compiler chokes on the big switch: */
Guido van Rossum1ae940a1995-01-02 19:04:15 +000077/* #define CASE_TOO_BIG 1 */
Guido van Rossum04691fc1992-08-12 15:35:34 +000078
Guido van Rossum408027e1996-12-30 16:17:54 +000079#ifdef Py_DEBUG
Guido van Rossum96a42c81992-01-12 02:29:51 +000080/* For debugging the interpreter: */
81#define LLTRACE 1 /* Low-level trace feature */
82#define CHECKEXC 1 /* Double-check exception checking */
Guido van Rossum10dc2e81990-11-18 17:27:39 +000083#endif
84
Jeremy Hylton52820442001-01-03 23:52:36 +000085typedef PyObject *(*callproc)(PyObject *, PyObject *, PyObject *);
Guido van Rossum5b722181993-03-30 17:46:03 +000086
Guido van Rossum374a9221991-04-04 10:40:29 +000087/* Forward declarations */
Martin v. Löwisf30d60e2004-06-08 08:17:44 +000088#ifdef WITH_TSC
Thomas Wouters477c8d52006-05-27 19:21:47 +000089static PyObject * call_function(PyObject ***, int, uint64*, uint64*);
Martin v. Löwisf30d60e2004-06-08 08:17:44 +000090#else
Thomas Wouters477c8d52006-05-27 19:21:47 +000091static PyObject * call_function(PyObject ***, int);
Martin v. Löwisf30d60e2004-06-08 08:17:44 +000092#endif
Thomas Wouters477c8d52006-05-27 19:21:47 +000093static PyObject * fast_function(PyObject *, PyObject ***, int, int, int);
94static PyObject * do_call(PyObject *, PyObject ***, int, int);
95static PyObject * ext_do_call(PyObject *, PyObject ***, int, int, int);
96static PyObject * update_keyword_args(PyObject *, int, PyObject ***,PyObject *);
97static PyObject * update_star_args(int, int, PyObject *, PyObject ***);
98static PyObject * load_args(PyObject ***, int);
Jeremy Hylton52820442001-01-03 23:52:36 +000099#define CALL_FLAG_VAR 1
100#define CALL_FLAG_KW 2
101
Guido van Rossum0a066c01992-03-27 17:29:15 +0000102#ifdef LLTRACE
Guido van Rossumc2e20742006-02-27 22:32:47 +0000103static int lltrace;
Tim Petersdbd9ba62000-07-09 03:09:57 +0000104static int prtrace(PyObject *, char *);
Guido van Rossum0a066c01992-03-27 17:29:15 +0000105#endif
Fred Drake5755ce62001-06-27 19:19:46 +0000106static int call_trace(Py_tracefunc, PyObject *, PyFrameObject *,
107 int, PyObject *);
Fred Drake4ec5d562001-10-04 19:26:43 +0000108static void call_trace_protected(Py_tracefunc, PyObject *,
Armin Rigo1c2d7e52005-09-20 18:34:01 +0000109 PyFrameObject *, int, PyObject *);
Fred Drake5755ce62001-06-27 19:19:46 +0000110static void call_exc_trace(Py_tracefunc, PyObject *, PyFrameObject *);
Tim Peters8a5c3c72004-04-05 19:36:21 +0000111static int maybe_call_line_trace(Py_tracefunc, PyObject *,
Armin Rigobf57a142004-03-22 19:24:58 +0000112 PyFrameObject *, int *, int *, int *);
Michael W. Hudsondd32a912002-08-15 14:59:02 +0000113
Thomas Wouters477c8d52006-05-27 19:21:47 +0000114static PyObject * apply_slice(PyObject *, PyObject *, PyObject *);
Tim Petersdbd9ba62000-07-09 03:09:57 +0000115static int assign_slice(PyObject *, PyObject *,
116 PyObject *, PyObject *);
Thomas Wouters477c8d52006-05-27 19:21:47 +0000117static PyObject * cmp_outcome(int, PyObject *, PyObject *);
118static PyObject * import_from(PyObject *, PyObject *);
Thomas Wouters52152252000-08-17 22:55:00 +0000119static int import_all_from(PyObject *, PyObject *);
Thomas Wouters477c8d52006-05-27 19:21:47 +0000120static PyObject * build_class(PyObject *, PyObject *, PyObject *);
Tim Petersdbd9ba62000-07-09 03:09:57 +0000121static void set_exc_info(PyThreadState *, PyObject *, PyObject *, PyObject *);
122static void reset_exc_info(PyThreadState *);
Paul Prescode68140d2000-08-30 20:25:01 +0000123static void format_exc_check_arg(PyObject *, char *, PyObject *);
Thomas Wouters477c8d52006-05-27 19:21:47 +0000124static PyObject * string_concatenate(PyObject *, PyObject *,
Raymond Hettinger52a21b82004-08-06 18:43:09 +0000125 PyFrameObject *, unsigned char *);
Guido van Rossum374a9221991-04-04 10:40:29 +0000126
Paul Prescode68140d2000-08-30 20:25:01 +0000127#define NAME_ERROR_MSG \
Fred Drake661ea262000-10-24 19:57:45 +0000128 "name '%.200s' is not defined"
Jeremy Hylton64949cb2001-01-25 20:06:59 +0000129#define GLOBAL_NAME_ERROR_MSG \
130 "global name '%.200s' is not defined"
Paul Prescode68140d2000-08-30 20:25:01 +0000131#define UNBOUNDLOCAL_ERROR_MSG \
Fred Drake661ea262000-10-24 19:57:45 +0000132 "local variable '%.200s' referenced before assignment"
Jeremy Hyltonc76770c2001-04-13 16:51:46 +0000133#define UNBOUNDFREE_ERROR_MSG \
134 "free variable '%.200s' referenced before assignment" \
135 " in enclosing scope"
Guido van Rossum374a9221991-04-04 10:40:29 +0000136
Guido van Rossum950361c1997-01-24 13:49:28 +0000137/* Dynamic execution profile */
138#ifdef DYNAMIC_EXECUTION_PROFILE
139#ifdef DXPAIRS
140static long dxpairs[257][256];
141#define dxp dxpairs[256]
142#else
143static long dxp[256];
144#endif
145#endif
146
Jeremy Hylton985eba52003-02-05 23:13:00 +0000147/* Function call profile */
148#ifdef CALL_PROFILE
149#define PCALL_NUM 11
150static int pcall[PCALL_NUM];
151
152#define PCALL_ALL 0
153#define PCALL_FUNCTION 1
154#define PCALL_FAST_FUNCTION 2
155#define PCALL_FASTER_FUNCTION 3
156#define PCALL_METHOD 4
157#define PCALL_BOUND_METHOD 5
158#define PCALL_CFUNCTION 6
159#define PCALL_TYPE 7
160#define PCALL_GENERATOR 8
161#define PCALL_OTHER 9
162#define PCALL_POP 10
163
164/* Notes about the statistics
165
166 PCALL_FAST stats
167
168 FAST_FUNCTION means no argument tuple needs to be created.
169 FASTER_FUNCTION means that the fast-path frame setup code is used.
170
171 If there is a method call where the call can be optimized by changing
172 the argument tuple and calling the function directly, it gets recorded
173 twice.
174
175 As a result, the relationship among the statistics appears to be
176 PCALL_ALL == PCALL_FUNCTION + PCALL_METHOD - PCALL_BOUND_METHOD +
177 PCALL_CFUNCTION + PCALL_TYPE + PCALL_GENERATOR + PCALL_OTHER
178 PCALL_FUNCTION > PCALL_FAST_FUNCTION > PCALL_FASTER_FUNCTION
179 PCALL_METHOD > PCALL_BOUND_METHOD
180*/
181
182#define PCALL(POS) pcall[POS]++
183
184PyObject *
185PyEval_GetCallStats(PyObject *self)
186{
Thomas Wouters89f507f2006-12-13 04:49:30 +0000187 return Py_BuildValue("iiiiiiiiiii",
Jeremy Hylton985eba52003-02-05 23:13:00 +0000188 pcall[0], pcall[1], pcall[2], pcall[3],
189 pcall[4], pcall[5], pcall[6], pcall[7],
Thomas Wouters89f507f2006-12-13 04:49:30 +0000190 pcall[8], pcall[9], pcall[10]);
Jeremy Hylton985eba52003-02-05 23:13:00 +0000191}
192#else
193#define PCALL(O)
194
195PyObject *
196PyEval_GetCallStats(PyObject *self)
197{
198 Py_INCREF(Py_None);
199 return Py_None;
200}
201#endif
202
Tim Peters5ca576e2001-06-18 22:08:13 +0000203
Guido van Rossume59214e1994-08-30 08:01:59 +0000204#ifdef WITH_THREAD
Guido van Rossumff4949e1992-08-05 19:58:53 +0000205
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000206#ifdef HAVE_ERRNO_H
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000207#include <errno.h>
Guido van Rossum2571cc81999-04-07 16:07:23 +0000208#endif
Guido van Rossum49b56061998-10-01 20:42:43 +0000209#include "pythread.h"
Guido van Rossumff4949e1992-08-05 19:58:53 +0000210
Guido van Rossumb8b6d0c2003-06-28 21:53:52 +0000211static PyThread_type_lock interpreter_lock = 0; /* This is the GIL */
Guido van Rossuma9672091994-09-14 13:31:22 +0000212static long main_thread = 0;
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000213
Tim Peters7f468f22004-10-11 02:40:51 +0000214int
215PyEval_ThreadsInitialized(void)
216{
217 return interpreter_lock != 0;
218}
219
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000220void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000221PyEval_InitThreads(void)
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000222{
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000223 if (interpreter_lock)
Sjoerd Mullendered59d201993-01-06 13:36:38 +0000224 return;
Guido van Rossum65d5b571998-12-21 19:32:43 +0000225 interpreter_lock = PyThread_allocate_lock();
226 PyThread_acquire_lock(interpreter_lock, 1);
227 main_thread = PyThread_get_thread_ident();
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000228}
Guido van Rossumff4949e1992-08-05 19:58:53 +0000229
Guido van Rossum9cc8a201997-07-19 19:55:50 +0000230void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000231PyEval_AcquireLock(void)
Guido van Rossum25ce5661997-08-02 03:10:38 +0000232{
Guido van Rossum65d5b571998-12-21 19:32:43 +0000233 PyThread_acquire_lock(interpreter_lock, 1);
Guido van Rossum25ce5661997-08-02 03:10:38 +0000234}
235
236void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000237PyEval_ReleaseLock(void)
Guido van Rossum25ce5661997-08-02 03:10:38 +0000238{
Guido van Rossum65d5b571998-12-21 19:32:43 +0000239 PyThread_release_lock(interpreter_lock);
Guido van Rossum25ce5661997-08-02 03:10:38 +0000240}
241
242void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000243PyEval_AcquireThread(PyThreadState *tstate)
Guido van Rossum9cc8a201997-07-19 19:55:50 +0000244{
245 if (tstate == NULL)
246 Py_FatalError("PyEval_AcquireThread: NULL new thread state");
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000247 /* Check someone has called PyEval_InitThreads() to create the lock */
248 assert(interpreter_lock);
Guido van Rossum65d5b571998-12-21 19:32:43 +0000249 PyThread_acquire_lock(interpreter_lock, 1);
Guido van Rossum9cc8a201997-07-19 19:55:50 +0000250 if (PyThreadState_Swap(tstate) != NULL)
251 Py_FatalError(
252 "PyEval_AcquireThread: non-NULL old thread state");
253}
254
255void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000256PyEval_ReleaseThread(PyThreadState *tstate)
Guido van Rossum9cc8a201997-07-19 19:55:50 +0000257{
258 if (tstate == NULL)
259 Py_FatalError("PyEval_ReleaseThread: NULL thread state");
260 if (PyThreadState_Swap(NULL) != tstate)
261 Py_FatalError("PyEval_ReleaseThread: wrong thread state");
Guido van Rossum65d5b571998-12-21 19:32:43 +0000262 PyThread_release_lock(interpreter_lock);
Guido van Rossum9cc8a201997-07-19 19:55:50 +0000263}
Guido van Rossumfee3a2d2000-08-27 17:34:07 +0000264
265/* This function is called from PyOS_AfterFork to ensure that newly
266 created child processes don't hold locks referring to threads which
267 are not running in the child process. (This could also be done using
268 pthread_atfork mechanism, at least for the pthreads implementation.) */
269
270void
271PyEval_ReInitThreads(void)
272{
273 if (!interpreter_lock)
274 return;
275 /*XXX Can't use PyThread_free_lock here because it does too
276 much error-checking. Doing this cleanly would require
277 adding a new function to each thread_*.h. Instead, just
278 create a new lock and waste a little bit of memory */
279 interpreter_lock = PyThread_allocate_lock();
280 PyThread_acquire_lock(interpreter_lock, 1);
281 main_thread = PyThread_get_thread_ident();
282}
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000283#endif
284
Guido van Rossumff4949e1992-08-05 19:58:53 +0000285/* Functions save_thread and restore_thread are always defined so
286 dynamically loaded modules needn't be compiled separately for use
287 with and without threads: */
288
Guido van Rossum2fca21f71997-07-18 23:56:58 +0000289PyThreadState *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000290PyEval_SaveThread(void)
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000291{
Guido van Rossumb74eca91997-09-30 22:03:16 +0000292 PyThreadState *tstate = PyThreadState_Swap(NULL);
293 if (tstate == NULL)
294 Py_FatalError("PyEval_SaveThread: NULL tstate");
Guido van Rossume59214e1994-08-30 08:01:59 +0000295#ifdef WITH_THREAD
Guido van Rossumb74eca91997-09-30 22:03:16 +0000296 if (interpreter_lock)
Guido van Rossum65d5b571998-12-21 19:32:43 +0000297 PyThread_release_lock(interpreter_lock);
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000298#endif
Guido van Rossumb74eca91997-09-30 22:03:16 +0000299 return tstate;
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000300}
301
302void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000303PyEval_RestoreThread(PyThreadState *tstate)
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000304{
Guido van Rossumb74eca91997-09-30 22:03:16 +0000305 if (tstate == NULL)
306 Py_FatalError("PyEval_RestoreThread: NULL tstate");
Guido van Rossume59214e1994-08-30 08:01:59 +0000307#ifdef WITH_THREAD
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000308 if (interpreter_lock) {
Guido van Rossumb74eca91997-09-30 22:03:16 +0000309 int err = errno;
Guido van Rossum65d5b571998-12-21 19:32:43 +0000310 PyThread_acquire_lock(interpreter_lock, 1);
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000311 errno = err;
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000312 }
313#endif
Guido van Rossumb74eca91997-09-30 22:03:16 +0000314 PyThreadState_Swap(tstate);
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000315}
316
317
Guido van Rossuma9672091994-09-14 13:31:22 +0000318/* Mechanism whereby asynchronously executing callbacks (e.g. UNIX
319 signal handlers or Mac I/O completion routines) can schedule calls
320 to a function to be called synchronously.
321 The synchronous function is called with one void* argument.
322 It should return 0 for success or -1 for failure -- failure should
323 be accompanied by an exception.
324
325 If registry succeeds, the registry function returns 0; if it fails
326 (e.g. due to too many pending calls) it returns -1 (without setting
327 an exception condition).
328
329 Note that because registry may occur from within signal handlers,
330 or other asynchronous events, calling malloc() is unsafe!
331
332#ifdef WITH_THREAD
333 Any thread can schedule pending calls, but only the main thread
334 will execute them.
335#endif
336
337 XXX WARNING! ASYNCHRONOUSLY EXECUTING CODE!
338 There are two possible race conditions:
339 (1) nested asynchronous registry calls;
340 (2) registry calls made while pending calls are being processed.
341 While (1) is very unlikely, (2) is a real possibility.
342 The current code is safe against (2), but not against (1).
343 The safety against (2) is derived from the fact that only one
344 thread (the main thread) ever takes things out of the queue.
Guido van Rossuma9672091994-09-14 13:31:22 +0000345
Guido van Rossuma027efa1997-05-05 20:56:21 +0000346 XXX Darn! With the advent of thread state, we should have an array
347 of pending calls per thread in the thread state! Later...
348*/
Guido van Rossum8861b741996-07-30 16:49:37 +0000349
Guido van Rossuma9672091994-09-14 13:31:22 +0000350#define NPENDINGCALLS 32
351static struct {
Thomas Wouters334fb892000-07-25 12:56:38 +0000352 int (*func)(void *);
353 void *arg;
Guido van Rossuma9672091994-09-14 13:31:22 +0000354} pendingcalls[NPENDINGCALLS];
355static volatile int pendingfirst = 0;
356static volatile int pendinglast = 0;
Guido van Rossuma027efa1997-05-05 20:56:21 +0000357static volatile int things_to_do = 0;
Guido van Rossuma9672091994-09-14 13:31:22 +0000358
359int
Thomas Wouters334fb892000-07-25 12:56:38 +0000360Py_AddPendingCall(int (*func)(void *), void *arg)
Guido van Rossuma9672091994-09-14 13:31:22 +0000361{
Michael W. Hudson30ea2f22004-07-07 17:44:12 +0000362 static volatile int busy = 0;
Guido van Rossuma9672091994-09-14 13:31:22 +0000363 int i, j;
364 /* XXX Begin critical section */
365 /* XXX If you want this to be safe against nested
366 XXX asynchronous calls, you'll have to work harder! */
Guido van Rossum180d7b41994-09-29 09:45:57 +0000367 if (busy)
368 return -1;
369 busy = 1;
Guido van Rossuma9672091994-09-14 13:31:22 +0000370 i = pendinglast;
371 j = (i + 1) % NPENDINGCALLS;
Guido van Rossum04e70322002-07-17 16:57:13 +0000372 if (j == pendingfirst) {
373 busy = 0;
Guido van Rossuma9672091994-09-14 13:31:22 +0000374 return -1; /* Queue full */
Guido van Rossum04e70322002-07-17 16:57:13 +0000375 }
Guido van Rossuma9672091994-09-14 13:31:22 +0000376 pendingcalls[i].func = func;
377 pendingcalls[i].arg = arg;
378 pendinglast = j;
Skip Montanarod581d772002-09-03 20:10:45 +0000379
380 _Py_Ticker = 0;
Guido van Rossuma027efa1997-05-05 20:56:21 +0000381 things_to_do = 1; /* Signal main loop */
Guido van Rossum180d7b41994-09-29 09:45:57 +0000382 busy = 0;
Guido van Rossuma9672091994-09-14 13:31:22 +0000383 /* XXX End critical section */
384 return 0;
385}
386
Guido van Rossum180d7b41994-09-29 09:45:57 +0000387int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000388Py_MakePendingCalls(void)
Guido van Rossuma9672091994-09-14 13:31:22 +0000389{
Guido van Rossum180d7b41994-09-29 09:45:57 +0000390 static int busy = 0;
Guido van Rossuma9672091994-09-14 13:31:22 +0000391#ifdef WITH_THREAD
Guido van Rossum65d5b571998-12-21 19:32:43 +0000392 if (main_thread && PyThread_get_thread_ident() != main_thread)
Guido van Rossuma9672091994-09-14 13:31:22 +0000393 return 0;
394#endif
Guido van Rossuma027efa1997-05-05 20:56:21 +0000395 if (busy)
Guido van Rossum180d7b41994-09-29 09:45:57 +0000396 return 0;
397 busy = 1;
Guido van Rossuma027efa1997-05-05 20:56:21 +0000398 things_to_do = 0;
Guido van Rossuma9672091994-09-14 13:31:22 +0000399 for (;;) {
400 int i;
Thomas Wouters334fb892000-07-25 12:56:38 +0000401 int (*func)(void *);
402 void *arg;
Guido van Rossuma9672091994-09-14 13:31:22 +0000403 i = pendingfirst;
404 if (i == pendinglast)
405 break; /* Queue empty */
406 func = pendingcalls[i].func;
407 arg = pendingcalls[i].arg;
408 pendingfirst = (i + 1) % NPENDINGCALLS;
Guido van Rossum180d7b41994-09-29 09:45:57 +0000409 if (func(arg) < 0) {
410 busy = 0;
Guido van Rossuma027efa1997-05-05 20:56:21 +0000411 things_to_do = 1; /* We're not done yet */
Guido van Rossuma9672091994-09-14 13:31:22 +0000412 return -1;
Guido van Rossum180d7b41994-09-29 09:45:57 +0000413 }
Guido van Rossuma9672091994-09-14 13:31:22 +0000414 }
Guido van Rossum180d7b41994-09-29 09:45:57 +0000415 busy = 0;
Guido van Rossuma9672091994-09-14 13:31:22 +0000416 return 0;
417}
418
419
Jeremy Hyltonee5adfb2000-08-31 19:23:01 +0000420/* The interpreter's recursion limit */
421
Hye-Shik Changb6fa2812005-04-04 15:49:02 +0000422#ifndef Py_DEFAULT_RECURSION_LIMIT
423#define Py_DEFAULT_RECURSION_LIMIT 1000
424#endif
425static int recursion_limit = Py_DEFAULT_RECURSION_LIMIT;
426int _Py_CheckRecursionLimit = Py_DEFAULT_RECURSION_LIMIT;
Jeremy Hyltonee5adfb2000-08-31 19:23:01 +0000427
Vladimir Marangozov7bd25be2000-09-01 11:07:19 +0000428int
429Py_GetRecursionLimit(void)
Jeremy Hyltonee5adfb2000-08-31 19:23:01 +0000430{
431 return recursion_limit;
432}
433
Vladimir Marangozov7bd25be2000-09-01 11:07:19 +0000434void
435Py_SetRecursionLimit(int new_limit)
Jeremy Hyltonee5adfb2000-08-31 19:23:01 +0000436{
437 recursion_limit = new_limit;
Armin Rigo2b3eb402003-10-28 12:05:48 +0000438 _Py_CheckRecursionLimit = recursion_limit;
Jeremy Hyltonee5adfb2000-08-31 19:23:01 +0000439}
440
Armin Rigo2b3eb402003-10-28 12:05:48 +0000441/* the macro Py_EnterRecursiveCall() only calls _Py_CheckRecursiveCall()
442 if the recursion_depth reaches _Py_CheckRecursionLimit.
443 If USE_STACKCHECK, the macro decrements _Py_CheckRecursionLimit
444 to guarantee that _Py_CheckRecursiveCall() is regularly called.
445 Without USE_STACKCHECK, there is no need for this. */
446int
447_Py_CheckRecursiveCall(char *where)
448{
449 PyThreadState *tstate = PyThreadState_GET();
450
451#ifdef USE_STACKCHECK
452 if (PyOS_CheckStack()) {
453 --tstate->recursion_depth;
454 PyErr_SetString(PyExc_MemoryError, "Stack overflow");
455 return -1;
456 }
457#endif
458 if (tstate->recursion_depth > recursion_limit) {
459 --tstate->recursion_depth;
460 PyErr_Format(PyExc_RuntimeError,
461 "maximum recursion depth exceeded%s",
462 where);
463 return -1;
464 }
465 _Py_CheckRecursionLimit = recursion_limit;
466 return 0;
467}
468
Guido van Rossum374a9221991-04-04 10:40:29 +0000469/* Status code for main loop (reason for stack unwind) */
Raymond Hettinger7c958652004-04-06 10:11:10 +0000470enum why_code {
471 WHY_NOT = 0x0001, /* No error */
472 WHY_EXCEPTION = 0x0002, /* Exception occurred */
473 WHY_RERAISE = 0x0004, /* Exception re-raised by 'finally' */
474 WHY_RETURN = 0x0008, /* 'return' statement */
475 WHY_BREAK = 0x0010, /* 'break' statement */
476 WHY_CONTINUE = 0x0020, /* 'continue' statement */
477 WHY_YIELD = 0x0040 /* 'yield' operator */
478};
Guido van Rossum374a9221991-04-04 10:40:29 +0000479
Raymond Hettinger7c958652004-04-06 10:11:10 +0000480static enum why_code do_raise(PyObject *, PyObject *, PyObject *);
Tim Petersd6d010b2001-06-21 02:49:55 +0000481static int unpack_iterable(PyObject *, int, PyObject **);
Guido van Rossum1aa14831997-01-21 05:34:20 +0000482
Skip Montanarod581d772002-09-03 20:10:45 +0000483/* for manipulating the thread switch and periodic "stuff" - used to be
484 per thread, now just a pair o' globals */
Skip Montanaro99dba272002-09-03 20:19:06 +0000485int _Py_CheckInterval = 100;
486volatile int _Py_Ticker = 100;
Guido van Rossum374a9221991-04-04 10:40:29 +0000487
Guido van Rossumb209a111997-04-29 18:18:01 +0000488PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000489PyEval_EvalCode(PyCodeObject *co, PyObject *globals, PyObject *locals)
Guido van Rossum681d79a1995-07-18 14:51:37 +0000490{
Jeremy Hylton985eba52003-02-05 23:13:00 +0000491 /* XXX raise SystemError if globals is NULL */
Tim Peters6d6c1a32001-08-02 04:15:00 +0000492 return PyEval_EvalCodeEx(co,
Guido van Rossum681d79a1995-07-18 14:51:37 +0000493 globals, locals,
Guido van Rossumb209a111997-04-29 18:18:01 +0000494 (PyObject **)NULL, 0,
495 (PyObject **)NULL, 0,
Jeremy Hylton64949cb2001-01-25 20:06:59 +0000496 (PyObject **)NULL, 0,
Guido van Rossum4f72a782006-10-27 23:31:49 +0000497 NULL, NULL);
Guido van Rossum681d79a1995-07-18 14:51:37 +0000498}
499
500
501/* Interpreter main loop */
502
Martin v. Löwis8d97e332004-06-27 15:43:12 +0000503PyObject *
Phillip J. Eby0d6615f2005-08-02 00:46:46 +0000504PyEval_EvalFrame(PyFrameObject *f) {
505 /* This is for backward compatibility with extension modules that
506 used this API; core interpreter code should call PyEval_EvalFrameEx() */
507 return PyEval_EvalFrameEx(f, 0);
508}
509
510PyObject *
Thomas Wouters49fd7fa2006-04-21 10:40:58 +0000511PyEval_EvalFrameEx(PyFrameObject *f, int throwflag)
Guido van Rossum374a9221991-04-04 10:40:29 +0000512{
Guido van Rossum950361c1997-01-24 13:49:28 +0000513#ifdef DXPAIRS
514 int lastopcode = 0;
515#endif
Armin Rigo8817fcd2004-06-17 10:22:40 +0000516 register PyObject **stack_pointer; /* Next free slot in value stack */
Guido van Rossum374a9221991-04-04 10:40:29 +0000517 register unsigned char *next_instr;
Armin Rigo8817fcd2004-06-17 10:22:40 +0000518 register int opcode; /* Current opcode */
519 register int oparg; /* Current opcode argument, if any */
Raymond Hettinger7c958652004-04-06 10:11:10 +0000520 register enum why_code why; /* Reason for block stack unwind */
Guido van Rossum374a9221991-04-04 10:40:29 +0000521 register int err; /* Error status -- nonzero if error */
Guido van Rossumb209a111997-04-29 18:18:01 +0000522 register PyObject *x; /* Result object -- NULL if error */
523 register PyObject *v; /* Temporary objects popped off stack */
524 register PyObject *w;
525 register PyObject *u;
526 register PyObject *t;
Jeremy Hylton2b724da2001-01-29 22:51:52 +0000527 register PyObject **fastlocals, **freevars;
Guido van Rossum014518f1998-11-23 21:09:51 +0000528 PyObject *retval = NULL; /* Return value */
Guido van Rossum885553e1998-12-21 18:33:30 +0000529 PyThreadState *tstate = PyThreadState_GET();
Tim Peters5ca576e2001-06-18 22:08:13 +0000530 PyCodeObject *co;
Michael W. Hudsondd32a912002-08-15 14:59:02 +0000531
Tim Peters8a5c3c72004-04-05 19:36:21 +0000532 /* when tracing we set things up so that
Michael W. Hudsondd32a912002-08-15 14:59:02 +0000533
534 not (instr_lb <= current_bytecode_offset < instr_ub)
535
Tim Peters8a5c3c72004-04-05 19:36:21 +0000536 is true when the line being executed has changed. The
Michael W. Hudsondd32a912002-08-15 14:59:02 +0000537 initial values are such as to make this false the first
538 time it is tested. */
Armin Rigobf57a142004-03-22 19:24:58 +0000539 int instr_ub = -1, instr_lb = 0, instr_prev = -1;
Michael W. Hudsondd32a912002-08-15 14:59:02 +0000540
Guido van Rossumd076c731998-10-07 19:42:25 +0000541 unsigned char *first_instr;
Skip Montanaro04d80f82002-08-04 21:03:35 +0000542 PyObject *names;
543 PyObject *consts;
Neal Norwitz5f5153e2005-10-21 04:28:38 +0000544#if defined(Py_DEBUG) || defined(LLTRACE)
Guido van Rossum681d79a1995-07-18 14:51:37 +0000545 /* Make it easier to find out where we are with a debugger */
Tim Peters5ca576e2001-06-18 22:08:13 +0000546 char *filename;
Guido van Rossum99bec951992-09-03 20:29:45 +0000547#endif
Guido van Rossum374a9221991-04-04 10:40:29 +0000548
Neal Norwitza81d2202002-07-14 00:27:26 +0000549/* Tuple access macros */
550
551#ifndef Py_DEBUG
552#define GETITEM(v, i) PyTuple_GET_ITEM((PyTupleObject *)(v), (i))
553#else
554#define GETITEM(v, i) PyTuple_GetItem((v), (i))
555#endif
556
Martin v. Löwisf30d60e2004-06-08 08:17:44 +0000557#ifdef WITH_TSC
558/* Use Pentium timestamp counter to mark certain events:
559 inst0 -- beginning of switch statement for opcode dispatch
560 inst1 -- end of switch statement (may be skipped)
561 loop0 -- the top of the mainloop
Thomas Wouters477c8d52006-05-27 19:21:47 +0000562 loop1 -- place where control returns again to top of mainloop
Martin v. Löwisf30d60e2004-06-08 08:17:44 +0000563 (may be skipped)
564 intr1 -- beginning of long interruption
565 intr2 -- end of long interruption
566
567 Many opcodes call out to helper C functions. In some cases, the
568 time in those functions should be counted towards the time for the
569 opcode, but not in all cases. For example, a CALL_FUNCTION opcode
570 calls another Python function; there's no point in charge all the
571 bytecode executed by the called function to the caller.
572
573 It's hard to make a useful judgement statically. In the presence
574 of operator overloading, it's impossible to tell if a call will
575 execute new Python code or not.
576
577 It's a case-by-case judgement. I'll use intr1 for the following
578 cases:
579
Martin v. Löwisf30d60e2004-06-08 08:17:44 +0000580 IMPORT_STAR
581 IMPORT_FROM
582 CALL_FUNCTION (and friends)
583
584 */
585 uint64 inst0, inst1, loop0, loop1, intr0 = 0, intr1 = 0;
586 int ticked = 0;
587
Michael W. Hudson75eabd22005-01-18 15:56:11 +0000588 READ_TIMESTAMP(inst0);
589 READ_TIMESTAMP(inst1);
590 READ_TIMESTAMP(loop0);
591 READ_TIMESTAMP(loop1);
Michael W. Hudson800ba232004-08-12 18:19:17 +0000592
593 /* shut up the compiler */
594 opcode = 0;
Martin v. Löwisf30d60e2004-06-08 08:17:44 +0000595#endif
596
Guido van Rossum374a9221991-04-04 10:40:29 +0000597/* Code access macros */
598
Martin v. Löwis18e16552006-02-15 17:27:45 +0000599#define INSTR_OFFSET() ((int)(next_instr - first_instr))
Guido van Rossum374a9221991-04-04 10:40:29 +0000600#define NEXTOP() (*next_instr++)
Raymond Hettinger5bed4562004-04-10 23:34:17 +0000601#define NEXTARG() (next_instr += 2, (next_instr[-1]<<8) + next_instr[-2])
Raymond Hettinger52a21b82004-08-06 18:43:09 +0000602#define PEEKARG() ((next_instr[2]<<8) + next_instr[1])
Guido van Rossumd076c731998-10-07 19:42:25 +0000603#define JUMPTO(x) (next_instr = first_instr + (x))
Guido van Rossum374a9221991-04-04 10:40:29 +0000604#define JUMPBY(x) (next_instr += (x))
605
Raymond Hettingerf606f872003-03-16 03:11:04 +0000606/* OpCode prediction macros
607 Some opcodes tend to come in pairs thus making it possible to predict
608 the second code when the first is run. For example, COMPARE_OP is often
609 followed by JUMP_IF_FALSE or JUMP_IF_TRUE. And, those opcodes are often
610 followed by a POP_TOP.
611
612 Verifying the prediction costs a single high-speed test of register
Raymond Hettingerac2072922003-03-16 15:41:11 +0000613 variable against a constant. If the pairing was good, then the
Raymond Hettingerf606f872003-03-16 03:11:04 +0000614 processor has a high likelihood of making its own successful branch
615 prediction which results in a nearly zero overhead transition to the
616 next opcode.
617
618 A successful prediction saves a trip through the eval-loop including
619 its two unpredictable branches, the HASARG test and the switch-case.
Raymond Hettingera7216982004-02-08 19:59:27 +0000620
Tim Peters8a5c3c72004-04-05 19:36:21 +0000621 If collecting opcode statistics, turn off prediction so that
622 statistics are accurately maintained (the predictions bypass
Raymond Hettingera7216982004-02-08 19:59:27 +0000623 the opcode frequency counter updates).
Raymond Hettingerf606f872003-03-16 03:11:04 +0000624*/
625
Raymond Hettingera7216982004-02-08 19:59:27 +0000626#ifdef DYNAMIC_EXECUTION_PROFILE
627#define PREDICT(op) if (0) goto PRED_##op
628#else
Raymond Hettingerac2072922003-03-16 15:41:11 +0000629#define PREDICT(op) if (*next_instr == op) goto PRED_##op
Raymond Hettingera7216982004-02-08 19:59:27 +0000630#endif
631
Raymond Hettingerf606f872003-03-16 03:11:04 +0000632#define PREDICTED(op) PRED_##op: next_instr++
Raymond Hettinger52a21b82004-08-06 18:43:09 +0000633#define PREDICTED_WITH_ARG(op) PRED_##op: oparg = PEEKARG(); next_instr += 3
Raymond Hettingerf606f872003-03-16 03:11:04 +0000634
Guido van Rossum374a9221991-04-04 10:40:29 +0000635/* Stack manipulation macros */
636
Martin v. Löwis18e16552006-02-15 17:27:45 +0000637/* The stack can grow at most MAXINT deep, as co_nlocals and
638 co_stacksize are ints. */
639#define STACK_LEVEL() ((int)(stack_pointer - f->f_valuestack))
Guido van Rossum374a9221991-04-04 10:40:29 +0000640#define EMPTY() (STACK_LEVEL() == 0)
641#define TOP() (stack_pointer[-1])
Raymond Hettinger663004b2003-01-09 15:24:30 +0000642#define SECOND() (stack_pointer[-2])
643#define THIRD() (stack_pointer[-3])
644#define FOURTH() (stack_pointer[-4])
Raymond Hettinger663004b2003-01-09 15:24:30 +0000645#define SET_TOP(v) (stack_pointer[-1] = (v))
646#define SET_SECOND(v) (stack_pointer[-2] = (v))
647#define SET_THIRD(v) (stack_pointer[-3] = (v))
648#define SET_FOURTH(v) (stack_pointer[-4] = (v))
Raymond Hettinger663004b2003-01-09 15:24:30 +0000649#define BASIC_STACKADJ(n) (stack_pointer += n)
Guido van Rossum374a9221991-04-04 10:40:29 +0000650#define BASIC_PUSH(v) (*stack_pointer++ = (v))
651#define BASIC_POP() (*--stack_pointer)
652
Guido van Rossum96a42c81992-01-12 02:29:51 +0000653#ifdef LLTRACE
Jeremy Hylton14368152001-10-17 13:29:30 +0000654#define PUSH(v) { (void)(BASIC_PUSH(v), \
655 lltrace && prtrace(TOP(), "push")); \
Thomas Wouters477c8d52006-05-27 19:21:47 +0000656 assert(STACK_LEVEL() <= co->co_stacksize); }
Fred Drakede26cfc2001-10-13 06:11:28 +0000657#define POP() ((void)(lltrace && prtrace(TOP(), "pop")), BASIC_POP())
Raymond Hettinger663004b2003-01-09 15:24:30 +0000658#define STACKADJ(n) { (void)(BASIC_STACKADJ(n), \
659 lltrace && prtrace(TOP(), "stackadj")); \
Thomas Wouters477c8d52006-05-27 19:21:47 +0000660 assert(STACK_LEVEL() <= co->co_stacksize); }
Guido van Rossumc2e20742006-02-27 22:32:47 +0000661#define EXT_POP(STACK_POINTER) (lltrace && prtrace(*(STACK_POINTER), "ext_pop"), *--(STACK_POINTER))
Guido van Rossum374a9221991-04-04 10:40:29 +0000662#else
663#define PUSH(v) BASIC_PUSH(v)
664#define POP() BASIC_POP()
Raymond Hettinger663004b2003-01-09 15:24:30 +0000665#define STACKADJ(n) BASIC_STACKADJ(n)
Guido van Rossumc2e20742006-02-27 22:32:47 +0000666#define EXT_POP(STACK_POINTER) (*--(STACK_POINTER))
Guido van Rossum374a9221991-04-04 10:40:29 +0000667#endif
668
Guido van Rossum681d79a1995-07-18 14:51:37 +0000669/* Local variable macros */
670
671#define GETLOCAL(i) (fastlocals[i])
Guido van Rossumcfbf1a32002-03-28 20:17:52 +0000672
673/* The SETLOCAL() macro must not DECREF the local variable in-place and
674 then store the new value; it must copy the old value to a temporary
675 value, then store the new value, and then DECREF the temporary value.
676 This is because it is possible that during the DECREF the frame is
677 accessed by other code (e.g. a __del__ method or gc.collect()) and the
678 variable would be pointing to already-freed memory. */
679#define SETLOCAL(i, value) do { PyObject *tmp = GETLOCAL(i); \
680 GETLOCAL(i) = value; \
681 Py_XDECREF(tmp); } while (0)
Guido van Rossum681d79a1995-07-18 14:51:37 +0000682
Guido van Rossuma027efa1997-05-05 20:56:21 +0000683/* Start of code */
684
Tim Peters5ca576e2001-06-18 22:08:13 +0000685 if (f == NULL)
686 return NULL;
687
Armin Rigo1d313ab2003-10-25 14:33:09 +0000688 /* push frame */
Armin Rigo2b3eb402003-10-28 12:05:48 +0000689 if (Py_EnterRecursiveCall(""))
Armin Rigo1d313ab2003-10-25 14:33:09 +0000690 return NULL;
Guido van Rossum8861b741996-07-30 16:49:37 +0000691
Tim Peters5ca576e2001-06-18 22:08:13 +0000692 tstate->frame = f;
Tim Peters5ca576e2001-06-18 22:08:13 +0000693
Neil Schemenauer6c0f2002001-09-04 19:03:35 +0000694 if (tstate->use_tracing) {
695 if (tstate->c_tracefunc != NULL) {
696 /* tstate->c_tracefunc, if defined, is a
697 function that will be called on *every* entry
698 to a code block. Its return value, if not
699 None, is a function that will be called at
700 the start of each executed line of code.
701 (Actually, the function must return itself
702 in order to continue tracing.) The trace
703 functions are called with three arguments:
704 a pointer to the current frame, a string
705 indicating why the function is called, and
706 an argument which depends on the situation.
707 The global trace function is also called
708 whenever an exception is detected. */
709 if (call_trace(tstate->c_tracefunc, tstate->c_traceobj,
710 f, PyTrace_CALL, Py_None)) {
Neil Schemenauer6c0f2002001-09-04 19:03:35 +0000711 /* Trace function raised an error */
Armin Rigo2b3eb402003-10-28 12:05:48 +0000712 goto exit_eval_frame;
Neil Schemenauer6c0f2002001-09-04 19:03:35 +0000713 }
714 }
715 if (tstate->c_profilefunc != NULL) {
716 /* Similar for c_profilefunc, except it needn't
717 return itself and isn't called for "line" events */
718 if (call_trace(tstate->c_profilefunc,
719 tstate->c_profileobj,
720 f, PyTrace_CALL, Py_None)) {
Neil Schemenauer6c0f2002001-09-04 19:03:35 +0000721 /* Profile function raised an error */
Armin Rigo2b3eb402003-10-28 12:05:48 +0000722 goto exit_eval_frame;
Neil Schemenauer6c0f2002001-09-04 19:03:35 +0000723 }
724 }
725 }
726
Michael W. Hudson019a78e2002-11-08 12:53:11 +0000727 co = f->f_code;
728 names = co->co_names;
729 consts = co->co_consts;
730 fastlocals = f->f_localsplus;
Thomas Wouters477c8d52006-05-27 19:21:47 +0000731 freevars = f->f_localsplus + co->co_nlocals;
Brett Cannonc9371d42005-06-25 08:23:41 +0000732 first_instr = (unsigned char*) PyString_AS_STRING(co->co_code);
Michael W. Hudson019a78e2002-11-08 12:53:11 +0000733 /* An explanation is in order for the next line.
734
735 f->f_lasti now refers to the index of the last instruction
736 executed. You might think this was obvious from the name, but
737 this wasn't always true before 2.3! PyFrame_New now sets
738 f->f_lasti to -1 (i.e. the index *before* the first instruction)
739 and YIELD_VALUE doesn't fiddle with f_lasti any more. So this
Thomas Wouters902d6eb2007-01-09 23:18:33 +0000740 does work. Promise.
741
742 When the PREDICT() macros are enabled, some opcode pairs follow in
743 direct succession without updating f->f_lasti. A successful
744 prediction effectively links the two codes together as if they
745 were a single new opcode; accordingly,f->f_lasti will point to
746 the first code in the pair (for instance, GET_ITER followed by
747 FOR_ITER is effectively a single opcode and f->f_lasti will point
748 at to the beginning of the combined pair.)
749 */
Michael W. Hudson019a78e2002-11-08 12:53:11 +0000750 next_instr = first_instr + f->f_lasti + 1;
751 stack_pointer = f->f_stacktop;
752 assert(stack_pointer != NULL);
753 f->f_stacktop = NULL; /* remains NULL unless yield suspends frame */
754
Tim Peters5ca576e2001-06-18 22:08:13 +0000755#ifdef LLTRACE
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000756 lltrace = PyDict_GetItemString(f->f_globals, "__lltrace__") != NULL;
Tim Peters5ca576e2001-06-18 22:08:13 +0000757#endif
Neal Norwitz5f5153e2005-10-21 04:28:38 +0000758#if defined(Py_DEBUG) || defined(LLTRACE)
Tim Peters5ca576e2001-06-18 22:08:13 +0000759 filename = PyString_AsString(co->co_filename);
760#endif
Guido van Rossumac7be682001-01-17 15:42:30 +0000761
Guido van Rossum374a9221991-04-04 10:40:29 +0000762 why = WHY_NOT;
763 err = 0;
Guido van Rossumb209a111997-04-29 18:18:01 +0000764 x = Py_None; /* Not a reference, just anything non-NULL */
Fred Drake48fba732000-10-11 13:54:07 +0000765 w = NULL;
Guido van Rossumac7be682001-01-17 15:42:30 +0000766
Thomas Wouters49fd7fa2006-04-21 10:40:58 +0000767 if (throwflag) { /* support for generator.throw() */
Phillip J. Eby0d6615f2005-08-02 00:46:46 +0000768 why = WHY_EXCEPTION;
769 goto on_error;
770 }
Thomas Wouters477c8d52006-05-27 19:21:47 +0000771
Guido van Rossum374a9221991-04-04 10:40:29 +0000772 for (;;) {
Martin v. Löwisf30d60e2004-06-08 08:17:44 +0000773#ifdef WITH_TSC
774 if (inst1 == 0) {
775 /* Almost surely, the opcode executed a break
776 or a continue, preventing inst1 from being set
777 on the way out of the loop.
778 */
Michael W. Hudson75eabd22005-01-18 15:56:11 +0000779 READ_TIMESTAMP(inst1);
Martin v. Löwisf30d60e2004-06-08 08:17:44 +0000780 loop1 = inst1;
781 }
782 dump_tsc(opcode, ticked, inst0, inst1, loop0, loop1,
783 intr0, intr1);
784 ticked = 0;
785 inst1 = 0;
786 intr0 = 0;
787 intr1 = 0;
Michael W. Hudson75eabd22005-01-18 15:56:11 +0000788 READ_TIMESTAMP(loop0);
Martin v. Löwisf30d60e2004-06-08 08:17:44 +0000789#endif
Michael W. Hudsondd32a912002-08-15 14:59:02 +0000790 assert(stack_pointer >= f->f_valuestack); /* else underflow */
Thomas Wouters477c8d52006-05-27 19:21:47 +0000791 assert(STACK_LEVEL() <= co->co_stacksize); /* else overflow */
Michael W. Hudsondd32a912002-08-15 14:59:02 +0000792
Guido van Rossuma027efa1997-05-05 20:56:21 +0000793 /* Do periodic things. Doing this every time through
794 the loop would add too much overhead, so we do it
795 only every Nth instruction. We also do it if
796 ``things_to_do'' is set, i.e. when an asynchronous
797 event needs attention (e.g. a signal handler or
798 async I/O handler); see Py_AddPendingCall() and
799 Py_MakePendingCalls() above. */
Guido van Rossumac7be682001-01-17 15:42:30 +0000800
Skip Montanarod581d772002-09-03 20:10:45 +0000801 if (--_Py_Ticker < 0) {
Guido van Rossumb8b6d0c2003-06-28 21:53:52 +0000802 if (*next_instr == SETUP_FINALLY) {
803 /* Make the last opcode before
804 a try: finally: block uninterruptable. */
805 goto fast_next_opcode;
806 }
Skip Montanarod581d772002-09-03 20:10:45 +0000807 _Py_Ticker = _Py_CheckInterval;
Michael W. Hudson019a78e2002-11-08 12:53:11 +0000808 tstate->tick_counter++;
Martin v. Löwisf30d60e2004-06-08 08:17:44 +0000809#ifdef WITH_TSC
810 ticked = 1;
811#endif
Guido van Rossuma027efa1997-05-05 20:56:21 +0000812 if (things_to_do) {
Guido van Rossum8861b741996-07-30 16:49:37 +0000813 if (Py_MakePendingCalls() < 0) {
814 why = WHY_EXCEPTION;
815 goto on_error;
816 }
Kurt B. Kaiser4c79a832004-11-23 18:06:08 +0000817 if (things_to_do)
818 /* MakePendingCalls() didn't succeed.
819 Force early re-execution of this
820 "periodic" code, possibly after
821 a thread switch */
822 _Py_Ticker = 0;
Guido van Rossum8861b741996-07-30 16:49:37 +0000823 }
Guido van Rossume59214e1994-08-30 08:01:59 +0000824#ifdef WITH_THREAD
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000825 if (interpreter_lock) {
826 /* Give another thread a chance */
827
Guido van Rossum25ce5661997-08-02 03:10:38 +0000828 if (PyThreadState_Swap(NULL) != tstate)
829 Py_FatalError("ceval: tstate mix-up");
Guido van Rossum65d5b571998-12-21 19:32:43 +0000830 PyThread_release_lock(interpreter_lock);
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000831
832 /* Other threads may run now */
833
Guido van Rossum65d5b571998-12-21 19:32:43 +0000834 PyThread_acquire_lock(interpreter_lock, 1);
Guido van Rossum25ce5661997-08-02 03:10:38 +0000835 if (PyThreadState_Swap(tstate) != NULL)
836 Py_FatalError("ceval: orphan tstate");
Guido van Rossumb8b6d0c2003-06-28 21:53:52 +0000837
838 /* Check for thread interrupts */
839
840 if (tstate->async_exc != NULL) {
841 x = tstate->async_exc;
842 tstate->async_exc = NULL;
843 PyErr_SetNone(x);
844 Py_DECREF(x);
845 why = WHY_EXCEPTION;
846 goto on_error;
847 }
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000848 }
849#endif
Guido van Rossum374a9221991-04-04 10:40:29 +0000850 }
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000851
Neil Schemenauer63543862002-02-17 19:10:14 +0000852 fast_next_opcode:
Guido van Rossum99bec951992-09-03 20:29:45 +0000853 f->f_lasti = INSTR_OFFSET();
Guido van Rossumac7be682001-01-17 15:42:30 +0000854
Michael W. Hudson019a78e2002-11-08 12:53:11 +0000855 /* line-by-line tracing support */
856
857 if (tstate->c_tracefunc != NULL && !tstate->tracing) {
858 /* see maybe_call_line_trace
859 for expository comments */
860 f->f_stacktop = stack_pointer;
Tim Peters8a5c3c72004-04-05 19:36:21 +0000861
Michael W. Hudson58ee2af2003-04-29 16:18:47 +0000862 err = maybe_call_line_trace(tstate->c_tracefunc,
863 tstate->c_traceobj,
Armin Rigobf57a142004-03-22 19:24:58 +0000864 f, &instr_lb, &instr_ub,
865 &instr_prev);
Michael W. Hudson019a78e2002-11-08 12:53:11 +0000866 /* Reload possibly changed frame fields */
867 JUMPTO(f->f_lasti);
Michael W. Hudson58ee2af2003-04-29 16:18:47 +0000868 if (f->f_stacktop != NULL) {
869 stack_pointer = f->f_stacktop;
870 f->f_stacktop = NULL;
871 }
872 if (err) {
873 /* trace function raised an exception */
874 goto on_error;
875 }
Michael W. Hudson019a78e2002-11-08 12:53:11 +0000876 }
877
878 /* Extract opcode and argument */
879
Guido van Rossum374a9221991-04-04 10:40:29 +0000880 opcode = NEXTOP();
Armin Rigo8817fcd2004-06-17 10:22:40 +0000881 oparg = 0; /* allows oparg to be stored in a register because
882 it doesn't have to be remembered across a full loop */
Raymond Hettinger5bed4562004-04-10 23:34:17 +0000883 if (HAS_ARG(opcode))
884 oparg = NEXTARG();
Fred Drakeef8ace32000-08-24 00:32:09 +0000885 dispatch_opcode:
Guido van Rossum950361c1997-01-24 13:49:28 +0000886#ifdef DYNAMIC_EXECUTION_PROFILE
887#ifdef DXPAIRS
888 dxpairs[lastopcode][opcode]++;
889 lastopcode = opcode;
890#endif
891 dxp[opcode]++;
892#endif
Guido van Rossum374a9221991-04-04 10:40:29 +0000893
Guido van Rossum96a42c81992-01-12 02:29:51 +0000894#ifdef LLTRACE
Guido van Rossum374a9221991-04-04 10:40:29 +0000895 /* Instruction tracing */
Guido van Rossumac7be682001-01-17 15:42:30 +0000896
Guido van Rossum96a42c81992-01-12 02:29:51 +0000897 if (lltrace) {
Guido van Rossum374a9221991-04-04 10:40:29 +0000898 if (HAS_ARG(opcode)) {
899 printf("%d: %d, %d\n",
Michael W. Hudsondd32a912002-08-15 14:59:02 +0000900 f->f_lasti, opcode, oparg);
Guido van Rossum374a9221991-04-04 10:40:29 +0000901 }
902 else {
903 printf("%d: %d\n",
Michael W. Hudsondd32a912002-08-15 14:59:02 +0000904 f->f_lasti, opcode);
Guido van Rossum374a9221991-04-04 10:40:29 +0000905 }
906 }
907#endif
Michael W. Hudsondd32a912002-08-15 14:59:02 +0000908
Guido van Rossum374a9221991-04-04 10:40:29 +0000909 /* Main switch on opcode */
Michael W. Hudson75eabd22005-01-18 15:56:11 +0000910 READ_TIMESTAMP(inst0);
Jeremy Hylton52820442001-01-03 23:52:36 +0000911
Guido van Rossum374a9221991-04-04 10:40:29 +0000912 switch (opcode) {
Guido van Rossumac7be682001-01-17 15:42:30 +0000913
Guido van Rossum374a9221991-04-04 10:40:29 +0000914 /* BEWARE!
915 It is essential that any operation that fails sets either
916 x to NULL, err to nonzero, or why to anything but WHY_NOT,
917 and that no operation that succeeds does this! */
Guido van Rossumac7be682001-01-17 15:42:30 +0000918
Guido van Rossum374a9221991-04-04 10:40:29 +0000919 /* case STOP_CODE: this is an error! */
Guido van Rossumac7be682001-01-17 15:42:30 +0000920
Raymond Hettinger9c18e812004-06-21 16:31:15 +0000921 case NOP:
922 goto fast_next_opcode;
923
Neil Schemenauer63543862002-02-17 19:10:14 +0000924 case LOAD_FAST:
925 x = GETLOCAL(oparg);
926 if (x != NULL) {
927 Py_INCREF(x);
928 PUSH(x);
929 goto fast_next_opcode;
930 }
931 format_exc_check_arg(PyExc_UnboundLocalError,
932 UNBOUNDLOCAL_ERROR_MSG,
933 PyTuple_GetItem(co->co_varnames, oparg));
934 break;
935
936 case LOAD_CONST:
Skip Montanaro04d80f82002-08-04 21:03:35 +0000937 x = GETITEM(consts, oparg);
Neil Schemenauer63543862002-02-17 19:10:14 +0000938 Py_INCREF(x);
939 PUSH(x);
940 goto fast_next_opcode;
941
Raymond Hettinger7dc52212003-03-16 20:14:44 +0000942 PREDICTED_WITH_ARG(STORE_FAST);
Neil Schemenauer63543862002-02-17 19:10:14 +0000943 case STORE_FAST:
944 v = POP();
945 SETLOCAL(oparg, v);
946 goto fast_next_opcode;
947
Raymond Hettingerf606f872003-03-16 03:11:04 +0000948 PREDICTED(POP_TOP);
Guido van Rossum374a9221991-04-04 10:40:29 +0000949 case POP_TOP:
950 v = POP();
Guido van Rossumb209a111997-04-29 18:18:01 +0000951 Py_DECREF(v);
Neil Schemenauer63543862002-02-17 19:10:14 +0000952 goto fast_next_opcode;
Guido van Rossumac7be682001-01-17 15:42:30 +0000953
Guido van Rossum374a9221991-04-04 10:40:29 +0000954 case ROT_TWO:
Raymond Hettinger663004b2003-01-09 15:24:30 +0000955 v = TOP();
956 w = SECOND();
957 SET_TOP(w);
958 SET_SECOND(v);
Raymond Hettinger080cb322003-03-14 01:37:42 +0000959 goto fast_next_opcode;
Guido van Rossumac7be682001-01-17 15:42:30 +0000960
Guido van Rossum374a9221991-04-04 10:40:29 +0000961 case ROT_THREE:
Raymond Hettinger663004b2003-01-09 15:24:30 +0000962 v = TOP();
963 w = SECOND();
964 x = THIRD();
965 SET_TOP(w);
966 SET_SECOND(x);
967 SET_THIRD(v);
Raymond Hettinger080cb322003-03-14 01:37:42 +0000968 goto fast_next_opcode;
Guido van Rossumac7be682001-01-17 15:42:30 +0000969
Thomas Wouters434d0822000-08-24 20:11:32 +0000970 case ROT_FOUR:
Raymond Hettinger663004b2003-01-09 15:24:30 +0000971 u = TOP();
972 v = SECOND();
973 w = THIRD();
974 x = FOURTH();
975 SET_TOP(v);
976 SET_SECOND(w);
977 SET_THIRD(x);
978 SET_FOURTH(u);
Raymond Hettinger080cb322003-03-14 01:37:42 +0000979 goto fast_next_opcode;
Guido van Rossumac7be682001-01-17 15:42:30 +0000980
Guido van Rossum374a9221991-04-04 10:40:29 +0000981 case DUP_TOP:
982 v = TOP();
Guido van Rossumb209a111997-04-29 18:18:01 +0000983 Py_INCREF(v);
Guido van Rossum374a9221991-04-04 10:40:29 +0000984 PUSH(v);
Raymond Hettinger080cb322003-03-14 01:37:42 +0000985 goto fast_next_opcode;
Guido van Rossumac7be682001-01-17 15:42:30 +0000986
Thomas Wouters434d0822000-08-24 20:11:32 +0000987 case DUP_TOPX:
Raymond Hettinger4bad9ba2003-01-19 05:08:13 +0000988 if (oparg == 2) {
Raymond Hettinger663004b2003-01-09 15:24:30 +0000989 x = TOP();
Tim Peters35ba6892000-10-11 07:04:49 +0000990 Py_INCREF(x);
Raymond Hettinger663004b2003-01-09 15:24:30 +0000991 w = SECOND();
Tim Peters35ba6892000-10-11 07:04:49 +0000992 Py_INCREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +0000993 STACKADJ(2);
994 SET_TOP(x);
995 SET_SECOND(w);
Raymond Hettingerf606f872003-03-16 03:11:04 +0000996 goto fast_next_opcode;
Raymond Hettinger4bad9ba2003-01-19 05:08:13 +0000997 } else if (oparg == 3) {
Raymond Hettinger663004b2003-01-09 15:24:30 +0000998 x = TOP();
Tim Peters35ba6892000-10-11 07:04:49 +0000999 Py_INCREF(x);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001000 w = SECOND();
Tim Peters35ba6892000-10-11 07:04:49 +00001001 Py_INCREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001002 v = THIRD();
Tim Peters35ba6892000-10-11 07:04:49 +00001003 Py_INCREF(v);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001004 STACKADJ(3);
1005 SET_TOP(x);
1006 SET_SECOND(w);
1007 SET_THIRD(v);
Raymond Hettingerf606f872003-03-16 03:11:04 +00001008 goto fast_next_opcode;
Thomas Wouters434d0822000-08-24 20:11:32 +00001009 }
Raymond Hettinger4bad9ba2003-01-19 05:08:13 +00001010 Py_FatalError("invalid argument to DUP_TOPX"
1011 " (bytecode corruption?)");
Tim Peters35ba6892000-10-11 07:04:49 +00001012 break;
Thomas Wouters434d0822000-08-24 20:11:32 +00001013
Guido van Rossum374a9221991-04-04 10:40:29 +00001014 case UNARY_POSITIVE:
Raymond Hettinger663004b2003-01-09 15:24:30 +00001015 v = TOP();
Guido van Rossumfc490731997-05-06 15:06:49 +00001016 x = PyNumber_Positive(v);
Guido van Rossumb209a111997-04-29 18:18:01 +00001017 Py_DECREF(v);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001018 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001019 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001020 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001021
Guido van Rossum374a9221991-04-04 10:40:29 +00001022 case UNARY_NEGATIVE:
Raymond Hettinger663004b2003-01-09 15:24:30 +00001023 v = TOP();
Guido van Rossumfc490731997-05-06 15:06:49 +00001024 x = PyNumber_Negative(v);
Guido van Rossumb209a111997-04-29 18:18:01 +00001025 Py_DECREF(v);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001026 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001027 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001028 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001029
Guido van Rossum374a9221991-04-04 10:40:29 +00001030 case UNARY_NOT:
Raymond Hettinger663004b2003-01-09 15:24:30 +00001031 v = TOP();
Guido van Rossumfc490731997-05-06 15:06:49 +00001032 err = PyObject_IsTrue(v);
Guido van Rossumb209a111997-04-29 18:18:01 +00001033 Py_DECREF(v);
Guido van Rossumfc490731997-05-06 15:06:49 +00001034 if (err == 0) {
1035 Py_INCREF(Py_True);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001036 SET_TOP(Py_True);
Guido van Rossumfc490731997-05-06 15:06:49 +00001037 continue;
1038 }
1039 else if (err > 0) {
1040 Py_INCREF(Py_False);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001041 SET_TOP(Py_False);
Guido van Rossumfc490731997-05-06 15:06:49 +00001042 err = 0;
1043 continue;
1044 }
Raymond Hettinger8bb90a52003-01-14 12:43:10 +00001045 STACKADJ(-1);
Guido van Rossum374a9221991-04-04 10:40:29 +00001046 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001047
Guido van Rossum7928cd71991-10-24 14:59:31 +00001048 case UNARY_INVERT:
Raymond Hettinger663004b2003-01-09 15:24:30 +00001049 v = TOP();
Guido van Rossumfc490731997-05-06 15:06:49 +00001050 x = PyNumber_Invert(v);
Guido van Rossumb209a111997-04-29 18:18:01 +00001051 Py_DECREF(v);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001052 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001053 if (x != NULL) continue;
Guido van Rossum7928cd71991-10-24 14:59:31 +00001054 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001055
Guido van Rossum50564e81996-01-12 01:13:16 +00001056 case BINARY_POWER:
1057 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001058 v = TOP();
Guido van Rossumfc490731997-05-06 15:06:49 +00001059 x = PyNumber_Power(v, w, Py_None);
Guido van Rossumb209a111997-04-29 18:18:01 +00001060 Py_DECREF(v);
1061 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001062 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001063 if (x != NULL) continue;
Guido van Rossum50564e81996-01-12 01:13:16 +00001064 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001065
Guido van Rossum374a9221991-04-04 10:40:29 +00001066 case BINARY_MULTIPLY:
1067 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001068 v = TOP();
Guido van Rossumfc490731997-05-06 15:06:49 +00001069 x = PyNumber_Multiply(v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +00001070 Py_DECREF(v);
1071 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001072 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001073 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001074 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001075
Tim Peters3caca232001-12-06 06:23:26 +00001076 case BINARY_TRUE_DIVIDE:
Guido van Rossum374a9221991-04-04 10:40:29 +00001077 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001078 v = TOP();
Tim Peters3caca232001-12-06 06:23:26 +00001079 x = PyNumber_TrueDivide(v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +00001080 Py_DECREF(v);
1081 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001082 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001083 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001084 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001085
Guido van Rossum4668b002001-08-08 05:00:18 +00001086 case BINARY_FLOOR_DIVIDE:
1087 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001088 v = TOP();
Guido van Rossum4668b002001-08-08 05:00:18 +00001089 x = PyNumber_FloorDivide(v, w);
1090 Py_DECREF(v);
1091 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001092 SET_TOP(x);
Guido van Rossum4668b002001-08-08 05:00:18 +00001093 if (x != NULL) continue;
1094 break;
1095
Guido van Rossum374a9221991-04-04 10:40:29 +00001096 case BINARY_MODULO:
1097 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001098 v = TOP();
Guido van Rossumfc490731997-05-06 15:06:49 +00001099 x = PyNumber_Remainder(v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +00001100 Py_DECREF(v);
1101 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001102 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001103 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001104 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001105
Guido van Rossum374a9221991-04-04 10:40:29 +00001106 case BINARY_ADD:
1107 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001108 v = TOP();
Tim Petersc1e6d962001-10-05 20:21:03 +00001109 if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
Guido van Rossumc12da691997-07-17 23:12:42 +00001110 /* INLINE: int + int */
1111 register long a, b, i;
Guido van Rossumcf183ac1998-12-04 18:51:36 +00001112 a = PyInt_AS_LONG(v);
1113 b = PyInt_AS_LONG(w);
Guido van Rossumc12da691997-07-17 23:12:42 +00001114 i = a + b;
Guido van Rossum87780df2001-08-23 02:58:07 +00001115 if ((i^a) < 0 && (i^b) < 0)
1116 goto slow_add;
1117 x = PyInt_FromLong(i);
Guido van Rossumc12da691997-07-17 23:12:42 +00001118 }
Raymond Hettinger52a21b82004-08-06 18:43:09 +00001119 else if (PyString_CheckExact(v) &&
1120 PyString_CheckExact(w)) {
1121 x = string_concatenate(v, w, f, next_instr);
1122 /* string_concatenate consumed the ref to v */
1123 goto skip_decref_vx;
1124 }
Guido van Rossum87780df2001-08-23 02:58:07 +00001125 else {
1126 slow_add:
Guido van Rossumc12da691997-07-17 23:12:42 +00001127 x = PyNumber_Add(v, w);
Guido van Rossum87780df2001-08-23 02:58:07 +00001128 }
Guido van Rossumb209a111997-04-29 18:18:01 +00001129 Py_DECREF(v);
Raymond Hettinger52a21b82004-08-06 18:43:09 +00001130 skip_decref_vx:
Guido van Rossumb209a111997-04-29 18:18:01 +00001131 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001132 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001133 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001134 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001135
Guido van Rossum374a9221991-04-04 10:40:29 +00001136 case BINARY_SUBTRACT:
1137 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001138 v = TOP();
Tim Petersc1e6d962001-10-05 20:21:03 +00001139 if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
Guido van Rossumc12da691997-07-17 23:12:42 +00001140 /* INLINE: int - int */
1141 register long a, b, i;
Guido van Rossumcf183ac1998-12-04 18:51:36 +00001142 a = PyInt_AS_LONG(v);
1143 b = PyInt_AS_LONG(w);
Guido van Rossumc12da691997-07-17 23:12:42 +00001144 i = a - b;
Guido van Rossum87780df2001-08-23 02:58:07 +00001145 if ((i^a) < 0 && (i^~b) < 0)
1146 goto slow_sub;
1147 x = PyInt_FromLong(i);
Guido van Rossumc12da691997-07-17 23:12:42 +00001148 }
Guido van Rossum87780df2001-08-23 02:58:07 +00001149 else {
1150 slow_sub:
Guido van Rossumc12da691997-07-17 23:12:42 +00001151 x = PyNumber_Subtract(v, w);
Guido van Rossum87780df2001-08-23 02:58:07 +00001152 }
Guido van Rossumb209a111997-04-29 18:18:01 +00001153 Py_DECREF(v);
1154 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001155 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001156 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001157 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001158
Guido van Rossum374a9221991-04-04 10:40:29 +00001159 case BINARY_SUBSCR:
1160 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001161 v = TOP();
Tim Petersb1c46982001-10-05 20:41:38 +00001162 if (PyList_CheckExact(v) && PyInt_CheckExact(w)) {
Guido van Rossumc12da691997-07-17 23:12:42 +00001163 /* INLINE: list[int] */
Neal Norwitz814e9382006-03-02 07:54:28 +00001164 Py_ssize_t i = PyInt_AsSsize_t(w);
Guido van Rossumc12da691997-07-17 23:12:42 +00001165 if (i < 0)
Guido van Rossumfa00e951998-07-08 15:02:37 +00001166 i += PyList_GET_SIZE(v);
Raymond Hettinger467a6982004-04-07 11:39:21 +00001167 if (i >= 0 && i < PyList_GET_SIZE(v)) {
Guido van Rossumfa00e951998-07-08 15:02:37 +00001168 x = PyList_GET_ITEM(v, i);
Guido van Rossumc12da691997-07-17 23:12:42 +00001169 Py_INCREF(x);
1170 }
Raymond Hettinger467a6982004-04-07 11:39:21 +00001171 else
1172 goto slow_get;
Guido van Rossumc12da691997-07-17 23:12:42 +00001173 }
1174 else
Raymond Hettinger467a6982004-04-07 11:39:21 +00001175 slow_get:
Guido van Rossumc12da691997-07-17 23:12:42 +00001176 x = PyObject_GetItem(v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +00001177 Py_DECREF(v);
1178 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001179 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001180 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001181 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001182
Guido van Rossum7928cd71991-10-24 14:59:31 +00001183 case BINARY_LSHIFT:
1184 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001185 v = TOP();
Guido van Rossumfc490731997-05-06 15:06:49 +00001186 x = PyNumber_Lshift(v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +00001187 Py_DECREF(v);
1188 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001189 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001190 if (x != NULL) continue;
Guido van Rossum7928cd71991-10-24 14:59:31 +00001191 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001192
Guido van Rossum7928cd71991-10-24 14:59:31 +00001193 case BINARY_RSHIFT:
1194 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001195 v = TOP();
Guido van Rossumfc490731997-05-06 15:06:49 +00001196 x = PyNumber_Rshift(v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +00001197 Py_DECREF(v);
1198 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001199 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001200 if (x != NULL) continue;
Guido van Rossum7928cd71991-10-24 14:59:31 +00001201 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001202
Guido van Rossum7928cd71991-10-24 14:59:31 +00001203 case BINARY_AND:
1204 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001205 v = TOP();
Guido van Rossumfc490731997-05-06 15:06:49 +00001206 x = PyNumber_And(v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +00001207 Py_DECREF(v);
1208 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001209 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001210 if (x != NULL) continue;
Guido van Rossum7928cd71991-10-24 14:59:31 +00001211 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001212
Guido van Rossum7928cd71991-10-24 14:59:31 +00001213 case BINARY_XOR:
1214 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001215 v = TOP();
Guido van Rossumfc490731997-05-06 15:06:49 +00001216 x = PyNumber_Xor(v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +00001217 Py_DECREF(v);
1218 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001219 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001220 if (x != NULL) continue;
Guido van Rossum7928cd71991-10-24 14:59:31 +00001221 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001222
Guido van Rossum7928cd71991-10-24 14:59:31 +00001223 case BINARY_OR:
1224 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001225 v = TOP();
Guido van Rossumfc490731997-05-06 15:06:49 +00001226 x = PyNumber_Or(v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +00001227 Py_DECREF(v);
1228 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001229 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001230 if (x != NULL) continue;
Guido van Rossum7928cd71991-10-24 14:59:31 +00001231 break;
Thomas Wouters434d0822000-08-24 20:11:32 +00001232
Raymond Hettingerdd80f762004-03-07 07:31:06 +00001233 case LIST_APPEND:
1234 w = POP();
1235 v = POP();
1236 err = PyList_Append(v, w);
1237 Py_DECREF(v);
1238 Py_DECREF(w);
Raymond Hettingerfba1cfc2004-03-12 16:33:17 +00001239 if (err == 0) {
1240 PREDICT(JUMP_ABSOLUTE);
1241 continue;
1242 }
Raymond Hettingerdd80f762004-03-07 07:31:06 +00001243 break;
1244
Thomas Wouters434d0822000-08-24 20:11:32 +00001245 case INPLACE_POWER:
1246 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001247 v = TOP();
Thomas Wouters434d0822000-08-24 20:11:32 +00001248 x = PyNumber_InPlacePower(v, w, Py_None);
1249 Py_DECREF(v);
1250 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001251 SET_TOP(x);
Thomas Wouters434d0822000-08-24 20:11:32 +00001252 if (x != NULL) continue;
1253 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001254
Thomas Wouters434d0822000-08-24 20:11:32 +00001255 case INPLACE_MULTIPLY:
1256 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001257 v = TOP();
Thomas Wouters434d0822000-08-24 20:11:32 +00001258 x = PyNumber_InPlaceMultiply(v, w);
1259 Py_DECREF(v);
1260 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001261 SET_TOP(x);
Thomas Wouters434d0822000-08-24 20:11:32 +00001262 if (x != NULL) continue;
1263 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001264
Tim Peters54b11912001-12-25 18:49:11 +00001265 case INPLACE_TRUE_DIVIDE:
Thomas Wouters434d0822000-08-24 20:11:32 +00001266 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001267 v = TOP();
Tim Peters54b11912001-12-25 18:49:11 +00001268 x = PyNumber_InPlaceTrueDivide(v, w);
Thomas Wouters434d0822000-08-24 20:11:32 +00001269 Py_DECREF(v);
1270 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001271 SET_TOP(x);
Thomas Wouters434d0822000-08-24 20:11:32 +00001272 if (x != NULL) continue;
1273 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001274
Guido van Rossum4668b002001-08-08 05:00:18 +00001275 case INPLACE_FLOOR_DIVIDE:
1276 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001277 v = TOP();
Guido van Rossum4668b002001-08-08 05:00:18 +00001278 x = PyNumber_InPlaceFloorDivide(v, w);
1279 Py_DECREF(v);
1280 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001281 SET_TOP(x);
Guido van Rossum4668b002001-08-08 05:00:18 +00001282 if (x != NULL) continue;
1283 break;
1284
Thomas Wouters434d0822000-08-24 20:11:32 +00001285 case INPLACE_MODULO:
1286 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001287 v = TOP();
Thomas Wouters434d0822000-08-24 20:11:32 +00001288 x = PyNumber_InPlaceRemainder(v, w);
1289 Py_DECREF(v);
1290 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001291 SET_TOP(x);
Thomas Wouters434d0822000-08-24 20:11:32 +00001292 if (x != NULL) continue;
1293 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001294
Thomas Wouters434d0822000-08-24 20:11:32 +00001295 case INPLACE_ADD:
1296 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001297 v = TOP();
Tim Petersc1e6d962001-10-05 20:21:03 +00001298 if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
Thomas Wouters434d0822000-08-24 20:11:32 +00001299 /* INLINE: int + int */
1300 register long a, b, i;
1301 a = PyInt_AS_LONG(v);
1302 b = PyInt_AS_LONG(w);
1303 i = a + b;
Guido van Rossum87780df2001-08-23 02:58:07 +00001304 if ((i^a) < 0 && (i^b) < 0)
1305 goto slow_iadd;
1306 x = PyInt_FromLong(i);
Thomas Wouters434d0822000-08-24 20:11:32 +00001307 }
Raymond Hettinger52a21b82004-08-06 18:43:09 +00001308 else if (PyString_CheckExact(v) &&
1309 PyString_CheckExact(w)) {
1310 x = string_concatenate(v, w, f, next_instr);
1311 /* string_concatenate consumed the ref to v */
1312 goto skip_decref_v;
1313 }
Guido van Rossum87780df2001-08-23 02:58:07 +00001314 else {
1315 slow_iadd:
Thomas Wouters434d0822000-08-24 20:11:32 +00001316 x = PyNumber_InPlaceAdd(v, w);
Guido van Rossum87780df2001-08-23 02:58:07 +00001317 }
Thomas Wouters434d0822000-08-24 20:11:32 +00001318 Py_DECREF(v);
Raymond Hettinger52a21b82004-08-06 18:43:09 +00001319 skip_decref_v:
Thomas Wouters434d0822000-08-24 20:11:32 +00001320 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001321 SET_TOP(x);
Thomas Wouters434d0822000-08-24 20:11:32 +00001322 if (x != NULL) continue;
1323 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001324
Thomas Wouters434d0822000-08-24 20:11:32 +00001325 case INPLACE_SUBTRACT:
1326 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001327 v = TOP();
Tim Petersc1e6d962001-10-05 20:21:03 +00001328 if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
Thomas Wouters434d0822000-08-24 20:11:32 +00001329 /* INLINE: int - int */
1330 register long a, b, i;
1331 a = PyInt_AS_LONG(v);
1332 b = PyInt_AS_LONG(w);
1333 i = a - b;
Guido van Rossum87780df2001-08-23 02:58:07 +00001334 if ((i^a) < 0 && (i^~b) < 0)
1335 goto slow_isub;
1336 x = PyInt_FromLong(i);
Thomas Wouters434d0822000-08-24 20:11:32 +00001337 }
Guido van Rossum87780df2001-08-23 02:58:07 +00001338 else {
1339 slow_isub:
Thomas Wouters434d0822000-08-24 20:11:32 +00001340 x = PyNumber_InPlaceSubtract(v, w);
Guido van Rossum87780df2001-08-23 02:58:07 +00001341 }
Thomas Wouters434d0822000-08-24 20:11:32 +00001342 Py_DECREF(v);
1343 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001344 SET_TOP(x);
Thomas Wouters434d0822000-08-24 20:11:32 +00001345 if (x != NULL) continue;
1346 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001347
Thomas Wouters434d0822000-08-24 20:11:32 +00001348 case INPLACE_LSHIFT:
1349 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001350 v = TOP();
Thomas Wouters434d0822000-08-24 20:11:32 +00001351 x = PyNumber_InPlaceLshift(v, w);
1352 Py_DECREF(v);
1353 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001354 SET_TOP(x);
Thomas Wouters434d0822000-08-24 20:11:32 +00001355 if (x != NULL) continue;
1356 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001357
Thomas Wouters434d0822000-08-24 20:11:32 +00001358 case INPLACE_RSHIFT:
1359 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001360 v = TOP();
Thomas Wouters434d0822000-08-24 20:11:32 +00001361 x = PyNumber_InPlaceRshift(v, w);
1362 Py_DECREF(v);
1363 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001364 SET_TOP(x);
Thomas Wouters434d0822000-08-24 20:11:32 +00001365 if (x != NULL) continue;
1366 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001367
Thomas Wouters434d0822000-08-24 20:11:32 +00001368 case INPLACE_AND:
1369 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001370 v = TOP();
Thomas Wouters434d0822000-08-24 20:11:32 +00001371 x = PyNumber_InPlaceAnd(v, w);
1372 Py_DECREF(v);
1373 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001374 SET_TOP(x);
Thomas Wouters434d0822000-08-24 20:11:32 +00001375 if (x != NULL) continue;
1376 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001377
Thomas Wouters434d0822000-08-24 20:11:32 +00001378 case INPLACE_XOR:
1379 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001380 v = TOP();
Thomas Wouters434d0822000-08-24 20:11:32 +00001381 x = PyNumber_InPlaceXor(v, w);
1382 Py_DECREF(v);
1383 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001384 SET_TOP(x);
Thomas Wouters434d0822000-08-24 20:11:32 +00001385 if (x != NULL) continue;
1386 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001387
Thomas Wouters434d0822000-08-24 20:11:32 +00001388 case INPLACE_OR:
1389 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001390 v = TOP();
Thomas Wouters434d0822000-08-24 20:11:32 +00001391 x = PyNumber_InPlaceOr(v, w);
1392 Py_DECREF(v);
1393 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001394 SET_TOP(x);
Thomas Wouters434d0822000-08-24 20:11:32 +00001395 if (x != NULL) continue;
1396 break;
1397
Guido van Rossum374a9221991-04-04 10:40:29 +00001398 case SLICE+0:
1399 case SLICE+1:
1400 case SLICE+2:
1401 case SLICE+3:
1402 if ((opcode-SLICE) & 2)
1403 w = POP();
1404 else
1405 w = NULL;
1406 if ((opcode-SLICE) & 1)
1407 v = POP();
1408 else
1409 v = NULL;
Raymond Hettinger663004b2003-01-09 15:24:30 +00001410 u = TOP();
Guido van Rossum374a9221991-04-04 10:40:29 +00001411 x = apply_slice(u, v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +00001412 Py_DECREF(u);
1413 Py_XDECREF(v);
1414 Py_XDECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001415 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001416 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001417 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001418
Guido van Rossum374a9221991-04-04 10:40:29 +00001419 case STORE_SLICE+0:
1420 case STORE_SLICE+1:
1421 case STORE_SLICE+2:
1422 case STORE_SLICE+3:
1423 if ((opcode-STORE_SLICE) & 2)
1424 w = POP();
1425 else
1426 w = NULL;
1427 if ((opcode-STORE_SLICE) & 1)
1428 v = POP();
1429 else
1430 v = NULL;
1431 u = POP();
1432 t = POP();
1433 err = assign_slice(u, v, w, t); /* u[v:w] = t */
Guido van Rossumb209a111997-04-29 18:18:01 +00001434 Py_DECREF(t);
1435 Py_DECREF(u);
1436 Py_XDECREF(v);
1437 Py_XDECREF(w);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001438 if (err == 0) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001439 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001440
Guido van Rossum374a9221991-04-04 10:40:29 +00001441 case DELETE_SLICE+0:
1442 case DELETE_SLICE+1:
1443 case DELETE_SLICE+2:
1444 case DELETE_SLICE+3:
1445 if ((opcode-DELETE_SLICE) & 2)
1446 w = POP();
1447 else
1448 w = NULL;
1449 if ((opcode-DELETE_SLICE) & 1)
1450 v = POP();
1451 else
1452 v = NULL;
1453 u = POP();
Guido van Rossumb209a111997-04-29 18:18:01 +00001454 err = assign_slice(u, v, w, (PyObject *)NULL);
Guido van Rossum374a9221991-04-04 10:40:29 +00001455 /* del u[v:w] */
Guido van Rossumb209a111997-04-29 18:18:01 +00001456 Py_DECREF(u);
1457 Py_XDECREF(v);
1458 Py_XDECREF(w);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001459 if (err == 0) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001460 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001461
Guido van Rossum374a9221991-04-04 10:40:29 +00001462 case STORE_SUBSCR:
Raymond Hettinger663004b2003-01-09 15:24:30 +00001463 w = TOP();
1464 v = SECOND();
1465 u = THIRD();
1466 STACKADJ(-3);
Guido van Rossum374a9221991-04-04 10:40:29 +00001467 /* v[w] = u */
Guido van Rossumfc490731997-05-06 15:06:49 +00001468 err = PyObject_SetItem(v, w, u);
Guido van Rossumb209a111997-04-29 18:18:01 +00001469 Py_DECREF(u);
1470 Py_DECREF(v);
1471 Py_DECREF(w);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001472 if (err == 0) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001473 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001474
Guido van Rossum374a9221991-04-04 10:40:29 +00001475 case DELETE_SUBSCR:
Raymond Hettinger663004b2003-01-09 15:24:30 +00001476 w = TOP();
1477 v = SECOND();
1478 STACKADJ(-2);
Guido van Rossum374a9221991-04-04 10:40:29 +00001479 /* del v[w] */
Guido van Rossumfc490731997-05-06 15:06:49 +00001480 err = PyObject_DelItem(v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +00001481 Py_DECREF(v);
1482 Py_DECREF(w);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001483 if (err == 0) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001484 break;
Barry Warsaw23c9ec82000-08-21 15:44:01 +00001485
Guido van Rossum374a9221991-04-04 10:40:29 +00001486 case PRINT_EXPR:
1487 v = POP();
Moshe Zadkaf68f2fe2001-01-11 05:41:27 +00001488 w = PySys_GetObject("displayhook");
1489 if (w == NULL) {
1490 PyErr_SetString(PyExc_RuntimeError,
1491 "lost sys.displayhook");
1492 err = -1;
Moshe Zadkaf5df3832001-01-11 11:55:37 +00001493 x = NULL;
Moshe Zadkaf68f2fe2001-01-11 05:41:27 +00001494 }
1495 if (err == 0) {
Raymond Hettinger8ae46892003-10-12 19:09:37 +00001496 x = PyTuple_Pack(1, v);
Moshe Zadkaf68f2fe2001-01-11 05:41:27 +00001497 if (x == NULL)
1498 err = -1;
1499 }
1500 if (err == 0) {
1501 w = PyEval_CallObject(w, x);
Moshe Zadkaf5df3832001-01-11 11:55:37 +00001502 Py_XDECREF(w);
Moshe Zadkaf68f2fe2001-01-11 05:41:27 +00001503 if (w == NULL)
1504 err = -1;
Guido van Rossum374a9221991-04-04 10:40:29 +00001505 }
Guido van Rossumb209a111997-04-29 18:18:01 +00001506 Py_DECREF(v);
Moshe Zadkaf68f2fe2001-01-11 05:41:27 +00001507 Py_XDECREF(x);
Guido van Rossum374a9221991-04-04 10:40:29 +00001508 break;
Moshe Zadkaf68f2fe2001-01-11 05:41:27 +00001509
Thomas Wouters434d0822000-08-24 20:11:32 +00001510#ifdef CASE_TOO_BIG
1511 default: switch (opcode) {
1512#endif
Guido van Rossumf10570b1995-07-07 22:53:21 +00001513 case RAISE_VARARGS:
1514 u = v = w = NULL;
1515 switch (oparg) {
1516 case 3:
1517 u = POP(); /* traceback */
Guido van Rossumf10570b1995-07-07 22:53:21 +00001518 /* Fallthrough */
1519 case 2:
1520 v = POP(); /* value */
1521 /* Fallthrough */
1522 case 1:
1523 w = POP(); /* exc */
Guido van Rossumd295f121998-04-09 21:39:57 +00001524 case 0: /* Fallthrough */
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00001525 why = do_raise(w, v, u);
Guido van Rossumf10570b1995-07-07 22:53:21 +00001526 break;
1527 default:
Guido van Rossumb209a111997-04-29 18:18:01 +00001528 PyErr_SetString(PyExc_SystemError,
Guido van Rossumf10570b1995-07-07 22:53:21 +00001529 "bad RAISE_VARARGS oparg");
Guido van Rossumf10570b1995-07-07 22:53:21 +00001530 why = WHY_EXCEPTION;
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00001531 break;
1532 }
Guido van Rossum374a9221991-04-04 10:40:29 +00001533 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001534
Guido van Rossum374a9221991-04-04 10:40:29 +00001535 case LOAD_LOCALS:
Raymond Hettinger467a6982004-04-07 11:39:21 +00001536 if ((x = f->f_locals) != NULL) {
1537 Py_INCREF(x);
1538 PUSH(x);
1539 continue;
Guido van Rossum681d79a1995-07-18 14:51:37 +00001540 }
Raymond Hettinger467a6982004-04-07 11:39:21 +00001541 PyErr_SetString(PyExc_SystemError, "no locals");
Guido van Rossum374a9221991-04-04 10:40:29 +00001542 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001543
Guido van Rossum374a9221991-04-04 10:40:29 +00001544 case RETURN_VALUE:
1545 retval = POP();
1546 why = WHY_RETURN;
Raymond Hettinger1dd83092004-02-06 18:32:33 +00001547 goto fast_block_end;
Guido van Rossumdb3165e1993-10-18 17:06:59 +00001548
Tim Peters5ca576e2001-06-18 22:08:13 +00001549 case YIELD_VALUE:
1550 retval = POP();
Tim Peters8c963692001-06-23 05:26:56 +00001551 f->f_stacktop = stack_pointer;
Tim Peters5ca576e2001-06-18 22:08:13 +00001552 why = WHY_YIELD;
Raymond Hettinger1dd83092004-02-06 18:32:33 +00001553 goto fast_yield;
Tim Peters5ca576e2001-06-18 22:08:13 +00001554
Guido van Rossum374a9221991-04-04 10:40:29 +00001555 case POP_BLOCK:
1556 {
Guido van Rossumb209a111997-04-29 18:18:01 +00001557 PyTryBlock *b = PyFrame_BlockPop(f);
Guido van Rossum374a9221991-04-04 10:40:29 +00001558 while (STACK_LEVEL() > b->b_level) {
1559 v = POP();
Guido van Rossumb209a111997-04-29 18:18:01 +00001560 Py_DECREF(v);
Guido van Rossum374a9221991-04-04 10:40:29 +00001561 }
1562 }
Raymond Hettinger7eddd782004-04-07 14:38:08 +00001563 continue;
Guido van Rossumac7be682001-01-17 15:42:30 +00001564
Guido van Rossum374a9221991-04-04 10:40:29 +00001565 case END_FINALLY:
1566 v = POP();
Guido van Rossumb209a111997-04-29 18:18:01 +00001567 if (PyInt_Check(v)) {
Raymond Hettinger7c958652004-04-06 10:11:10 +00001568 why = (enum why_code) PyInt_AS_LONG(v);
Tim Peters8a5c3c72004-04-05 19:36:21 +00001569 assert(why != WHY_YIELD);
Raymond Hettingerc8aa08b2004-04-11 14:59:33 +00001570 if (why == WHY_RETURN ||
1571 why == WHY_CONTINUE)
Guido van Rossum374a9221991-04-04 10:40:29 +00001572 retval = POP();
1573 }
Brett Cannonf74225d2007-02-26 21:10:16 +00001574 else if (PyExceptionClass_Check(v)) {
Guido van Rossum374a9221991-04-04 10:40:29 +00001575 w = POP();
Guido van Rossumf10570b1995-07-07 22:53:21 +00001576 u = POP();
Guido van Rossumb209a111997-04-29 18:18:01 +00001577 PyErr_Restore(v, w, u);
Guido van Rossum374a9221991-04-04 10:40:29 +00001578 why = WHY_RERAISE;
Guido van Rossum0db1ef91995-07-28 23:06:00 +00001579 break;
Guido van Rossum374a9221991-04-04 10:40:29 +00001580 }
Guido van Rossumb209a111997-04-29 18:18:01 +00001581 else if (v != Py_None) {
1582 PyErr_SetString(PyExc_SystemError,
Guido van Rossum374a9221991-04-04 10:40:29 +00001583 "'finally' pops bad exception");
1584 why = WHY_EXCEPTION;
1585 }
Guido van Rossumb209a111997-04-29 18:18:01 +00001586 Py_DECREF(v);
Guido van Rossum374a9221991-04-04 10:40:29 +00001587 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001588
Guido van Rossum374a9221991-04-04 10:40:29 +00001589 case BUILD_CLASS:
Raymond Hettinger663004b2003-01-09 15:24:30 +00001590 u = TOP();
1591 v = SECOND();
1592 w = THIRD();
1593 STACKADJ(-2);
Guido van Rossum25831651993-05-19 14:50:45 +00001594 x = build_class(u, v, w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001595 SET_TOP(x);
Guido van Rossumb209a111997-04-29 18:18:01 +00001596 Py_DECREF(u);
1597 Py_DECREF(v);
1598 Py_DECREF(w);
Guido van Rossum374a9221991-04-04 10:40:29 +00001599 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001600
Guido van Rossum374a9221991-04-04 10:40:29 +00001601 case STORE_NAME:
Skip Montanaro496e6582002-08-06 17:47:40 +00001602 w = GETITEM(names, oparg);
Guido van Rossum374a9221991-04-04 10:40:29 +00001603 v = POP();
Raymond Hettinger467a6982004-04-07 11:39:21 +00001604 if ((x = f->f_locals) != NULL) {
Raymond Hettinger66bd2332004-08-02 08:30:07 +00001605 if (PyDict_CheckExact(x))
Raymond Hettinger214b1c32004-07-02 06:41:07 +00001606 err = PyDict_SetItem(x, w, v);
1607 else
1608 err = PyObject_SetItem(x, w, v);
Raymond Hettinger467a6982004-04-07 11:39:21 +00001609 Py_DECREF(v);
Raymond Hettinger7eddd782004-04-07 14:38:08 +00001610 if (err == 0) continue;
Guido van Rossum681d79a1995-07-18 14:51:37 +00001611 break;
1612 }
Raymond Hettinger467a6982004-04-07 11:39:21 +00001613 PyErr_Format(PyExc_SystemError,
1614 "no locals found when storing %s",
1615 PyObject_REPR(w));
Guido van Rossum374a9221991-04-04 10:40:29 +00001616 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001617
Guido van Rossum374a9221991-04-04 10:40:29 +00001618 case DELETE_NAME:
Skip Montanaro496e6582002-08-06 17:47:40 +00001619 w = GETITEM(names, oparg);
Raymond Hettinger467a6982004-04-07 11:39:21 +00001620 if ((x = f->f_locals) != NULL) {
Raymond Hettinger214b1c32004-07-02 06:41:07 +00001621 if ((err = PyObject_DelItem(x, w)) != 0)
Raymond Hettinger467a6982004-04-07 11:39:21 +00001622 format_exc_check_arg(PyExc_NameError,
1623 NAME_ERROR_MSG ,w);
Guido van Rossum681d79a1995-07-18 14:51:37 +00001624 break;
1625 }
Raymond Hettinger467a6982004-04-07 11:39:21 +00001626 PyErr_Format(PyExc_SystemError,
1627 "no locals when deleting %s",
1628 PyObject_REPR(w));
Guido van Rossum374a9221991-04-04 10:40:29 +00001629 break;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001630
Raymond Hettinger7dc52212003-03-16 20:14:44 +00001631 PREDICTED_WITH_ARG(UNPACK_SEQUENCE);
Thomas Wouters0be5aab2000-08-11 22:15:52 +00001632 case UNPACK_SEQUENCE:
Guido van Rossum374a9221991-04-04 10:40:29 +00001633 v = POP();
Raymond Hettingerf114a3a2004-03-08 23:25:30 +00001634 if (PyTuple_CheckExact(v) && PyTuple_GET_SIZE(v) == oparg) {
1635 PyObject **items = ((PyTupleObject *)v)->ob_item;
1636 while (oparg--) {
1637 w = items[oparg];
1638 Py_INCREF(w);
1639 PUSH(w);
Barry Warsawe42b18f1997-08-25 22:13:04 +00001640 }
Raymond Hettinger7eddd782004-04-07 14:38:08 +00001641 Py_DECREF(v);
1642 continue;
Raymond Hettingerf114a3a2004-03-08 23:25:30 +00001643 } else if (PyList_CheckExact(v) && PyList_GET_SIZE(v) == oparg) {
1644 PyObject **items = ((PyListObject *)v)->ob_item;
1645 while (oparg--) {
1646 w = items[oparg];
1647 Py_INCREF(w);
1648 PUSH(w);
Barry Warsawe42b18f1997-08-25 22:13:04 +00001649 }
Raymond Hettingerf114a3a2004-03-08 23:25:30 +00001650 } else if (unpack_iterable(v, oparg,
Tim Petersd6d010b2001-06-21 02:49:55 +00001651 stack_pointer + oparg))
1652 stack_pointer += oparg;
Tim Peters8b13b3e2001-09-30 05:58:42 +00001653 else {
1654 if (PyErr_ExceptionMatches(PyExc_TypeError))
1655 PyErr_SetString(PyExc_TypeError,
1656 "unpack non-sequence");
Barry Warsawe42b18f1997-08-25 22:13:04 +00001657 why = WHY_EXCEPTION;
Tim Peters8b13b3e2001-09-30 05:58:42 +00001658 }
Guido van Rossumb209a111997-04-29 18:18:01 +00001659 Py_DECREF(v);
Guido van Rossum374a9221991-04-04 10:40:29 +00001660 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001661
Guido van Rossum374a9221991-04-04 10:40:29 +00001662 case STORE_ATTR:
Skip Montanaro496e6582002-08-06 17:47:40 +00001663 w = GETITEM(names, oparg);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001664 v = TOP();
1665 u = SECOND();
1666 STACKADJ(-2);
Guido van Rossumb209a111997-04-29 18:18:01 +00001667 err = PyObject_SetAttr(v, w, u); /* v.w = u */
1668 Py_DECREF(v);
1669 Py_DECREF(u);
Raymond Hettinger7eddd782004-04-07 14:38:08 +00001670 if (err == 0) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001671 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001672
Guido van Rossum374a9221991-04-04 10:40:29 +00001673 case DELETE_ATTR:
Skip Montanaro496e6582002-08-06 17:47:40 +00001674 w = GETITEM(names, oparg);
Guido van Rossum374a9221991-04-04 10:40:29 +00001675 v = POP();
Guido van Rossuma027efa1997-05-05 20:56:21 +00001676 err = PyObject_SetAttr(v, w, (PyObject *)NULL);
1677 /* del v.w */
Guido van Rossumb209a111997-04-29 18:18:01 +00001678 Py_DECREF(v);
Guido van Rossum374a9221991-04-04 10:40:29 +00001679 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001680
Guido van Rossum32c6cdf1991-12-10 13:52:46 +00001681 case STORE_GLOBAL:
Skip Montanaro496e6582002-08-06 17:47:40 +00001682 w = GETITEM(names, oparg);
Guido van Rossum32c6cdf1991-12-10 13:52:46 +00001683 v = POP();
Guido van Rossumb209a111997-04-29 18:18:01 +00001684 err = PyDict_SetItem(f->f_globals, w, v);
1685 Py_DECREF(v);
Raymond Hettinger7eddd782004-04-07 14:38:08 +00001686 if (err == 0) continue;
Guido van Rossum32c6cdf1991-12-10 13:52:46 +00001687 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001688
Guido van Rossum32c6cdf1991-12-10 13:52:46 +00001689 case DELETE_GLOBAL:
Skip Montanaro496e6582002-08-06 17:47:40 +00001690 w = GETITEM(names, oparg);
Guido van Rossumb209a111997-04-29 18:18:01 +00001691 if ((err = PyDict_DelItem(f->f_globals, w)) != 0)
Paul Prescode68140d2000-08-30 20:25:01 +00001692 format_exc_check_arg(
Jeremy Hylton64949cb2001-01-25 20:06:59 +00001693 PyExc_NameError, GLOBAL_NAME_ERROR_MSG, w);
Guido van Rossum32c6cdf1991-12-10 13:52:46 +00001694 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001695
Guido van Rossum374a9221991-04-04 10:40:29 +00001696 case LOAD_NAME:
Skip Montanaro496e6582002-08-06 17:47:40 +00001697 w = GETITEM(names, oparg);
Raymond Hettinger214b1c32004-07-02 06:41:07 +00001698 if ((v = f->f_locals) == NULL) {
Jeremy Hyltonc862cf42001-01-19 03:25:05 +00001699 PyErr_Format(PyExc_SystemError,
1700 "no locals when loading %s",
Jeremy Hylton483638c2001-02-01 20:20:45 +00001701 PyObject_REPR(w));
Guido van Rossum681d79a1995-07-18 14:51:37 +00001702 break;
1703 }
Michael W. Hudsona3711f72004-08-02 14:50:43 +00001704 if (PyDict_CheckExact(v)) {
Raymond Hettinger214b1c32004-07-02 06:41:07 +00001705 x = PyDict_GetItem(v, w);
Michael W. Hudsona3711f72004-08-02 14:50:43 +00001706 Py_XINCREF(x);
1707 }
Raymond Hettinger214b1c32004-07-02 06:41:07 +00001708 else {
1709 x = PyObject_GetItem(v, w);
1710 if (x == NULL && PyErr_Occurred()) {
1711 if (!PyErr_ExceptionMatches(PyExc_KeyError))
1712 break;
1713 PyErr_Clear();
1714 }
1715 }
Guido van Rossum374a9221991-04-04 10:40:29 +00001716 if (x == NULL) {
Guido van Rossumb209a111997-04-29 18:18:01 +00001717 x = PyDict_GetItem(f->f_globals, w);
Guido van Rossum374a9221991-04-04 10:40:29 +00001718 if (x == NULL) {
Guido van Rossumb209a111997-04-29 18:18:01 +00001719 x = PyDict_GetItem(f->f_builtins, w);
Guido van Rossum374a9221991-04-04 10:40:29 +00001720 if (x == NULL) {
Paul Prescode68140d2000-08-30 20:25:01 +00001721 format_exc_check_arg(
Guido van Rossumac7be682001-01-17 15:42:30 +00001722 PyExc_NameError,
Paul Prescode68140d2000-08-30 20:25:01 +00001723 NAME_ERROR_MSG ,w);
Guido van Rossum374a9221991-04-04 10:40:29 +00001724 break;
1725 }
1726 }
Michael W. Hudsona3711f72004-08-02 14:50:43 +00001727 Py_INCREF(x);
Guido van Rossum374a9221991-04-04 10:40:29 +00001728 }
Guido van Rossum374a9221991-04-04 10:40:29 +00001729 PUSH(x);
Raymond Hettinger467a6982004-04-07 11:39:21 +00001730 continue;
Guido van Rossumac7be682001-01-17 15:42:30 +00001731
Guido van Rossum374a9221991-04-04 10:40:29 +00001732 case LOAD_GLOBAL:
Skip Montanaro496e6582002-08-06 17:47:40 +00001733 w = GETITEM(names, oparg);
Guido van Rossum3a4dfc82002-08-19 20:24:07 +00001734 if (PyString_CheckExact(w)) {
Guido van Rossumd8dbf842002-08-19 21:17:53 +00001735 /* Inline the PyDict_GetItem() calls.
1736 WARNING: this is an extreme speed hack.
1737 Do not try this at home. */
Guido van Rossum3a4dfc82002-08-19 20:24:07 +00001738 long hash = ((PyStringObject *)w)->ob_shash;
1739 if (hash != -1) {
Guido van Rossum3a4dfc82002-08-19 20:24:07 +00001740 PyDictObject *d;
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001741 PyDictEntry *e;
Guido van Rossum3a4dfc82002-08-19 20:24:07 +00001742 d = (PyDictObject *)(f->f_globals);
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001743 e = d->ma_lookup(d, w, hash);
1744 if (e == NULL) {
1745 x = NULL;
1746 break;
1747 }
1748 x = e->me_value;
Guido van Rossum3a4dfc82002-08-19 20:24:07 +00001749 if (x != NULL) {
1750 Py_INCREF(x);
1751 PUSH(x);
1752 continue;
1753 }
1754 d = (PyDictObject *)(f->f_builtins);
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00001755 e = d->ma_lookup(d, w, hash);
1756 if (e == NULL) {
1757 x = NULL;
1758 break;
1759 }
1760 x = e->me_value;
Guido van Rossum3a4dfc82002-08-19 20:24:07 +00001761 if (x != NULL) {
1762 Py_INCREF(x);
1763 PUSH(x);
1764 continue;
1765 }
1766 goto load_global_error;
1767 }
1768 }
1769 /* This is the un-inlined version of the code above */
Guido van Rossumb209a111997-04-29 18:18:01 +00001770 x = PyDict_GetItem(f->f_globals, w);
Guido van Rossum374a9221991-04-04 10:40:29 +00001771 if (x == NULL) {
Guido van Rossumb209a111997-04-29 18:18:01 +00001772 x = PyDict_GetItem(f->f_builtins, w);
Guido van Rossum374a9221991-04-04 10:40:29 +00001773 if (x == NULL) {
Guido van Rossum3a4dfc82002-08-19 20:24:07 +00001774 load_global_error:
Paul Prescode68140d2000-08-30 20:25:01 +00001775 format_exc_check_arg(
Guido van Rossumac7be682001-01-17 15:42:30 +00001776 PyExc_NameError,
Guido van Rossum3a4dfc82002-08-19 20:24:07 +00001777 GLOBAL_NAME_ERROR_MSG, w);
Guido van Rossum374a9221991-04-04 10:40:29 +00001778 break;
1779 }
1780 }
Guido van Rossumb209a111997-04-29 18:18:01 +00001781 Py_INCREF(x);
Guido van Rossum374a9221991-04-04 10:40:29 +00001782 PUSH(x);
Raymond Hettinger7eddd782004-04-07 14:38:08 +00001783 continue;
Guido van Rossum681d79a1995-07-18 14:51:37 +00001784
Guido van Rossum8b17d6b1993-03-30 13:18:41 +00001785 case DELETE_FAST:
Guido van Rossum2e4c8991998-05-12 20:27:36 +00001786 x = GETLOCAL(oparg);
Raymond Hettinger467a6982004-04-07 11:39:21 +00001787 if (x != NULL) {
1788 SETLOCAL(oparg, NULL);
1789 continue;
Guido van Rossum2e4c8991998-05-12 20:27:36 +00001790 }
Raymond Hettinger467a6982004-04-07 11:39:21 +00001791 format_exc_check_arg(
1792 PyExc_UnboundLocalError,
1793 UNBOUNDLOCAL_ERROR_MSG,
1794 PyTuple_GetItem(co->co_varnames, oparg)
1795 );
1796 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001797
Jeremy Hylton64949cb2001-01-25 20:06:59 +00001798 case LOAD_CLOSURE:
Jeremy Hylton2b724da2001-01-29 22:51:52 +00001799 x = freevars[oparg];
Jeremy Hylton64949cb2001-01-25 20:06:59 +00001800 Py_INCREF(x);
1801 PUSH(x);
Raymond Hettinger7eddd782004-04-07 14:38:08 +00001802 if (x != NULL) continue;
Jeremy Hylton64949cb2001-01-25 20:06:59 +00001803 break;
1804
1805 case LOAD_DEREF:
Jeremy Hylton2b724da2001-01-29 22:51:52 +00001806 x = freevars[oparg];
Jeremy Hylton64949cb2001-01-25 20:06:59 +00001807 w = PyCell_Get(x);
Raymond Hettinger467a6982004-04-07 11:39:21 +00001808 if (w != NULL) {
1809 PUSH(w);
1810 continue;
Jeremy Hylton2524d692001-02-05 17:23:16 +00001811 }
Raymond Hettinger467a6982004-04-07 11:39:21 +00001812 err = -1;
1813 /* Don't stomp existing exception */
1814 if (PyErr_Occurred())
1815 break;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001816 if (oparg < PyTuple_GET_SIZE(co->co_cellvars)) {
1817 v = PyTuple_GET_ITEM(co->co_cellvars,
Raymond Hettinger467a6982004-04-07 11:39:21 +00001818 oparg);
1819 format_exc_check_arg(
1820 PyExc_UnboundLocalError,
1821 UNBOUNDLOCAL_ERROR_MSG,
1822 v);
1823 } else {
Thomas Wouters477c8d52006-05-27 19:21:47 +00001824 v = PyTuple_GET_ITEM(
Raymond Hettinger467a6982004-04-07 11:39:21 +00001825 co->co_freevars,
Thomas Wouters477c8d52006-05-27 19:21:47 +00001826 oparg - PyTuple_GET_SIZE(co->co_cellvars));
Raymond Hettinger467a6982004-04-07 11:39:21 +00001827 format_exc_check_arg(
1828 PyExc_NameError,
1829 UNBOUNDFREE_ERROR_MSG,
1830 v);
1831 }
Jeremy Hylton64949cb2001-01-25 20:06:59 +00001832 break;
1833
1834 case STORE_DEREF:
1835 w = POP();
Jeremy Hylton2b724da2001-01-29 22:51:52 +00001836 x = freevars[oparg];
Jeremy Hylton64949cb2001-01-25 20:06:59 +00001837 PyCell_Set(x, w);
Jeremy Hylton30c9f392001-03-13 01:58:22 +00001838 Py_DECREF(w);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00001839 continue;
1840
Guido van Rossum374a9221991-04-04 10:40:29 +00001841 case BUILD_TUPLE:
Guido van Rossumb209a111997-04-29 18:18:01 +00001842 x = PyTuple_New(oparg);
Guido van Rossum374a9221991-04-04 10:40:29 +00001843 if (x != NULL) {
Raymond Hettinger5bed4562004-04-10 23:34:17 +00001844 for (; --oparg >= 0;) {
Guido van Rossum374a9221991-04-04 10:40:29 +00001845 w = POP();
Guido van Rossumb209a111997-04-29 18:18:01 +00001846 PyTuple_SET_ITEM(x, oparg, w);
Guido van Rossum374a9221991-04-04 10:40:29 +00001847 }
1848 PUSH(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001849 continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001850 }
1851 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001852
Guido van Rossum374a9221991-04-04 10:40:29 +00001853 case BUILD_LIST:
Guido van Rossumb209a111997-04-29 18:18:01 +00001854 x = PyList_New(oparg);
Guido van Rossum374a9221991-04-04 10:40:29 +00001855 if (x != NULL) {
Raymond Hettinger5bed4562004-04-10 23:34:17 +00001856 for (; --oparg >= 0;) {
Guido van Rossum374a9221991-04-04 10:40:29 +00001857 w = POP();
Guido van Rossum5053efc1998-08-04 15:27:50 +00001858 PyList_SET_ITEM(x, oparg, w);
Guido van Rossum374a9221991-04-04 10:40:29 +00001859 }
1860 PUSH(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001861 continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001862 }
1863 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001864
Guido van Rossum86e58e22006-08-28 15:27:34 +00001865 case BUILD_SET:
1866 x = PySet_New(NULL);
1867 if (x != NULL) {
1868 for (; --oparg >= 0;) {
1869 w = POP();
1870 if (err == 0)
1871 err = PySet_Add(x, w);
1872 Py_DECREF(w);
1873 }
1874 if (err != 0) {
1875 Py_DECREF(x);
1876 break;
1877 }
1878 PUSH(x);
1879 continue;
1880 }
1881 break;
1882
Guido van Rossum374a9221991-04-04 10:40:29 +00001883 case BUILD_MAP:
Guido van Rossumb209a111997-04-29 18:18:01 +00001884 x = PyDict_New();
Guido van Rossum374a9221991-04-04 10:40:29 +00001885 PUSH(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001886 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001887 break;
Thomas Wouters00e41de2007-02-23 19:56:57 +00001888
1889 case MAKE_BYTES:
1890 w = POP();
1891 if (PyString_Check(w))
1892 x = PyBytes_FromStringAndSize(
1893 PyString_AS_STRING(w),
1894 PyString_GET_SIZE(w));
1895 else
1896 x = NULL;
1897 Py_DECREF(w);
1898 PUSH(x);
1899 if (x != NULL) continue;
1900 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001901
Guido van Rossum374a9221991-04-04 10:40:29 +00001902 case LOAD_ATTR:
Skip Montanaro496e6582002-08-06 17:47:40 +00001903 w = GETITEM(names, oparg);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001904 v = TOP();
Guido van Rossumb209a111997-04-29 18:18:01 +00001905 x = PyObject_GetAttr(v, w);
1906 Py_DECREF(v);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001907 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001908 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001909 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001910
Guido van Rossum374a9221991-04-04 10:40:29 +00001911 case COMPARE_OP:
1912 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001913 v = TOP();
Raymond Hettinger4bad9ba2003-01-19 05:08:13 +00001914 if (PyInt_CheckExact(w) && PyInt_CheckExact(v)) {
Guido van Rossumc12da691997-07-17 23:12:42 +00001915 /* INLINE: cmp(int, int) */
1916 register long a, b;
1917 register int res;
Guido van Rossumcf183ac1998-12-04 18:51:36 +00001918 a = PyInt_AS_LONG(v);
1919 b = PyInt_AS_LONG(w);
Guido van Rossumc12da691997-07-17 23:12:42 +00001920 switch (oparg) {
Martin v. Löwis7198a522002-01-01 19:59:11 +00001921 case PyCmp_LT: res = a < b; break;
1922 case PyCmp_LE: res = a <= b; break;
1923 case PyCmp_EQ: res = a == b; break;
1924 case PyCmp_NE: res = a != b; break;
1925 case PyCmp_GT: res = a > b; break;
1926 case PyCmp_GE: res = a >= b; break;
1927 case PyCmp_IS: res = v == w; break;
1928 case PyCmp_IS_NOT: res = v != w; break;
Guido van Rossumc12da691997-07-17 23:12:42 +00001929 default: goto slow_compare;
1930 }
1931 x = res ? Py_True : Py_False;
1932 Py_INCREF(x);
1933 }
1934 else {
1935 slow_compare:
1936 x = cmp_outcome(oparg, v, w);
1937 }
Guido van Rossumb209a111997-04-29 18:18:01 +00001938 Py_DECREF(v);
1939 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001940 SET_TOP(x);
Raymond Hettingerf606f872003-03-16 03:11:04 +00001941 if (x == NULL) break;
1942 PREDICT(JUMP_IF_FALSE);
1943 PREDICT(JUMP_IF_TRUE);
1944 continue;
Guido van Rossumac7be682001-01-17 15:42:30 +00001945
Guido van Rossum374a9221991-04-04 10:40:29 +00001946 case IMPORT_NAME:
Skip Montanaro496e6582002-08-06 17:47:40 +00001947 w = GETITEM(names, oparg);
Guido van Rossumb209a111997-04-29 18:18:01 +00001948 x = PyDict_GetItemString(f->f_builtins, "__import__");
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001949 if (x == NULL) {
Guido van Rossumb209a111997-04-29 18:18:01 +00001950 PyErr_SetString(PyExc_ImportError,
Guido van Rossumfc490731997-05-06 15:06:49 +00001951 "__import__ not found");
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001952 break;
1953 }
Thomas Woutersf7f438b2006-02-28 16:09:29 +00001954 v = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001955 u = TOP();
Thomas Woutersf7f438b2006-02-28 16:09:29 +00001956 if (PyInt_AsLong(u) != -1 || PyErr_Occurred())
1957 w = PyTuple_Pack(5,
1958 w,
1959 f->f_globals,
1960 f->f_locals == NULL ?
1961 Py_None : f->f_locals,
1962 v,
1963 u);
1964 else
1965 w = PyTuple_Pack(4,
1966 w,
1967 f->f_globals,
1968 f->f_locals == NULL ?
1969 Py_None : f->f_locals,
1970 v);
1971 Py_DECREF(v);
Guido van Rossumb209a111997-04-29 18:18:01 +00001972 Py_DECREF(u);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001973 if (w == NULL) {
Raymond Hettinger663004b2003-01-09 15:24:30 +00001974 u = POP();
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001975 x = NULL;
1976 break;
1977 }
Michael W. Hudson75eabd22005-01-18 15:56:11 +00001978 READ_TIMESTAMP(intr0);
Guido van Rossumb209a111997-04-29 18:18:01 +00001979 x = PyEval_CallObject(x, w);
Michael W. Hudson75eabd22005-01-18 15:56:11 +00001980 READ_TIMESTAMP(intr1);
Guido van Rossumb209a111997-04-29 18:18:01 +00001981 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001982 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001983 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001984 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001985
Thomas Wouters52152252000-08-17 22:55:00 +00001986 case IMPORT_STAR:
1987 v = POP();
Guido van Rossumb209a111997-04-29 18:18:01 +00001988 PyFrame_FastToLocals(f);
Guido van Rossum681d79a1995-07-18 14:51:37 +00001989 if ((x = f->f_locals) == NULL) {
Guido van Rossuma027efa1997-05-05 20:56:21 +00001990 PyErr_SetString(PyExc_SystemError,
Jeremy Hyltonc862cf42001-01-19 03:25:05 +00001991 "no locals found during 'import *'");
Guido van Rossum681d79a1995-07-18 14:51:37 +00001992 break;
1993 }
Michael W. Hudson75eabd22005-01-18 15:56:11 +00001994 READ_TIMESTAMP(intr0);
Thomas Wouters52152252000-08-17 22:55:00 +00001995 err = import_all_from(x, v);
Michael W. Hudson75eabd22005-01-18 15:56:11 +00001996 READ_TIMESTAMP(intr1);
Guido van Rossumb209a111997-04-29 18:18:01 +00001997 PyFrame_LocalsToFast(f, 0);
Thomas Wouters52152252000-08-17 22:55:00 +00001998 Py_DECREF(v);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001999 if (err == 0) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00002000 break;
Guido van Rossum25831651993-05-19 14:50:45 +00002001
Thomas Wouters52152252000-08-17 22:55:00 +00002002 case IMPORT_FROM:
Skip Montanaro496e6582002-08-06 17:47:40 +00002003 w = GETITEM(names, oparg);
Thomas Wouters52152252000-08-17 22:55:00 +00002004 v = TOP();
Michael W. Hudson75eabd22005-01-18 15:56:11 +00002005 READ_TIMESTAMP(intr0);
Thomas Wouters52152252000-08-17 22:55:00 +00002006 x = import_from(v, w);
Michael W. Hudson75eabd22005-01-18 15:56:11 +00002007 READ_TIMESTAMP(intr1);
Thomas Wouters52152252000-08-17 22:55:00 +00002008 PUSH(x);
2009 if (x != NULL) continue;
2010 break;
2011
Guido van Rossum374a9221991-04-04 10:40:29 +00002012 case JUMP_FORWARD:
2013 JUMPBY(oparg);
Neil Schemenauerc4b570f2003-06-01 19:21:12 +00002014 goto fast_next_opcode;
Guido van Rossumac7be682001-01-17 15:42:30 +00002015
Raymond Hettingerf606f872003-03-16 03:11:04 +00002016 PREDICTED_WITH_ARG(JUMP_IF_FALSE);
Guido van Rossum374a9221991-04-04 10:40:29 +00002017 case JUMP_IF_FALSE:
Raymond Hettinger21012b82003-02-26 18:11:50 +00002018 w = TOP();
Raymond Hettingerf606f872003-03-16 03:11:04 +00002019 if (w == Py_True) {
2020 PREDICT(POP_TOP);
Neil Schemenauerc4b570f2003-06-01 19:21:12 +00002021 goto fast_next_opcode;
Raymond Hettingerf606f872003-03-16 03:11:04 +00002022 }
Raymond Hettinger21012b82003-02-26 18:11:50 +00002023 if (w == Py_False) {
2024 JUMPBY(oparg);
Neil Schemenauerc4b570f2003-06-01 19:21:12 +00002025 goto fast_next_opcode;
Raymond Hettinger21012b82003-02-26 18:11:50 +00002026 }
2027 err = PyObject_IsTrue(w);
Guido van Rossum04691fc1992-08-12 15:35:34 +00002028 if (err > 0)
2029 err = 0;
2030 else if (err == 0)
Guido van Rossum374a9221991-04-04 10:40:29 +00002031 JUMPBY(oparg);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00002032 else
2033 break;
2034 continue;
Guido van Rossumac7be682001-01-17 15:42:30 +00002035
Raymond Hettingerf606f872003-03-16 03:11:04 +00002036 PREDICTED_WITH_ARG(JUMP_IF_TRUE);
Guido van Rossum374a9221991-04-04 10:40:29 +00002037 case JUMP_IF_TRUE:
Raymond Hettinger21012b82003-02-26 18:11:50 +00002038 w = TOP();
Raymond Hettingerf606f872003-03-16 03:11:04 +00002039 if (w == Py_False) {
2040 PREDICT(POP_TOP);
Neil Schemenauerc4b570f2003-06-01 19:21:12 +00002041 goto fast_next_opcode;
Raymond Hettingerf606f872003-03-16 03:11:04 +00002042 }
Raymond Hettinger21012b82003-02-26 18:11:50 +00002043 if (w == Py_True) {
2044 JUMPBY(oparg);
Neil Schemenauerc4b570f2003-06-01 19:21:12 +00002045 goto fast_next_opcode;
Raymond Hettinger21012b82003-02-26 18:11:50 +00002046 }
2047 err = PyObject_IsTrue(w);
Guido van Rossum04691fc1992-08-12 15:35:34 +00002048 if (err > 0) {
2049 err = 0;
Guido van Rossum374a9221991-04-04 10:40:29 +00002050 JUMPBY(oparg);
Guido van Rossum04691fc1992-08-12 15:35:34 +00002051 }
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00002052 else if (err == 0)
2053 ;
2054 else
2055 break;
2056 continue;
Guido van Rossumac7be682001-01-17 15:42:30 +00002057
Raymond Hettingerfba1cfc2004-03-12 16:33:17 +00002058 PREDICTED_WITH_ARG(JUMP_ABSOLUTE);
Guido van Rossum374a9221991-04-04 10:40:29 +00002059 case JUMP_ABSOLUTE:
2060 JUMPTO(oparg);
Neil Schemenauerca2a2f12003-05-30 23:59:44 +00002061 continue;
Guido van Rossumac7be682001-01-17 15:42:30 +00002062
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002063 case GET_ITER:
2064 /* before: [obj]; after [getiter(obj)] */
Raymond Hettinger663004b2003-01-09 15:24:30 +00002065 v = TOP();
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002066 x = PyObject_GetIter(v);
2067 Py_DECREF(v);
2068 if (x != NULL) {
Raymond Hettinger663004b2003-01-09 15:24:30 +00002069 SET_TOP(x);
Raymond Hettinger7dc52212003-03-16 20:14:44 +00002070 PREDICT(FOR_ITER);
Guido van Rossum213c7a62001-04-23 14:08:49 +00002071 continue;
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002072 }
Raymond Hettinger8bb90a52003-01-14 12:43:10 +00002073 STACKADJ(-1);
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002074 break;
2075
Raymond Hettinger7dc52212003-03-16 20:14:44 +00002076 PREDICTED_WITH_ARG(FOR_ITER);
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002077 case FOR_ITER:
2078 /* before: [iter]; after: [iter, iter()] *or* [] */
2079 v = TOP();
Raymond Hettingerdb0de9e2004-03-12 08:41:36 +00002080 x = (*v->ob_type->tp_iternext)(v);
Guido van Rossum213c7a62001-04-23 14:08:49 +00002081 if (x != NULL) {
2082 PUSH(x);
Raymond Hettinger7dc52212003-03-16 20:14:44 +00002083 PREDICT(STORE_FAST);
2084 PREDICT(UNPACK_SEQUENCE);
Guido van Rossum213c7a62001-04-23 14:08:49 +00002085 continue;
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002086 }
Raymond Hettingerdb0de9e2004-03-12 08:41:36 +00002087 if (PyErr_Occurred()) {
2088 if (!PyErr_ExceptionMatches(PyExc_StopIteration))
2089 break;
2090 PyErr_Clear();
Guido van Rossum213c7a62001-04-23 14:08:49 +00002091 }
Raymond Hettingerdb0de9e2004-03-12 08:41:36 +00002092 /* iterator ended normally */
2093 x = v = POP();
2094 Py_DECREF(v);
2095 JUMPBY(oparg);
2096 continue;
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002097
Raymond Hettinger2d783e92004-03-12 09:12:22 +00002098 case BREAK_LOOP:
2099 why = WHY_BREAK;
2100 goto fast_block_end;
2101
2102 case CONTINUE_LOOP:
2103 retval = PyInt_FromLong(oparg);
Thomas Wouters477c8d52006-05-27 19:21:47 +00002104 if (!retval) {
2105 x = NULL;
2106 break;
2107 }
Raymond Hettinger2d783e92004-03-12 09:12:22 +00002108 why = WHY_CONTINUE;
2109 goto fast_block_end;
2110
Guido van Rossum374a9221991-04-04 10:40:29 +00002111 case SETUP_LOOP:
2112 case SETUP_EXCEPT:
2113 case SETUP_FINALLY:
Thomas Wouters9fe394c2007-02-05 01:24:16 +00002114 /* NOTE: If you add any new block-setup opcodes that are
2115 not try/except/finally handlers, you may need to
2116 update the PyGen_NeedsFinalizing() function. */
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002117
Guido van Rossumb209a111997-04-29 18:18:01 +00002118 PyFrame_BlockSetup(f, opcode, INSTR_OFFSET() + oparg,
Jeremy Hylton3faa52e2001-02-01 22:48:12 +00002119 STACK_LEVEL());
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00002120 continue;
Guido van Rossumac7be682001-01-17 15:42:30 +00002121
Guido van Rossumc2e20742006-02-27 22:32:47 +00002122 case WITH_CLEANUP:
2123 {
2124 /* TOP is the context.__exit__ bound method.
2125 Below that are 1-3 values indicating how/why
2126 we entered the finally clause:
2127 - SECOND = None
Guido van Rossumf6694362006-03-10 02:28:35 +00002128 - (SECOND, THIRD) = (WHY_{RETURN,CONTINUE}), retval
Guido van Rossumc2e20742006-02-27 22:32:47 +00002129 - SECOND = WHY_*; no retval below it
2130 - (SECOND, THIRD, FOURTH) = exc_info()
2131 In the last case, we must call
2132 TOP(SECOND, THIRD, FOURTH)
2133 otherwise we must call
2134 TOP(None, None, None)
Guido van Rossum1a5e21e2006-02-28 21:57:43 +00002135
2136 In addition, if the stack represents an exception,
Guido van Rossumf6694362006-03-10 02:28:35 +00002137 *and* the function call returns a 'true' value, we
2138 "zap" this information, to prevent END_FINALLY from
2139 re-raising the exception. (But non-local gotos
2140 should still be resumed.)
Guido van Rossumc2e20742006-02-27 22:32:47 +00002141 */
Thomas Wouters477c8d52006-05-27 19:21:47 +00002142
Guido van Rossumc2e20742006-02-27 22:32:47 +00002143 x = TOP();
2144 u = SECOND();
2145 if (PyInt_Check(u) || u == Py_None) {
2146 u = v = w = Py_None;
2147 }
2148 else {
2149 v = THIRD();
2150 w = FOURTH();
2151 }
Guido van Rossumf6694362006-03-10 02:28:35 +00002152 /* XXX Not the fastest way to call it... */
2153 x = PyObject_CallFunctionObjArgs(x, u, v, w, NULL);
2154 if (x == NULL)
2155 break; /* Go to error exit */
2156 if (u != Py_None && PyObject_IsTrue(x)) {
2157 /* There was an exception and a true return */
2158 Py_DECREF(x);
2159 x = TOP(); /* Again */
2160 STACKADJ(-3);
2161 Py_INCREF(Py_None);
2162 SET_TOP(Py_None);
2163 Py_DECREF(x);
2164 Py_DECREF(u);
2165 Py_DECREF(v);
2166 Py_DECREF(w);
2167 } else {
2168 /* Let END_FINALLY do its thing */
2169 Py_DECREF(x);
2170 x = POP();
2171 Py_DECREF(x);
2172 }
Guido van Rossumc2e20742006-02-27 22:32:47 +00002173 break;
2174 }
2175
Guido van Rossumf10570b1995-07-07 22:53:21 +00002176 case CALL_FUNCTION:
Armin Rigo8817fcd2004-06-17 10:22:40 +00002177 {
2178 PyObject **sp;
Jeremy Hylton985eba52003-02-05 23:13:00 +00002179 PCALL(PCALL_ALL);
Armin Rigo8817fcd2004-06-17 10:22:40 +00002180 sp = stack_pointer;
Martin v. Löwisf30d60e2004-06-08 08:17:44 +00002181#ifdef WITH_TSC
Armin Rigo8817fcd2004-06-17 10:22:40 +00002182 x = call_function(&sp, oparg, &intr0, &intr1);
Martin v. Löwisf30d60e2004-06-08 08:17:44 +00002183#else
Armin Rigo8817fcd2004-06-17 10:22:40 +00002184 x = call_function(&sp, oparg);
Martin v. Löwisf30d60e2004-06-08 08:17:44 +00002185#endif
Armin Rigo8817fcd2004-06-17 10:22:40 +00002186 stack_pointer = sp;
Jeremy Hyltone8c04322002-08-16 17:47:26 +00002187 PUSH(x);
2188 if (x != NULL)
2189 continue;
2190 break;
Armin Rigo8817fcd2004-06-17 10:22:40 +00002191 }
Guido van Rossumac7be682001-01-17 15:42:30 +00002192
Jeremy Hylton76901512000-03-28 23:49:17 +00002193 case CALL_FUNCTION_VAR:
2194 case CALL_FUNCTION_KW:
2195 case CALL_FUNCTION_VAR_KW:
Guido van Rossumf10570b1995-07-07 22:53:21 +00002196 {
Jeremy Hylton76901512000-03-28 23:49:17 +00002197 int na = oparg & 0xff;
2198 int nk = (oparg>>8) & 0xff;
2199 int flags = (opcode - CALL_FUNCTION) & 3;
Jeremy Hylton52820442001-01-03 23:52:36 +00002200 int n = na + 2 * nk;
Armin Rigo8817fcd2004-06-17 10:22:40 +00002201 PyObject **pfunc, *func, **sp;
Jeremy Hylton985eba52003-02-05 23:13:00 +00002202 PCALL(PCALL_ALL);
Jeremy Hylton52820442001-01-03 23:52:36 +00002203 if (flags & CALL_FLAG_VAR)
2204 n++;
2205 if (flags & CALL_FLAG_KW)
2206 n++;
2207 pfunc = stack_pointer - n - 1;
2208 func = *pfunc;
Jeremy Hylton52820442001-01-03 23:52:36 +00002209
Guido van Rossumac7be682001-01-17 15:42:30 +00002210 if (PyMethod_Check(func)
Jeremy Hylton52820442001-01-03 23:52:36 +00002211 && PyMethod_GET_SELF(func) != NULL) {
2212 PyObject *self = PyMethod_GET_SELF(func);
Jeremy Hylton76901512000-03-28 23:49:17 +00002213 Py_INCREF(self);
Jeremy Hylton52820442001-01-03 23:52:36 +00002214 func = PyMethod_GET_FUNCTION(func);
2215 Py_INCREF(func);
Jeremy Hylton76901512000-03-28 23:49:17 +00002216 Py_DECREF(*pfunc);
2217 *pfunc = self;
2218 na++;
2219 n++;
Guido van Rossumac7be682001-01-17 15:42:30 +00002220 } else
Jeremy Hylton52820442001-01-03 23:52:36 +00002221 Py_INCREF(func);
Armin Rigo8817fcd2004-06-17 10:22:40 +00002222 sp = stack_pointer;
Michael W. Hudson75eabd22005-01-18 15:56:11 +00002223 READ_TIMESTAMP(intr0);
Armin Rigo8817fcd2004-06-17 10:22:40 +00002224 x = ext_do_call(func, &sp, flags, na, nk);
Michael W. Hudson75eabd22005-01-18 15:56:11 +00002225 READ_TIMESTAMP(intr1);
Armin Rigo8817fcd2004-06-17 10:22:40 +00002226 stack_pointer = sp;
Jeremy Hylton76901512000-03-28 23:49:17 +00002227 Py_DECREF(func);
Jeremy Hylton52820442001-01-03 23:52:36 +00002228
Jeremy Hylton76901512000-03-28 23:49:17 +00002229 while (stack_pointer > pfunc) {
Jeremy Hylton52820442001-01-03 23:52:36 +00002230 w = POP();
2231 Py_DECREF(w);
Jeremy Hylton76901512000-03-28 23:49:17 +00002232 }
2233 PUSH(x);
Guido van Rossumac7be682001-01-17 15:42:30 +00002234 if (x != NULL)
Jeremy Hylton52820442001-01-03 23:52:36 +00002235 continue;
Jeremy Hylton76901512000-03-28 23:49:17 +00002236 break;
Guido van Rossumf10570b1995-07-07 22:53:21 +00002237 }
Guido van Rossumac7be682001-01-17 15:42:30 +00002238
Guido van Rossum681d79a1995-07-18 14:51:37 +00002239 case MAKE_FUNCTION:
Guido van Rossum4f72a782006-10-27 23:31:49 +00002240 {
2241 int posdefaults = oparg & 0xff;
2242 int kwdefaults = (oparg>>8) & 0xff;
Neal Norwitzc1505362006-12-28 06:47:50 +00002243 int num_annotations = (oparg >> 16) & 0x7fff;
Guido van Rossum4f72a782006-10-27 23:31:49 +00002244
Guido van Rossum681d79a1995-07-18 14:51:37 +00002245 v = POP(); /* code object */
Guido van Rossumb209a111997-04-29 18:18:01 +00002246 x = PyFunction_New(v, f->f_globals);
2247 Py_DECREF(v);
Neal Norwitzc1505362006-12-28 06:47:50 +00002248
2249 if (x != NULL && num_annotations > 0) {
2250 Py_ssize_t name_ix;
2251 u = POP(); /* names of args with annotations */
2252 v = PyDict_New();
2253 if (v == NULL) {
2254 Py_DECREF(x);
2255 x = NULL;
2256 break;
2257 }
2258 name_ix = PyTuple_Size(u);
2259 assert(num_annotations == name_ix+1);
2260 while (name_ix > 0) {
2261 --name_ix;
2262 t = PyTuple_GET_ITEM(u, name_ix);
2263 w = POP();
2264 /* XXX(nnorwitz): check for errors */
2265 PyDict_SetItem(v, t, w);
2266 Py_DECREF(w);
2267 }
2268
2269 err = PyFunction_SetAnnotations(x, v);
2270 Py_DECREF(v);
2271 Py_DECREF(u);
2272 }
2273
Guido van Rossum681d79a1995-07-18 14:51:37 +00002274 /* XXX Maybe this should be a separate opcode? */
Guido van Rossum4f72a782006-10-27 23:31:49 +00002275 if (x != NULL && posdefaults > 0) {
2276 v = PyTuple_New(posdefaults);
Guido van Rossum681d79a1995-07-18 14:51:37 +00002277 if (v == NULL) {
Guido van Rossumb209a111997-04-29 18:18:01 +00002278 Py_DECREF(x);
Guido van Rossum681d79a1995-07-18 14:51:37 +00002279 x = NULL;
2280 break;
2281 }
Guido van Rossum4f72a782006-10-27 23:31:49 +00002282 while (--posdefaults >= 0) {
Guido van Rossum681d79a1995-07-18 14:51:37 +00002283 w = POP();
Guido van Rossum4f72a782006-10-27 23:31:49 +00002284 PyTuple_SET_ITEM(v, posdefaults, w);
Guido van Rossum681d79a1995-07-18 14:51:37 +00002285 }
2286 err = PyFunction_SetDefaults(x, v);
Guido van Rossumb209a111997-04-29 18:18:01 +00002287 Py_DECREF(v);
Guido van Rossum681d79a1995-07-18 14:51:37 +00002288 }
Guido van Rossum4f72a782006-10-27 23:31:49 +00002289 if (x != NULL && kwdefaults > 0) {
2290 v = PyDict_New();
2291 if (v == NULL) {
2292 Py_DECREF(x);
2293 x = NULL;
2294 break;
2295 }
2296 while (--kwdefaults >= 0) {
2297 w = POP(); /* default value */
2298 u = POP(); /* kw only arg name */
Neal Norwitzc1505362006-12-28 06:47:50 +00002299 /* XXX(nnorwitz): check for errors */
Guido van Rossum4f72a782006-10-27 23:31:49 +00002300 PyDict_SetItem(v, u, w);
Georg Brandl94ab0002007-02-26 13:58:18 +00002301 Py_DECREF(w);
2302 Py_DECREF(u);
Guido van Rossum4f72a782006-10-27 23:31:49 +00002303 }
2304 err = PyFunction_SetKwDefaults(x, v);
2305 Py_DECREF(v);
2306 }
Guido van Rossum681d79a1995-07-18 14:51:37 +00002307 PUSH(x);
2308 break;
Guido van Rossum4f72a782006-10-27 23:31:49 +00002309 }
Guido van Rossum8861b741996-07-30 16:49:37 +00002310
Jeremy Hylton64949cb2001-01-25 20:06:59 +00002311 case MAKE_CLOSURE:
2312 {
Jeremy Hylton64949cb2001-01-25 20:06:59 +00002313 v = POP(); /* code object */
2314 x = PyFunction_New(v, f->f_globals);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00002315 Py_DECREF(v);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00002316 if (x != NULL) {
2317 v = POP();
Jeremy Hylton64949cb2001-01-25 20:06:59 +00002318 err = PyFunction_SetClosure(x, v);
2319 Py_DECREF(v);
2320 }
2321 if (x != NULL && oparg > 0) {
2322 v = PyTuple_New(oparg);
2323 if (v == NULL) {
2324 Py_DECREF(x);
2325 x = NULL;
2326 break;
2327 }
Raymond Hettinger5bed4562004-04-10 23:34:17 +00002328 while (--oparg >= 0) {
Jeremy Hylton64949cb2001-01-25 20:06:59 +00002329 w = POP();
2330 PyTuple_SET_ITEM(v, oparg, w);
2331 }
2332 err = PyFunction_SetDefaults(x, v);
2333 Py_DECREF(v);
2334 }
2335 PUSH(x);
2336 break;
2337 }
2338
Guido van Rossum8861b741996-07-30 16:49:37 +00002339 case BUILD_SLICE:
2340 if (oparg == 3)
2341 w = POP();
2342 else
2343 w = NULL;
2344 v = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00002345 u = TOP();
Guido van Rossum1aa14831997-01-21 05:34:20 +00002346 x = PySlice_New(u, v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +00002347 Py_DECREF(u);
2348 Py_DECREF(v);
2349 Py_XDECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00002350 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00002351 if (x != NULL) continue;
Guido van Rossum8861b741996-07-30 16:49:37 +00002352 break;
2353
Fred Drakeef8ace32000-08-24 00:32:09 +00002354 case EXTENDED_ARG:
2355 opcode = NEXTOP();
Raymond Hettinger5bed4562004-04-10 23:34:17 +00002356 oparg = oparg<<16 | NEXTARG();
Fred Drakeef8ace32000-08-24 00:32:09 +00002357 goto dispatch_opcode;
Guido van Rossum8861b741996-07-30 16:49:37 +00002358
Guido van Rossum374a9221991-04-04 10:40:29 +00002359 default:
2360 fprintf(stderr,
2361 "XXX lineno: %d, opcode: %d\n",
Michael W. Hudsondd32a912002-08-15 14:59:02 +00002362 PyCode_Addr2Line(f->f_code, f->f_lasti),
2363 opcode);
Guido van Rossumb209a111997-04-29 18:18:01 +00002364 PyErr_SetString(PyExc_SystemError, "unknown opcode");
Guido van Rossum374a9221991-04-04 10:40:29 +00002365 why = WHY_EXCEPTION;
2366 break;
Guido van Rossum04691fc1992-08-12 15:35:34 +00002367
2368#ifdef CASE_TOO_BIG
2369 }
2370#endif
2371
Guido van Rossum374a9221991-04-04 10:40:29 +00002372 } /* switch */
2373
2374 on_error:
Guido van Rossumac7be682001-01-17 15:42:30 +00002375
Michael W. Hudson75eabd22005-01-18 15:56:11 +00002376 READ_TIMESTAMP(inst1);
Martin v. Löwisf30d60e2004-06-08 08:17:44 +00002377
Guido van Rossum374a9221991-04-04 10:40:29 +00002378 /* Quickly continue if no error occurred */
Guido van Rossumac7be682001-01-17 15:42:30 +00002379
Guido van Rossum374a9221991-04-04 10:40:29 +00002380 if (why == WHY_NOT) {
Guido van Rossum681d79a1995-07-18 14:51:37 +00002381 if (err == 0 && x != NULL) {
2382#ifdef CHECKEXC
Guido van Rossumeb894eb1999-03-09 16:16:45 +00002383 /* This check is expensive! */
Guido van Rossumb209a111997-04-29 18:18:01 +00002384 if (PyErr_Occurred())
Guido van Rossum681d79a1995-07-18 14:51:37 +00002385 fprintf(stderr,
2386 "XXX undetected error\n");
Martin v. Löwisf30d60e2004-06-08 08:17:44 +00002387 else {
2388#endif
Michael W. Hudson75eabd22005-01-18 15:56:11 +00002389 READ_TIMESTAMP(loop1);
Guido van Rossum681d79a1995-07-18 14:51:37 +00002390 continue; /* Normal, fast path */
Martin v. Löwisf30d60e2004-06-08 08:17:44 +00002391#ifdef CHECKEXC
2392 }
2393#endif
Guido van Rossum681d79a1995-07-18 14:51:37 +00002394 }
Guido van Rossum374a9221991-04-04 10:40:29 +00002395 why = WHY_EXCEPTION;
Guido van Rossumb209a111997-04-29 18:18:01 +00002396 x = Py_None;
Guido van Rossum374a9221991-04-04 10:40:29 +00002397 err = 0;
2398 }
2399
Guido van Rossum374a9221991-04-04 10:40:29 +00002400 /* Double-check exception status */
Guido van Rossumac7be682001-01-17 15:42:30 +00002401
Raymond Hettingerc8aa08b2004-04-11 14:59:33 +00002402 if (why == WHY_EXCEPTION || why == WHY_RERAISE) {
Guido van Rossumb209a111997-04-29 18:18:01 +00002403 if (!PyErr_Occurred()) {
Guido van Rossuma027efa1997-05-05 20:56:21 +00002404 PyErr_SetString(PyExc_SystemError,
Guido van Rossumeb894eb1999-03-09 16:16:45 +00002405 "error return without exception set");
Guido van Rossum374a9221991-04-04 10:40:29 +00002406 why = WHY_EXCEPTION;
2407 }
2408 }
Guido van Rossumeb894eb1999-03-09 16:16:45 +00002409#ifdef CHECKEXC
Guido van Rossum374a9221991-04-04 10:40:29 +00002410 else {
Guido van Rossumeb894eb1999-03-09 16:16:45 +00002411 /* This check is expensive! */
Guido van Rossumb209a111997-04-29 18:18:01 +00002412 if (PyErr_Occurred()) {
Jeremy Hylton904ed862003-11-05 17:29:35 +00002413 char buf[1024];
2414 sprintf(buf, "Stack unwind with exception "
2415 "set and why=%d", why);
2416 Py_FatalError(buf);
Guido van Rossum681d79a1995-07-18 14:51:37 +00002417 }
Guido van Rossum374a9221991-04-04 10:40:29 +00002418 }
2419#endif
2420
2421 /* Log traceback info if this is a real exception */
Guido van Rossumac7be682001-01-17 15:42:30 +00002422
Guido van Rossum374a9221991-04-04 10:40:29 +00002423 if (why == WHY_EXCEPTION) {
Guido van Rossumb209a111997-04-29 18:18:01 +00002424 PyTraceBack_Here(f);
Guido van Rossum96a42c81992-01-12 02:29:51 +00002425
Fred Drake8f51f542001-10-04 14:48:42 +00002426 if (tstate->c_tracefunc != NULL)
2427 call_exc_trace(tstate->c_tracefunc,
2428 tstate->c_traceobj, f);
Guido van Rossum014518f1998-11-23 21:09:51 +00002429 }
Guido van Rossumac7be682001-01-17 15:42:30 +00002430
Guido van Rossum374a9221991-04-04 10:40:29 +00002431 /* For the rest, treat WHY_RERAISE as WHY_EXCEPTION */
Guido van Rossumac7be682001-01-17 15:42:30 +00002432
Guido van Rossum374a9221991-04-04 10:40:29 +00002433 if (why == WHY_RERAISE)
2434 why = WHY_EXCEPTION;
2435
2436 /* Unwind stacks if a (pseudo) exception occurred */
Guido van Rossumac7be682001-01-17 15:42:30 +00002437
Raymond Hettinger1dd83092004-02-06 18:32:33 +00002438fast_block_end:
Tim Peters8a5c3c72004-04-05 19:36:21 +00002439 while (why != WHY_NOT && f->f_iblock > 0) {
Guido van Rossumb209a111997-04-29 18:18:01 +00002440 PyTryBlock *b = PyFrame_BlockPop(f);
Jeremy Hylton3faa52e2001-02-01 22:48:12 +00002441
Tim Peters8a5c3c72004-04-05 19:36:21 +00002442 assert(why != WHY_YIELD);
Jeremy Hylton3faa52e2001-02-01 22:48:12 +00002443 if (b->b_type == SETUP_LOOP && why == WHY_CONTINUE) {
2444 /* For a continue inside a try block,
2445 don't pop the block for the loop. */
Thomas Wouters1ee64222001-09-24 19:32:01 +00002446 PyFrame_BlockSetup(f, b->b_type, b->b_handler,
2447 b->b_level);
Jeremy Hylton3faa52e2001-02-01 22:48:12 +00002448 why = WHY_NOT;
2449 JUMPTO(PyInt_AS_LONG(retval));
2450 Py_DECREF(retval);
2451 break;
2452 }
2453
Guido van Rossum374a9221991-04-04 10:40:29 +00002454 while (STACK_LEVEL() > b->b_level) {
2455 v = POP();
Guido van Rossumb209a111997-04-29 18:18:01 +00002456 Py_XDECREF(v);
Guido van Rossum374a9221991-04-04 10:40:29 +00002457 }
2458 if (b->b_type == SETUP_LOOP && why == WHY_BREAK) {
2459 why = WHY_NOT;
2460 JUMPTO(b->b_handler);
2461 break;
2462 }
2463 if (b->b_type == SETUP_FINALLY ||
Guido van Rossum150b2df1996-12-05 23:17:11 +00002464 (b->b_type == SETUP_EXCEPT &&
2465 why == WHY_EXCEPTION)) {
Guido van Rossum374a9221991-04-04 10:40:29 +00002466 if (why == WHY_EXCEPTION) {
Guido van Rossumb209a111997-04-29 18:18:01 +00002467 PyObject *exc, *val, *tb;
2468 PyErr_Fetch(&exc, &val, &tb);
Guido van Rossum374a9221991-04-04 10:40:29 +00002469 if (val == NULL) {
Guido van Rossumb209a111997-04-29 18:18:01 +00002470 val = Py_None;
2471 Py_INCREF(val);
Guido van Rossum374a9221991-04-04 10:40:29 +00002472 }
Guido van Rossum374a9221991-04-04 10:40:29 +00002473 /* Make the raw exception data
2474 available to the handler,
2475 so a program can emulate the
2476 Python main loop. Don't do
2477 this for 'finally'. */
2478 if (b->b_type == SETUP_EXCEPT) {
Barry Warsaweaedc7c1997-08-28 22:36:40 +00002479 PyErr_NormalizeException(
2480 &exc, &val, &tb);
Guido van Rossuma027efa1997-05-05 20:56:21 +00002481 set_exc_info(tstate,
2482 exc, val, tb);
Guido van Rossum374a9221991-04-04 10:40:29 +00002483 }
Jeremy Hyltonc6314892001-09-26 19:24:45 +00002484 if (tb == NULL) {
2485 Py_INCREF(Py_None);
2486 PUSH(Py_None);
2487 } else
2488 PUSH(tb);
Guido van Rossum374a9221991-04-04 10:40:29 +00002489 PUSH(val);
2490 PUSH(exc);
2491 }
2492 else {
Raymond Hettinger06032cb2004-04-06 09:37:35 +00002493 if (why & (WHY_RETURN | WHY_CONTINUE))
Guido van Rossum374a9221991-04-04 10:40:29 +00002494 PUSH(retval);
Guido van Rossumb209a111997-04-29 18:18:01 +00002495 v = PyInt_FromLong((long)why);
Guido van Rossum374a9221991-04-04 10:40:29 +00002496 PUSH(v);
2497 }
2498 why = WHY_NOT;
2499 JUMPTO(b->b_handler);
2500 break;
2501 }
2502 } /* unwind stack */
2503
2504 /* End the loop if we still have an error (or return) */
Guido van Rossumac7be682001-01-17 15:42:30 +00002505
Guido van Rossum374a9221991-04-04 10:40:29 +00002506 if (why != WHY_NOT)
2507 break;
Michael W. Hudson75eabd22005-01-18 15:56:11 +00002508 READ_TIMESTAMP(loop1);
Guido van Rossumac7be682001-01-17 15:42:30 +00002509
Guido van Rossum374a9221991-04-04 10:40:29 +00002510 } /* main loop */
Guido van Rossumac7be682001-01-17 15:42:30 +00002511
Tim Peters8a5c3c72004-04-05 19:36:21 +00002512 assert(why != WHY_YIELD);
2513 /* Pop remaining stack entries. */
2514 while (!EMPTY()) {
2515 v = POP();
2516 Py_XDECREF(v);
Guido van Rossum35974fb2001-12-06 21:28:18 +00002517 }
2518
Tim Peters8a5c3c72004-04-05 19:36:21 +00002519 if (why != WHY_RETURN)
Guido van Rossum96a42c81992-01-12 02:29:51 +00002520 retval = NULL;
Guido van Rossumac7be682001-01-17 15:42:30 +00002521
Raymond Hettinger1dd83092004-02-06 18:32:33 +00002522fast_yield:
Fred Drake9e3ad782001-07-03 23:39:52 +00002523 if (tstate->use_tracing) {
Barry Warsawe2eca0b2005-08-15 18:14:19 +00002524 if (tstate->c_tracefunc) {
2525 if (why == WHY_RETURN || why == WHY_YIELD) {
2526 if (call_trace(tstate->c_tracefunc,
2527 tstate->c_traceobj, f,
2528 PyTrace_RETURN, retval)) {
2529 Py_XDECREF(retval);
2530 retval = NULL;
2531 why = WHY_EXCEPTION;
2532 }
2533 }
2534 else if (why == WHY_EXCEPTION) {
2535 call_trace_protected(tstate->c_tracefunc,
2536 tstate->c_traceobj, f,
Armin Rigo1c2d7e52005-09-20 18:34:01 +00002537 PyTrace_RETURN, NULL);
Guido van Rossum96a42c81992-01-12 02:29:51 +00002538 }
Guido van Rossum96a42c81992-01-12 02:29:51 +00002539 }
Fred Drake8f51f542001-10-04 14:48:42 +00002540 if (tstate->c_profilefunc) {
Fred Drake4ec5d562001-10-04 19:26:43 +00002541 if (why == WHY_EXCEPTION)
2542 call_trace_protected(tstate->c_profilefunc,
2543 tstate->c_profileobj, f,
Armin Rigo1c2d7e52005-09-20 18:34:01 +00002544 PyTrace_RETURN, NULL);
Fred Drake4ec5d562001-10-04 19:26:43 +00002545 else if (call_trace(tstate->c_profilefunc,
2546 tstate->c_profileobj, f,
2547 PyTrace_RETURN, retval)) {
Fred Drake9e3ad782001-07-03 23:39:52 +00002548 Py_XDECREF(retval);
2549 retval = NULL;
2550 why = WHY_EXCEPTION;
2551 }
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00002552 }
Guido van Rossum96a42c81992-01-12 02:29:51 +00002553 }
Guido van Rossuma4240131997-01-21 21:18:36 +00002554
Thomas Wouters477c8d52006-05-27 19:21:47 +00002555 if (tstate->frame->f_exc_type != NULL)
2556 reset_exc_info(tstate);
2557 else {
2558 assert(tstate->frame->f_exc_value == NULL);
2559 assert(tstate->frame->f_exc_traceback == NULL);
2560 }
Guido van Rossuma027efa1997-05-05 20:56:21 +00002561
Tim Peters5ca576e2001-06-18 22:08:13 +00002562 /* pop frame */
Armin Rigo2b3eb402003-10-28 12:05:48 +00002563 exit_eval_frame:
2564 Py_LeaveRecursiveCall();
Guido van Rossuma027efa1997-05-05 20:56:21 +00002565 tstate->frame = f->f_back;
Guido van Rossumac7be682001-01-17 15:42:30 +00002566
Guido van Rossum96a42c81992-01-12 02:29:51 +00002567 return retval;
Guido van Rossum374a9221991-04-04 10:40:29 +00002568}
2569
Guido van Rossumc2e20742006-02-27 22:32:47 +00002570/* This is gonna seem *real weird*, but if you put some other code between
Martin v. Löwis8d97e332004-06-27 15:43:12 +00002571 PyEval_EvalFrame() and PyEval_EvalCodeEx() you will need to adjust
Guido van Rossumc2e20742006-02-27 22:32:47 +00002572 the test in the if statements in Misc/gdbinit (pystack and pystackv). */
Skip Montanaro786ea6b2004-03-01 15:44:05 +00002573
Tim Peters6d6c1a32001-08-02 04:15:00 +00002574PyObject *
2575PyEval_EvalCodeEx(PyCodeObject *co, PyObject *globals, PyObject *locals,
Tim Peters5ca576e2001-06-18 22:08:13 +00002576 PyObject **args, int argcount, PyObject **kws, int kwcount,
Guido van Rossum4f72a782006-10-27 23:31:49 +00002577 PyObject **defs, int defcount, PyObject *kwdefs, PyObject *closure)
Tim Peters5ca576e2001-06-18 22:08:13 +00002578{
2579 register PyFrameObject *f;
2580 register PyObject *retval = NULL;
2581 register PyObject **fastlocals, **freevars;
2582 PyThreadState *tstate = PyThreadState_GET();
2583 PyObject *x, *u;
2584
2585 if (globals == NULL) {
Tim Peters8a5c3c72004-04-05 19:36:21 +00002586 PyErr_SetString(PyExc_SystemError,
Jeremy Hylton910d7d42001-08-12 21:52:24 +00002587 "PyEval_EvalCodeEx: NULL globals");
Tim Peters5ca576e2001-06-18 22:08:13 +00002588 return NULL;
2589 }
2590
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00002591 assert(tstate != NULL);
Jeremy Hylton985eba52003-02-05 23:13:00 +00002592 assert(globals != NULL);
2593 f = PyFrame_New(tstate, co, globals, locals);
Tim Peters5ca576e2001-06-18 22:08:13 +00002594 if (f == NULL)
2595 return NULL;
2596
2597 fastlocals = f->f_localsplus;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002598 freevars = f->f_localsplus + co->co_nlocals;
Tim Peters5ca576e2001-06-18 22:08:13 +00002599
2600 if (co->co_argcount > 0 ||
Guido van Rossum4f72a782006-10-27 23:31:49 +00002601 co->co_kwonlyargcount > 0 ||
Tim Peters5ca576e2001-06-18 22:08:13 +00002602 co->co_flags & (CO_VARARGS | CO_VARKEYWORDS)) {
2603 int i;
2604 int n = argcount;
2605 PyObject *kwdict = NULL;
2606 if (co->co_flags & CO_VARKEYWORDS) {
2607 kwdict = PyDict_New();
2608 if (kwdict == NULL)
2609 goto fail;
Guido van Rossum4f72a782006-10-27 23:31:49 +00002610 i = co->co_argcount + co->co_kwonlyargcount;
Tim Peters5ca576e2001-06-18 22:08:13 +00002611 if (co->co_flags & CO_VARARGS)
2612 i++;
2613 SETLOCAL(i, kwdict);
2614 }
2615 if (argcount > co->co_argcount) {
2616 if (!(co->co_flags & CO_VARARGS)) {
2617 PyErr_Format(PyExc_TypeError,
2618 "%.200s() takes %s %d "
Guido van Rossum4f72a782006-10-27 23:31:49 +00002619 "%spositional argument%s (%d given)",
Tim Peters5ca576e2001-06-18 22:08:13 +00002620 PyString_AsString(co->co_name),
2621 defcount ? "at most" : "exactly",
2622 co->co_argcount,
2623 kwcount ? "non-keyword " : "",
2624 co->co_argcount == 1 ? "" : "s",
2625 argcount);
2626 goto fail;
2627 }
2628 n = co->co_argcount;
2629 }
2630 for (i = 0; i < n; i++) {
2631 x = args[i];
2632 Py_INCREF(x);
2633 SETLOCAL(i, x);
2634 }
2635 if (co->co_flags & CO_VARARGS) {
2636 u = PyTuple_New(argcount - n);
2637 if (u == NULL)
2638 goto fail;
Guido van Rossum4f72a782006-10-27 23:31:49 +00002639 SETLOCAL(co->co_argcount + co->co_kwonlyargcount, u);
Tim Peters5ca576e2001-06-18 22:08:13 +00002640 for (i = n; i < argcount; i++) {
2641 x = args[i];
2642 Py_INCREF(x);
2643 PyTuple_SET_ITEM(u, i-n, x);
2644 }
2645 }
2646 for (i = 0; i < kwcount; i++) {
2647 PyObject *keyword = kws[2*i];
2648 PyObject *value = kws[2*i + 1];
2649 int j;
2650 if (keyword == NULL || !PyString_Check(keyword)) {
2651 PyErr_Format(PyExc_TypeError,
2652 "%.200s() keywords must be strings",
2653 PyString_AsString(co->co_name));
2654 goto fail;
2655 }
2656 /* XXX slow -- speed up using dictionary? */
Guido van Rossum4f72a782006-10-27 23:31:49 +00002657 for (j = 0;
2658 j < co->co_argcount + co->co_kwonlyargcount;
2659 j++) {
Tim Peters5ca576e2001-06-18 22:08:13 +00002660 PyObject *nm = PyTuple_GET_ITEM(
2661 co->co_varnames, j);
2662 int cmp = PyObject_RichCompareBool(
2663 keyword, nm, Py_EQ);
2664 if (cmp > 0)
2665 break;
2666 else if (cmp < 0)
2667 goto fail;
2668 }
2669 /* Check errors from Compare */
2670 if (PyErr_Occurred())
2671 goto fail;
Guido van Rossum4f72a782006-10-27 23:31:49 +00002672 if (j >= co->co_argcount + co->co_kwonlyargcount) {
Tim Peters5ca576e2001-06-18 22:08:13 +00002673 if (kwdict == NULL) {
2674 PyErr_Format(PyExc_TypeError,
2675 "%.200s() got an unexpected "
2676 "keyword argument '%.400s'",
2677 PyString_AsString(co->co_name),
2678 PyString_AsString(keyword));
2679 goto fail;
2680 }
2681 PyDict_SetItem(kwdict, keyword, value);
2682 }
2683 else {
2684 if (GETLOCAL(j) != NULL) {
2685 PyErr_Format(PyExc_TypeError,
2686 "%.200s() got multiple "
2687 "values for keyword "
2688 "argument '%.400s'",
2689 PyString_AsString(co->co_name),
2690 PyString_AsString(keyword));
2691 goto fail;
2692 }
2693 Py_INCREF(value);
2694 SETLOCAL(j, value);
2695 }
2696 }
Guido van Rossum4f72a782006-10-27 23:31:49 +00002697 if (co->co_kwonlyargcount > 0) {
2698 for (i = co->co_argcount;
2699 i < co->co_argcount + co->co_kwonlyargcount;
2700 i++) {
Guido van Rossum29602e42006-11-22 04:45:33 +00002701 PyObject *name, *def;
Guido van Rossum4f72a782006-10-27 23:31:49 +00002702 if (GETLOCAL(i) != NULL)
2703 continue;
Guido van Rossum29602e42006-11-22 04:45:33 +00002704 name = PyTuple_GET_ITEM(co->co_varnames, i);
2705 def = NULL;
Guido van Rossum4f72a782006-10-27 23:31:49 +00002706 if (kwdefs != NULL)
2707 def = PyDict_GetItem(kwdefs, name);
2708 if (def != NULL) {
2709 Py_INCREF(def);
2710 SETLOCAL(i, def);
2711 continue;
2712 }
2713 PyErr_Format(PyExc_TypeError,
2714 "%.200s() needs "
Brett Cannone33a6112007-01-29 23:43:38 +00002715 "keyword-only argument %s",
Guido van Rossum4f72a782006-10-27 23:31:49 +00002716 PyString_AsString(co->co_name),
2717 PyString_AsString(name));
2718 goto fail;
2719 }
2720 }
Tim Peters5ca576e2001-06-18 22:08:13 +00002721 if (argcount < co->co_argcount) {
2722 int m = co->co_argcount - defcount;
2723 for (i = argcount; i < m; i++) {
2724 if (GETLOCAL(i) == NULL) {
2725 PyErr_Format(PyExc_TypeError,
2726 "%.200s() takes %s %d "
Guido van Rossum4f72a782006-10-27 23:31:49 +00002727 "%spositional argument%s "
2728 "(%d given)",
Tim Peters5ca576e2001-06-18 22:08:13 +00002729 PyString_AsString(co->co_name),
2730 ((co->co_flags & CO_VARARGS) ||
2731 defcount) ? "at least"
2732 : "exactly",
2733 m, kwcount ? "non-keyword " : "",
2734 m == 1 ? "" : "s", i);
2735 goto fail;
2736 }
2737 }
2738 if (n > m)
2739 i = n - m;
2740 else
2741 i = 0;
2742 for (; i < defcount; i++) {
2743 if (GETLOCAL(m+i) == NULL) {
2744 PyObject *def = defs[i];
2745 Py_INCREF(def);
2746 SETLOCAL(m+i, def);
2747 }
2748 }
2749 }
2750 }
2751 else {
2752 if (argcount > 0 || kwcount > 0) {
2753 PyErr_Format(PyExc_TypeError,
2754 "%.200s() takes no arguments (%d given)",
2755 PyString_AsString(co->co_name),
2756 argcount + kwcount);
2757 goto fail;
2758 }
2759 }
2760 /* Allocate and initialize storage for cell vars, and copy free
2761 vars into frame. This isn't too efficient right now. */
Thomas Wouters477c8d52006-05-27 19:21:47 +00002762 if (PyTuple_GET_SIZE(co->co_cellvars)) {
Thomas Wouters0e3f5912006-08-11 14:57:12 +00002763 int i, j, nargs, found;
Tim Peters5ca576e2001-06-18 22:08:13 +00002764 char *cellname, *argname;
2765 PyObject *c;
2766
2767 nargs = co->co_argcount;
2768 if (co->co_flags & CO_VARARGS)
2769 nargs++;
2770 if (co->co_flags & CO_VARKEYWORDS)
2771 nargs++;
2772
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00002773 /* Initialize each cell var, taking into account
2774 cell vars that are initialized from arguments.
2775
2776 Should arrange for the compiler to put cellvars
2777 that are arguments at the beginning of the cellvars
2778 list so that we can march over it more efficiently?
2779 */
Thomas Wouters477c8d52006-05-27 19:21:47 +00002780 for (i = 0; i < PyTuple_GET_SIZE(co->co_cellvars); ++i) {
Tim Peters5ca576e2001-06-18 22:08:13 +00002781 cellname = PyString_AS_STRING(
2782 PyTuple_GET_ITEM(co->co_cellvars, i));
2783 found = 0;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00002784 for (j = 0; j < nargs; j++) {
Tim Peters5ca576e2001-06-18 22:08:13 +00002785 argname = PyString_AS_STRING(
2786 PyTuple_GET_ITEM(co->co_varnames, j));
2787 if (strcmp(cellname, argname) == 0) {
2788 c = PyCell_New(GETLOCAL(j));
2789 if (c == NULL)
2790 goto fail;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002791 GETLOCAL(co->co_nlocals + i) = c;
Tim Peters5ca576e2001-06-18 22:08:13 +00002792 found = 1;
2793 break;
2794 }
Tim Peters5ca576e2001-06-18 22:08:13 +00002795 }
2796 if (found == 0) {
2797 c = PyCell_New(NULL);
2798 if (c == NULL)
2799 goto fail;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002800 SETLOCAL(co->co_nlocals + i, c);
Tim Peters5ca576e2001-06-18 22:08:13 +00002801 }
2802 }
Tim Peters5ca576e2001-06-18 22:08:13 +00002803 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002804 if (PyTuple_GET_SIZE(co->co_freevars)) {
Tim Peters5ca576e2001-06-18 22:08:13 +00002805 int i;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002806 for (i = 0; i < PyTuple_GET_SIZE(co->co_freevars); ++i) {
Tim Peters5ca576e2001-06-18 22:08:13 +00002807 PyObject *o = PyTuple_GET_ITEM(closure, i);
2808 Py_INCREF(o);
Thomas Wouters477c8d52006-05-27 19:21:47 +00002809 freevars[PyTuple_GET_SIZE(co->co_cellvars) + i] = o;
Tim Peters5ca576e2001-06-18 22:08:13 +00002810 }
2811 }
2812
Tim Peters5ca576e2001-06-18 22:08:13 +00002813 if (co->co_flags & CO_GENERATOR) {
Neil Schemenauer2b13ce82001-06-21 02:41:10 +00002814 /* Don't need to keep the reference to f_back, it will be set
2815 * when the generator is resumed. */
Tim Peters5ba58662001-07-16 02:29:45 +00002816 Py_XDECREF(f->f_back);
Neil Schemenauer2b13ce82001-06-21 02:41:10 +00002817 f->f_back = NULL;
2818
Jeremy Hylton985eba52003-02-05 23:13:00 +00002819 PCALL(PCALL_GENERATOR);
2820
Neil Schemenauer2b13ce82001-06-21 02:41:10 +00002821 /* Create a new generator that owns the ready to run frame
2822 * and return that as the value. */
Martin v. Löwise440e472004-06-01 15:22:42 +00002823 return PyGen_New(f);
Tim Peters5ca576e2001-06-18 22:08:13 +00002824 }
2825
Phillip J. Eby0d6615f2005-08-02 00:46:46 +00002826 retval = PyEval_EvalFrameEx(f,0);
Tim Peters5ca576e2001-06-18 22:08:13 +00002827
2828 fail: /* Jump here from prelude on failure */
2829
Tim Petersb13680b2001-11-27 23:29:29 +00002830 /* decref'ing the frame can cause __del__ methods to get invoked,
2831 which can call back into Python. While we're done with the
2832 current Python frame (f), the associated C stack is still in use,
2833 so recursion_depth must be boosted for the duration.
2834 */
2835 assert(tstate != NULL);
2836 ++tstate->recursion_depth;
Tim Peters5ca576e2001-06-18 22:08:13 +00002837 Py_DECREF(f);
Tim Petersb13680b2001-11-27 23:29:29 +00002838 --tstate->recursion_depth;
Tim Peters5ca576e2001-06-18 22:08:13 +00002839 return retval;
2840}
2841
2842
Guido van Rossumc9fbb722003-03-01 03:36:33 +00002843/* Implementation notes for set_exc_info() and reset_exc_info():
2844
2845- Below, 'exc_ZZZ' stands for 'exc_type', 'exc_value' and
2846 'exc_traceback'. These always travel together.
2847
2848- tstate->curexc_ZZZ is the "hot" exception that is set by
2849 PyErr_SetString(), cleared by PyErr_Clear(), and so on.
2850
2851- Once an exception is caught by an except clause, it is transferred
2852 from tstate->curexc_ZZZ to tstate->exc_ZZZ, from which sys.exc_info()
2853 can pick it up. This is the primary task of set_exc_info().
Thomas Wouters477c8d52006-05-27 19:21:47 +00002854 XXX That can't be right: set_exc_info() doesn't look at tstate->curexc_ZZZ.
Guido van Rossumc9fbb722003-03-01 03:36:33 +00002855
2856- Now let me explain the complicated dance with frame->f_exc_ZZZ.
2857
2858 Long ago, when none of this existed, there were just a few globals:
2859 one set corresponding to the "hot" exception, and one set
2860 corresponding to sys.exc_ZZZ. (Actually, the latter weren't C
2861 globals; they were simply stored as sys.exc_ZZZ. For backwards
2862 compatibility, they still are!) The problem was that in code like
2863 this:
2864
2865 try:
2866 "something that may fail"
2867 except "some exception":
2868 "do something else first"
2869 "print the exception from sys.exc_ZZZ."
2870
2871 if "do something else first" invoked something that raised and caught
2872 an exception, sys.exc_ZZZ were overwritten. That was a frequent
2873 cause of subtle bugs. I fixed this by changing the semantics as
2874 follows:
2875
2876 - Within one frame, sys.exc_ZZZ will hold the last exception caught
2877 *in that frame*.
2878
2879 - But initially, and as long as no exception is caught in a given
2880 frame, sys.exc_ZZZ will hold the last exception caught in the
2881 previous frame (or the frame before that, etc.).
2882
2883 The first bullet fixed the bug in the above example. The second
2884 bullet was for backwards compatibility: it was (and is) common to
2885 have a function that is called when an exception is caught, and to
2886 have that function access the caught exception via sys.exc_ZZZ.
2887 (Example: traceback.print_exc()).
2888
2889 At the same time I fixed the problem that sys.exc_ZZZ weren't
2890 thread-safe, by introducing sys.exc_info() which gets it from tstate;
2891 but that's really a separate improvement.
2892
2893 The reset_exc_info() function in ceval.c restores the tstate->exc_ZZZ
2894 variables to what they were before the current frame was called. The
2895 set_exc_info() function saves them on the frame so that
2896 reset_exc_info() can restore them. The invariant is that
2897 frame->f_exc_ZZZ is NULL iff the current frame never caught an
2898 exception (where "catching" an exception applies only to successful
2899 except clauses); and if the current frame ever caught an exception,
2900 frame->f_exc_ZZZ is the exception that was stored in tstate->exc_ZZZ
2901 at the start of the current frame.
2902
2903*/
2904
Guido van Rossuma027efa1997-05-05 20:56:21 +00002905static void
Guido van Rossumac7be682001-01-17 15:42:30 +00002906set_exc_info(PyThreadState *tstate,
2907 PyObject *type, PyObject *value, PyObject *tb)
Guido van Rossuma027efa1997-05-05 20:56:21 +00002908{
Thomas Wouters477c8d52006-05-27 19:21:47 +00002909 PyFrameObject *frame = tstate->frame;
Guido van Rossumdf4c3081997-05-20 17:06:11 +00002910 PyObject *tmp_type, *tmp_value, *tmp_tb;
Barry Warsaw4249f541997-08-22 21:26:19 +00002911
Thomas Wouters477c8d52006-05-27 19:21:47 +00002912 assert(type != NULL);
2913 assert(frame != NULL);
Guido van Rossuma027efa1997-05-05 20:56:21 +00002914 if (frame->f_exc_type == NULL) {
Thomas Wouters477c8d52006-05-27 19:21:47 +00002915 assert(frame->f_exc_value == NULL);
2916 assert(frame->f_exc_traceback == NULL);
2917 /* This frame didn't catch an exception before. */
2918 /* Save previous exception of this thread in this frame. */
Guido van Rossuma027efa1997-05-05 20:56:21 +00002919 if (tstate->exc_type == NULL) {
Thomas Wouters477c8d52006-05-27 19:21:47 +00002920 /* XXX Why is this set to Py_None? */
Guido van Rossuma027efa1997-05-05 20:56:21 +00002921 Py_INCREF(Py_None);
2922 tstate->exc_type = Py_None;
2923 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002924 Py_INCREF(tstate->exc_type);
Guido van Rossuma027efa1997-05-05 20:56:21 +00002925 Py_XINCREF(tstate->exc_value);
2926 Py_XINCREF(tstate->exc_traceback);
2927 frame->f_exc_type = tstate->exc_type;
2928 frame->f_exc_value = tstate->exc_value;
2929 frame->f_exc_traceback = tstate->exc_traceback;
2930 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002931 /* Set new exception for this thread. */
Guido van Rossumdf4c3081997-05-20 17:06:11 +00002932 tmp_type = tstate->exc_type;
2933 tmp_value = tstate->exc_value;
2934 tmp_tb = tstate->exc_traceback;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002935 Py_INCREF(type);
Guido van Rossuma027efa1997-05-05 20:56:21 +00002936 Py_XINCREF(value);
2937 Py_XINCREF(tb);
2938 tstate->exc_type = type;
2939 tstate->exc_value = value;
2940 tstate->exc_traceback = tb;
Guido van Rossumdf4c3081997-05-20 17:06:11 +00002941 Py_XDECREF(tmp_type);
2942 Py_XDECREF(tmp_value);
2943 Py_XDECREF(tmp_tb);
Guido van Rossuma027efa1997-05-05 20:56:21 +00002944 /* For b/w compatibility */
2945 PySys_SetObject("exc_type", type);
2946 PySys_SetObject("exc_value", value);
2947 PySys_SetObject("exc_traceback", tb);
2948}
2949
2950static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002951reset_exc_info(PyThreadState *tstate)
Guido van Rossuma027efa1997-05-05 20:56:21 +00002952{
2953 PyFrameObject *frame;
Guido van Rossumdf4c3081997-05-20 17:06:11 +00002954 PyObject *tmp_type, *tmp_value, *tmp_tb;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002955
2956 /* It's a precondition that the thread state's frame caught an
2957 * exception -- verify in a debug build.
2958 */
2959 assert(tstate != NULL);
Guido van Rossuma027efa1997-05-05 20:56:21 +00002960 frame = tstate->frame;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002961 assert(frame != NULL);
2962 assert(frame->f_exc_type != NULL);
2963
2964 /* Copy the frame's exception info back to the thread state. */
2965 tmp_type = tstate->exc_type;
2966 tmp_value = tstate->exc_value;
2967 tmp_tb = tstate->exc_traceback;
2968 Py_INCREF(frame->f_exc_type);
2969 Py_XINCREF(frame->f_exc_value);
2970 Py_XINCREF(frame->f_exc_traceback);
2971 tstate->exc_type = frame->f_exc_type;
2972 tstate->exc_value = frame->f_exc_value;
2973 tstate->exc_traceback = frame->f_exc_traceback;
2974 Py_XDECREF(tmp_type);
2975 Py_XDECREF(tmp_value);
2976 Py_XDECREF(tmp_tb);
2977
2978 /* For b/w compatibility */
2979 PySys_SetObject("exc_type", frame->f_exc_type);
2980 PySys_SetObject("exc_value", frame->f_exc_value);
2981 PySys_SetObject("exc_traceback", frame->f_exc_traceback);
2982
2983 /* Clear the frame's exception info. */
Guido van Rossumdf4c3081997-05-20 17:06:11 +00002984 tmp_type = frame->f_exc_type;
2985 tmp_value = frame->f_exc_value;
2986 tmp_tb = frame->f_exc_traceback;
Guido van Rossuma027efa1997-05-05 20:56:21 +00002987 frame->f_exc_type = NULL;
2988 frame->f_exc_value = NULL;
2989 frame->f_exc_traceback = NULL;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002990 Py_DECREF(tmp_type);
Guido van Rossumdf4c3081997-05-20 17:06:11 +00002991 Py_XDECREF(tmp_value);
2992 Py_XDECREF(tmp_tb);
Guido van Rossuma027efa1997-05-05 20:56:21 +00002993}
2994
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00002995/* Logic for the raise statement (too complicated for inlining).
2996 This *consumes* a reference count to each of its arguments. */
Raymond Hettinger7c958652004-04-06 10:11:10 +00002997static enum why_code
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002998do_raise(PyObject *type, PyObject *value, PyObject *tb)
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00002999{
Guido van Rossumd295f121998-04-09 21:39:57 +00003000 if (type == NULL) {
3001 /* Reraise */
Nicholas Bastine5662ae2004-03-24 22:22:12 +00003002 PyThreadState *tstate = PyThreadState_GET();
Guido van Rossumd295f121998-04-09 21:39:57 +00003003 type = tstate->exc_type == NULL ? Py_None : tstate->exc_type;
3004 value = tstate->exc_value;
3005 tb = tstate->exc_traceback;
3006 Py_XINCREF(type);
3007 Py_XINCREF(value);
3008 Py_XINCREF(tb);
3009 }
Guido van Rossumac7be682001-01-17 15:42:30 +00003010
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00003011 /* We support the following forms of raise:
3012 raise <class>, <classinstance>
3013 raise <class>, <argument tuple>
3014 raise <class>, None
3015 raise <class>, <argument>
3016 raise <classinstance>, None
3017 raise <string>, <object>
3018 raise <string>, None
3019
3020 An omitted second argument is the same as None.
3021
3022 In addition, raise <tuple>, <anything> is the same as
3023 raising the tuple's first item (and it better have one!);
3024 this rule is applied recursively.
3025
3026 Finally, an optional third argument can be supplied, which
3027 gives the traceback to be substituted (useful when
3028 re-raising an exception after examining it). */
3029
3030 /* First, check the traceback argument, replacing None with
3031 NULL. */
Guido van Rossumb209a111997-04-29 18:18:01 +00003032 if (tb == Py_None) {
3033 Py_DECREF(tb);
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00003034 tb = NULL;
3035 }
3036 else if (tb != NULL && !PyTraceBack_Check(tb)) {
Guido van Rossumb209a111997-04-29 18:18:01 +00003037 PyErr_SetString(PyExc_TypeError,
Fred Drake661ea262000-10-24 19:57:45 +00003038 "raise: arg 3 must be a traceback or None");
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00003039 goto raise_error;
3040 }
3041
3042 /* Next, replace a missing value with None */
3043 if (value == NULL) {
Guido van Rossumb209a111997-04-29 18:18:01 +00003044 value = Py_None;
3045 Py_INCREF(value);
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00003046 }
3047
3048 /* Next, repeatedly, replace a tuple exception with its first item */
Guido van Rossumb209a111997-04-29 18:18:01 +00003049 while (PyTuple_Check(type) && PyTuple_Size(type) > 0) {
3050 PyObject *tmp = type;
3051 type = PyTuple_GET_ITEM(type, 0);
3052 Py_INCREF(type);
3053 Py_DECREF(tmp);
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00003054 }
3055
Guido van Rossum45aecf42006-03-15 04:58:47 +00003056 if (PyExceptionClass_Check(type))
Barry Warsaw4249f541997-08-22 21:26:19 +00003057 PyErr_NormalizeException(&type, &value, &tb);
3058
Brett Cannonbf364092006-03-01 04:25:17 +00003059 else if (PyExceptionInstance_Check(type)) {
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00003060 /* Raising an instance. The value should be a dummy. */
Guido van Rossumb209a111997-04-29 18:18:01 +00003061 if (value != Py_None) {
3062 PyErr_SetString(PyExc_TypeError,
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00003063 "instance exception may not have a separate value");
3064 goto raise_error;
3065 }
3066 else {
3067 /* Normalize to raise <class>, <instance> */
Guido van Rossumb209a111997-04-29 18:18:01 +00003068 Py_DECREF(value);
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00003069 value = type;
Brett Cannonbf364092006-03-01 04:25:17 +00003070 type = PyExceptionInstance_Class(type);
Guido van Rossumb209a111997-04-29 18:18:01 +00003071 Py_INCREF(type);
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00003072 }
3073 }
3074 else {
3075 /* Not something you can raise. You get an exception
3076 anyway, just not what you specified :-) */
Guido van Rossum45aecf42006-03-15 04:58:47 +00003077 PyErr_SetString(PyExc_TypeError,
3078 "exceptions must derive from BaseException");
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00003079 goto raise_error;
3080 }
Guido van Rossumb209a111997-04-29 18:18:01 +00003081 PyErr_Restore(type, value, tb);
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00003082 if (tb == NULL)
3083 return WHY_EXCEPTION;
3084 else
3085 return WHY_RERAISE;
3086 raise_error:
Guido van Rossumb209a111997-04-29 18:18:01 +00003087 Py_XDECREF(value);
3088 Py_XDECREF(type);
3089 Py_XDECREF(tb);
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00003090 return WHY_EXCEPTION;
3091}
3092
Tim Petersd6d010b2001-06-21 02:49:55 +00003093/* Iterate v argcnt times and store the results on the stack (via decreasing
3094 sp). Return 1 for success, 0 if error. */
3095
Barry Warsawe42b18f1997-08-25 22:13:04 +00003096static int
Tim Petersd6d010b2001-06-21 02:49:55 +00003097unpack_iterable(PyObject *v, int argcnt, PyObject **sp)
Barry Warsawe42b18f1997-08-25 22:13:04 +00003098{
Tim Petersd6d010b2001-06-21 02:49:55 +00003099 int i = 0;
3100 PyObject *it; /* iter(v) */
Barry Warsawe42b18f1997-08-25 22:13:04 +00003101 PyObject *w;
Guido van Rossumac7be682001-01-17 15:42:30 +00003102
Tim Petersd6d010b2001-06-21 02:49:55 +00003103 assert(v != NULL);
3104
3105 it = PyObject_GetIter(v);
3106 if (it == NULL)
3107 goto Error;
3108
3109 for (; i < argcnt; i++) {
3110 w = PyIter_Next(it);
3111 if (w == NULL) {
3112 /* Iterator done, via error or exhaustion. */
3113 if (!PyErr_Occurred()) {
3114 PyErr_Format(PyExc_ValueError,
3115 "need more than %d value%s to unpack",
3116 i, i == 1 ? "" : "s");
3117 }
3118 goto Error;
Barry Warsawe42b18f1997-08-25 22:13:04 +00003119 }
3120 *--sp = w;
3121 }
Tim Petersd6d010b2001-06-21 02:49:55 +00003122
3123 /* We better have exhausted the iterator now. */
3124 w = PyIter_Next(it);
3125 if (w == NULL) {
3126 if (PyErr_Occurred())
3127 goto Error;
3128 Py_DECREF(it);
3129 return 1;
Barry Warsawe42b18f1997-08-25 22:13:04 +00003130 }
Guido van Rossumbb8f59a2001-12-03 19:33:25 +00003131 Py_DECREF(w);
Tim Petersd6d010b2001-06-21 02:49:55 +00003132 PyErr_SetString(PyExc_ValueError, "too many values to unpack");
Barry Warsawe42b18f1997-08-25 22:13:04 +00003133 /* fall through */
Tim Petersd6d010b2001-06-21 02:49:55 +00003134Error:
Barry Warsaw91010551997-08-25 22:30:51 +00003135 for (; i > 0; i--, sp++)
3136 Py_DECREF(*sp);
Tim Petersd6d010b2001-06-21 02:49:55 +00003137 Py_XDECREF(it);
Barry Warsawe42b18f1997-08-25 22:13:04 +00003138 return 0;
3139}
3140
3141
Guido van Rossum96a42c81992-01-12 02:29:51 +00003142#ifdef LLTRACE
Guido van Rossum3f5da241990-12-20 15:06:42 +00003143static int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003144prtrace(PyObject *v, char *str)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003145{
Guido van Rossum3f5da241990-12-20 15:06:42 +00003146 printf("%s ", str);
Guido van Rossumb209a111997-04-29 18:18:01 +00003147 if (PyObject_Print(v, stdout, 0) != 0)
3148 PyErr_Clear(); /* Don't know what else to do */
Guido van Rossum3f5da241990-12-20 15:06:42 +00003149 printf("\n");
Guido van Rossumcc229ea2000-05-04 00:55:17 +00003150 return 1;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003151}
Guido van Rossum3f5da241990-12-20 15:06:42 +00003152#endif
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003153
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00003154static void
Fred Drake5755ce62001-06-27 19:19:46 +00003155call_exc_trace(Py_tracefunc func, PyObject *self, PyFrameObject *f)
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00003156{
Guido van Rossumb209a111997-04-29 18:18:01 +00003157 PyObject *type, *value, *traceback, *arg;
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00003158 int err;
Guido van Rossumb209a111997-04-29 18:18:01 +00003159 PyErr_Fetch(&type, &value, &traceback);
Guido van Rossumbd9ccca1992-04-09 14:58:08 +00003160 if (value == NULL) {
Guido van Rossumb209a111997-04-29 18:18:01 +00003161 value = Py_None;
3162 Py_INCREF(value);
Guido van Rossumbd9ccca1992-04-09 14:58:08 +00003163 }
Raymond Hettinger8ae46892003-10-12 19:09:37 +00003164 arg = PyTuple_Pack(3, type, value, traceback);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003165 if (arg == NULL) {
Guido van Rossumb209a111997-04-29 18:18:01 +00003166 PyErr_Restore(type, value, traceback);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003167 return;
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00003168 }
Fred Drake5755ce62001-06-27 19:19:46 +00003169 err = call_trace(func, self, f, PyTrace_EXCEPTION, arg);
Guido van Rossumb209a111997-04-29 18:18:01 +00003170 Py_DECREF(arg);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003171 if (err == 0)
Guido van Rossumb209a111997-04-29 18:18:01 +00003172 PyErr_Restore(type, value, traceback);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003173 else {
Guido van Rossumb209a111997-04-29 18:18:01 +00003174 Py_XDECREF(type);
3175 Py_XDECREF(value);
3176 Py_XDECREF(traceback);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003177 }
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00003178}
3179
Fred Drake4ec5d562001-10-04 19:26:43 +00003180static void
3181call_trace_protected(Py_tracefunc func, PyObject *obj, PyFrameObject *frame,
Armin Rigo1c2d7e52005-09-20 18:34:01 +00003182 int what, PyObject *arg)
Fred Drake4ec5d562001-10-04 19:26:43 +00003183{
3184 PyObject *type, *value, *traceback;
3185 int err;
3186 PyErr_Fetch(&type, &value, &traceback);
Armin Rigo1c2d7e52005-09-20 18:34:01 +00003187 err = call_trace(func, obj, frame, what, arg);
Fred Drake4ec5d562001-10-04 19:26:43 +00003188 if (err == 0)
3189 PyErr_Restore(type, value, traceback);
3190 else {
3191 Py_XDECREF(type);
3192 Py_XDECREF(value);
3193 Py_XDECREF(traceback);
3194 }
3195}
3196
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00003197static int
Fred Drake5755ce62001-06-27 19:19:46 +00003198call_trace(Py_tracefunc func, PyObject *obj, PyFrameObject *frame,
3199 int what, PyObject *arg)
Guido van Rossum96a42c81992-01-12 02:29:51 +00003200{
Fred Drake5755ce62001-06-27 19:19:46 +00003201 register PyThreadState *tstate = frame->f_tstate;
3202 int result;
3203 if (tstate->tracing)
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00003204 return 0;
Guido van Rossuma027efa1997-05-05 20:56:21 +00003205 tstate->tracing++;
Fred Drake9e3ad782001-07-03 23:39:52 +00003206 tstate->use_tracing = 0;
Fred Drake5755ce62001-06-27 19:19:46 +00003207 result = func(obj, frame, what, arg);
Fred Drake9e3ad782001-07-03 23:39:52 +00003208 tstate->use_tracing = ((tstate->c_tracefunc != NULL)
3209 || (tstate->c_profilefunc != NULL));
Guido van Rossuma027efa1997-05-05 20:56:21 +00003210 tstate->tracing--;
Fred Drake5755ce62001-06-27 19:19:46 +00003211 return result;
Guido van Rossum96a42c81992-01-12 02:29:51 +00003212}
3213
Guido van Rossuma12fe4e2003-04-09 19:06:21 +00003214PyObject *
3215_PyEval_CallTracing(PyObject *func, PyObject *args)
3216{
3217 PyFrameObject *frame = PyEval_GetFrame();
3218 PyThreadState *tstate = frame->f_tstate;
3219 int save_tracing = tstate->tracing;
3220 int save_use_tracing = tstate->use_tracing;
3221 PyObject *result;
3222
3223 tstate->tracing = 0;
3224 tstate->use_tracing = ((tstate->c_tracefunc != NULL)
3225 || (tstate->c_profilefunc != NULL));
3226 result = PyObject_Call(func, args, NULL);
3227 tstate->tracing = save_tracing;
3228 tstate->use_tracing = save_use_tracing;
3229 return result;
3230}
3231
Michael W. Hudson006c7522002-11-08 13:08:46 +00003232static int
Tim Peters8a5c3c72004-04-05 19:36:21 +00003233maybe_call_line_trace(Py_tracefunc func, PyObject *obj,
Armin Rigobf57a142004-03-22 19:24:58 +00003234 PyFrameObject *frame, int *instr_lb, int *instr_ub,
3235 int *instr_prev)
Michael W. Hudsondd32a912002-08-15 14:59:02 +00003236{
Michael W. Hudson006c7522002-11-08 13:08:46 +00003237 int result = 0;
3238
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00003239 /* If the last instruction executed isn't in the current
3240 instruction window, reset the window. If the last
3241 instruction happens to fall at the start of a line or if it
3242 represents a jump backwards, call the trace function.
3243 */
Michael W. Hudson53d58bb2002-08-30 13:09:51 +00003244 if ((frame->f_lasti < *instr_lb || frame->f_lasti >= *instr_ub)) {
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00003245 int line;
3246 PyAddrPair bounds;
Michael W. Hudsondd32a912002-08-15 14:59:02 +00003247
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00003248 line = PyCode_CheckLineNumber(frame->f_code, frame->f_lasti,
3249 &bounds);
3250 if (line >= 0) {
Michael W. Hudson02ff6a92002-09-11 15:36:32 +00003251 frame->f_lineno = line;
Tim Peters8a5c3c72004-04-05 19:36:21 +00003252 result = call_trace(func, obj, frame,
Michael W. Hudson006c7522002-11-08 13:08:46 +00003253 PyTrace_LINE, Py_None);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00003254 }
3255 *instr_lb = bounds.ap_lower;
3256 *instr_ub = bounds.ap_upper;
Michael W. Hudsondd32a912002-08-15 14:59:02 +00003257 }
Armin Rigobf57a142004-03-22 19:24:58 +00003258 else if (frame->f_lasti <= *instr_prev) {
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00003259 result = call_trace(func, obj, frame, PyTrace_LINE, Py_None);
Armin Rigobf57a142004-03-22 19:24:58 +00003260 }
3261 *instr_prev = frame->f_lasti;
Michael W. Hudson006c7522002-11-08 13:08:46 +00003262 return result;
Michael W. Hudsondd32a912002-08-15 14:59:02 +00003263}
3264
Fred Drake5755ce62001-06-27 19:19:46 +00003265void
3266PyEval_SetProfile(Py_tracefunc func, PyObject *arg)
Fred Draked0838392001-06-16 21:02:31 +00003267{
Nicholas Bastine5662ae2004-03-24 22:22:12 +00003268 PyThreadState *tstate = PyThreadState_GET();
Fred Drake5755ce62001-06-27 19:19:46 +00003269 PyObject *temp = tstate->c_profileobj;
3270 Py_XINCREF(arg);
3271 tstate->c_profilefunc = NULL;
3272 tstate->c_profileobj = NULL;
Brett Cannon55fa66d2005-06-25 07:07:35 +00003273 /* Must make sure that tracing is not ignored if 'temp' is freed */
Fred Drake9e3ad782001-07-03 23:39:52 +00003274 tstate->use_tracing = tstate->c_tracefunc != NULL;
Fred Drake5755ce62001-06-27 19:19:46 +00003275 Py_XDECREF(temp);
3276 tstate->c_profilefunc = func;
3277 tstate->c_profileobj = arg;
Brett Cannon55fa66d2005-06-25 07:07:35 +00003278 /* Flag that tracing or profiling is turned on */
Fred Drake9e3ad782001-07-03 23:39:52 +00003279 tstate->use_tracing = (func != NULL) || (tstate->c_tracefunc != NULL);
Fred Drake5755ce62001-06-27 19:19:46 +00003280}
3281
3282void
3283PyEval_SetTrace(Py_tracefunc func, PyObject *arg)
3284{
Nicholas Bastine5662ae2004-03-24 22:22:12 +00003285 PyThreadState *tstate = PyThreadState_GET();
Fred Drake5755ce62001-06-27 19:19:46 +00003286 PyObject *temp = tstate->c_traceobj;
3287 Py_XINCREF(arg);
3288 tstate->c_tracefunc = NULL;
3289 tstate->c_traceobj = NULL;
Brett Cannon55fa66d2005-06-25 07:07:35 +00003290 /* Must make sure that profiling is not ignored if 'temp' is freed */
Fred Drake9e3ad782001-07-03 23:39:52 +00003291 tstate->use_tracing = tstate->c_profilefunc != NULL;
Fred Drake5755ce62001-06-27 19:19:46 +00003292 Py_XDECREF(temp);
3293 tstate->c_tracefunc = func;
3294 tstate->c_traceobj = arg;
Brett Cannon55fa66d2005-06-25 07:07:35 +00003295 /* Flag that tracing or profiling is turned on */
Fred Drake9e3ad782001-07-03 23:39:52 +00003296 tstate->use_tracing = ((func != NULL)
3297 || (tstate->c_profilefunc != NULL));
Fred Draked0838392001-06-16 21:02:31 +00003298}
3299
Guido van Rossumb209a111997-04-29 18:18:01 +00003300PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003301PyEval_GetBuiltins(void)
Guido van Rossum6135a871995-01-09 17:53:26 +00003302{
Guido van Rossum6297a7a2003-02-19 15:53:17 +00003303 PyFrameObject *current_frame = PyEval_GetFrame();
Guido van Rossum6135a871995-01-09 17:53:26 +00003304 if (current_frame == NULL)
Nicholas Bastine5662ae2004-03-24 22:22:12 +00003305 return PyThreadState_GET()->interp->builtins;
Guido van Rossum6135a871995-01-09 17:53:26 +00003306 else
3307 return current_frame->f_builtins;
3308}
3309
Guido van Rossumb209a111997-04-29 18:18:01 +00003310PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003311PyEval_GetLocals(void)
Guido van Rossum5b722181993-03-30 17:46:03 +00003312{
Guido van Rossum6297a7a2003-02-19 15:53:17 +00003313 PyFrameObject *current_frame = PyEval_GetFrame();
Guido van Rossum5b722181993-03-30 17:46:03 +00003314 if (current_frame == NULL)
3315 return NULL;
Guido van Rossumb209a111997-04-29 18:18:01 +00003316 PyFrame_FastToLocals(current_frame);
Guido van Rossum5b722181993-03-30 17:46:03 +00003317 return current_frame->f_locals;
3318}
3319
Guido van Rossumb209a111997-04-29 18:18:01 +00003320PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003321PyEval_GetGlobals(void)
Guido van Rossum3f5da241990-12-20 15:06:42 +00003322{
Guido van Rossum6297a7a2003-02-19 15:53:17 +00003323 PyFrameObject *current_frame = PyEval_GetFrame();
Guido van Rossum3f5da241990-12-20 15:06:42 +00003324 if (current_frame == NULL)
3325 return NULL;
3326 else
3327 return current_frame->f_globals;
3328}
3329
Guido van Rossum6297a7a2003-02-19 15:53:17 +00003330PyFrameObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003331PyEval_GetFrame(void)
Guido van Rossume59214e1994-08-30 08:01:59 +00003332{
Nicholas Bastine5662ae2004-03-24 22:22:12 +00003333 PyThreadState *tstate = PyThreadState_GET();
Guido van Rossum6297a7a2003-02-19 15:53:17 +00003334 return _PyThreadState_GetFrame(tstate);
Guido van Rossume59214e1994-08-30 08:01:59 +00003335}
3336
Guido van Rossum6135a871995-01-09 17:53:26 +00003337int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003338PyEval_GetRestricted(void)
Guido van Rossum6135a871995-01-09 17:53:26 +00003339{
Guido van Rossum6297a7a2003-02-19 15:53:17 +00003340 PyFrameObject *current_frame = PyEval_GetFrame();
Thomas Wouters0e3f5912006-08-11 14:57:12 +00003341 return current_frame == NULL ? 0 : PyFrame_IsRestricted(current_frame);
Guido van Rossum6135a871995-01-09 17:53:26 +00003342}
3343
Guido van Rossumbe270261997-05-22 22:26:18 +00003344int
Tim Peters5ba58662001-07-16 02:29:45 +00003345PyEval_MergeCompilerFlags(PyCompilerFlags *cf)
Jeremy Hylton061d1062001-03-22 02:32:48 +00003346{
Guido van Rossum6297a7a2003-02-19 15:53:17 +00003347 PyFrameObject *current_frame = PyEval_GetFrame();
Just van Rossum3aaf42c2003-02-10 08:21:10 +00003348 int result = cf->cf_flags != 0;
Tim Peters5ba58662001-07-16 02:29:45 +00003349
3350 if (current_frame != NULL) {
3351 const int codeflags = current_frame->f_code->co_flags;
Tim Peterse2c18e92001-08-17 20:47:47 +00003352 const int compilerflags = codeflags & PyCF_MASK;
3353 if (compilerflags) {
Tim Peters5ba58662001-07-16 02:29:45 +00003354 result = 1;
Tim Peterse2c18e92001-08-17 20:47:47 +00003355 cf->cf_flags |= compilerflags;
Tim Peters5ba58662001-07-16 02:29:45 +00003356 }
Neil Schemenauerc24ea082002-03-22 23:53:36 +00003357#if 0 /* future keyword */
Martin v. Löwis7198a522002-01-01 19:59:11 +00003358 if (codeflags & CO_GENERATOR_ALLOWED) {
3359 result = 1;
3360 cf->cf_flags |= CO_GENERATOR_ALLOWED;
3361 }
Neil Schemenauerc24ea082002-03-22 23:53:36 +00003362#endif
Tim Peters5ba58662001-07-16 02:29:45 +00003363 }
3364 return result;
Jeremy Hylton061d1062001-03-22 02:32:48 +00003365}
3366
Guido van Rossum3f5da241990-12-20 15:06:42 +00003367
Guido van Rossum681d79a1995-07-18 14:51:37 +00003368/* External interface to call any callable object.
3369 The arg must be a tuple or NULL. */
Guido van Rossum83bf35c1991-07-27 21:32:34 +00003370
Guido van Rossumd7ed6831997-08-30 15:02:50 +00003371#undef PyEval_CallObject
3372/* for backward compatibility: export this interface */
3373
Guido van Rossumb209a111997-04-29 18:18:01 +00003374PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003375PyEval_CallObject(PyObject *func, PyObject *arg)
Guido van Rossum83bf35c1991-07-27 21:32:34 +00003376{
Guido van Rossumb209a111997-04-29 18:18:01 +00003377 return PyEval_CallObjectWithKeywords(func, arg, (PyObject *)NULL);
Guido van Rossum681d79a1995-07-18 14:51:37 +00003378}
Guido van Rossumd7ed6831997-08-30 15:02:50 +00003379#define PyEval_CallObject(func,arg) \
3380 PyEval_CallObjectWithKeywords(func, arg, (PyObject *)NULL)
Guido van Rossume59214e1994-08-30 08:01:59 +00003381
Guido van Rossumb209a111997-04-29 18:18:01 +00003382PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003383PyEval_CallObjectWithKeywords(PyObject *func, PyObject *arg, PyObject *kw)
Guido van Rossum681d79a1995-07-18 14:51:37 +00003384{
Jeremy Hylton52820442001-01-03 23:52:36 +00003385 PyObject *result;
Guido van Rossum681d79a1995-07-18 14:51:37 +00003386
Hye-Shik Chang4af5c8c2006-03-07 15:39:21 +00003387 if (arg == NULL) {
Guido van Rossumb209a111997-04-29 18:18:01 +00003388 arg = PyTuple_New(0);
Hye-Shik Chang4af5c8c2006-03-07 15:39:21 +00003389 if (arg == NULL)
3390 return NULL;
3391 }
Guido van Rossumb209a111997-04-29 18:18:01 +00003392 else if (!PyTuple_Check(arg)) {
Guido van Rossuma027efa1997-05-05 20:56:21 +00003393 PyErr_SetString(PyExc_TypeError,
3394 "argument list must be a tuple");
Guido van Rossum681d79a1995-07-18 14:51:37 +00003395 return NULL;
3396 }
3397 else
Guido van Rossumb209a111997-04-29 18:18:01 +00003398 Py_INCREF(arg);
Guido van Rossum681d79a1995-07-18 14:51:37 +00003399
Guido van Rossumb209a111997-04-29 18:18:01 +00003400 if (kw != NULL && !PyDict_Check(kw)) {
Guido van Rossuma027efa1997-05-05 20:56:21 +00003401 PyErr_SetString(PyExc_TypeError,
3402 "keyword list must be a dictionary");
Guido van Rossum25826c92000-04-21 21:17:39 +00003403 Py_DECREF(arg);
Guido van Rossume3e61c11995-08-04 04:14:47 +00003404 return NULL;
3405 }
3406
Tim Peters6d6c1a32001-08-02 04:15:00 +00003407 result = PyObject_Call(func, arg, kw);
Guido van Rossumb209a111997-04-29 18:18:01 +00003408 Py_DECREF(arg);
Jeremy Hylton52820442001-01-03 23:52:36 +00003409 return result;
3410}
3411
Jeremy Hyltonaf68c872005-12-10 18:50:16 +00003412const char *
Tim Peters6d6c1a32001-08-02 04:15:00 +00003413PyEval_GetFuncName(PyObject *func)
Jeremy Hylton512a2372001-04-11 13:52:29 +00003414{
3415 if (PyMethod_Check(func))
Tim Peters6d6c1a32001-08-02 04:15:00 +00003416 return PyEval_GetFuncName(PyMethod_GET_FUNCTION(func));
Jeremy Hylton512a2372001-04-11 13:52:29 +00003417 else if (PyFunction_Check(func))
3418 return PyString_AsString(((PyFunctionObject*)func)->func_name);
3419 else if (PyCFunction_Check(func))
3420 return ((PyCFunctionObject*)func)->m_ml->ml_name;
Guido van Rossum50e9fb92006-08-17 05:42:55 +00003421 else
Jeremy Hylton512a2372001-04-11 13:52:29 +00003422 return func->ob_type->tp_name;
Jeremy Hylton512a2372001-04-11 13:52:29 +00003423}
3424
Jeremy Hyltonaf68c872005-12-10 18:50:16 +00003425const char *
Tim Peters6d6c1a32001-08-02 04:15:00 +00003426PyEval_GetFuncDesc(PyObject *func)
Jeremy Hylton512a2372001-04-11 13:52:29 +00003427{
3428 if (PyMethod_Check(func))
3429 return "()";
3430 else if (PyFunction_Check(func))
3431 return "()";
3432 else if (PyCFunction_Check(func))
3433 return "()";
Guido van Rossum50e9fb92006-08-17 05:42:55 +00003434 else
Jeremy Hylton512a2372001-04-11 13:52:29 +00003435 return " object";
Jeremy Hylton512a2372001-04-11 13:52:29 +00003436}
3437
Neal Norwitzaddfe0c2002-11-10 14:33:26 +00003438static void
Jeremy Hylton192690e2002-08-16 18:36:11 +00003439err_args(PyObject *func, int flags, int nargs)
3440{
3441 if (flags & METH_NOARGS)
Tim Peters8a5c3c72004-04-05 19:36:21 +00003442 PyErr_Format(PyExc_TypeError,
Guido van Rossum86c659a2002-08-23 14:11:35 +00003443 "%.200s() takes no arguments (%d given)",
Tim Peters8a5c3c72004-04-05 19:36:21 +00003444 ((PyCFunctionObject *)func)->m_ml->ml_name,
Jeremy Hylton192690e2002-08-16 18:36:11 +00003445 nargs);
3446 else
Tim Peters8a5c3c72004-04-05 19:36:21 +00003447 PyErr_Format(PyExc_TypeError,
Guido van Rossum86c659a2002-08-23 14:11:35 +00003448 "%.200s() takes exactly one argument (%d given)",
Tim Peters8a5c3c72004-04-05 19:36:21 +00003449 ((PyCFunctionObject *)func)->m_ml->ml_name,
Jeremy Hylton192690e2002-08-16 18:36:11 +00003450 nargs);
3451}
3452
Armin Rigo1c2d7e52005-09-20 18:34:01 +00003453#define C_TRACE(x, call) \
Nicholas Bastind858a772004-06-25 23:31:06 +00003454if (tstate->use_tracing && tstate->c_profilefunc) { \
3455 if (call_trace(tstate->c_profilefunc, \
3456 tstate->c_profileobj, \
3457 tstate->frame, PyTrace_C_CALL, \
Armin Rigo1c2d7e52005-09-20 18:34:01 +00003458 func)) { \
3459 x = NULL; \
3460 } \
3461 else { \
3462 x = call; \
3463 if (tstate->c_profilefunc != NULL) { \
3464 if (x == NULL) { \
3465 call_trace_protected(tstate->c_profilefunc, \
3466 tstate->c_profileobj, \
3467 tstate->frame, PyTrace_C_EXCEPTION, \
3468 func); \
3469 /* XXX should pass (type, value, tb) */ \
3470 } else { \
3471 if (call_trace(tstate->c_profilefunc, \
3472 tstate->c_profileobj, \
3473 tstate->frame, PyTrace_C_RETURN, \
3474 func)) { \
3475 Py_DECREF(x); \
3476 x = NULL; \
3477 } \
3478 } \
Nicholas Bastinc69ebe82004-03-24 21:57:10 +00003479 } \
Nicholas Bastind858a772004-06-25 23:31:06 +00003480 } \
3481} else { \
Armin Rigo1c2d7e52005-09-20 18:34:01 +00003482 x = call; \
Nicholas Bastinc69ebe82004-03-24 21:57:10 +00003483 }
3484
Jeremy Hyltone8c04322002-08-16 17:47:26 +00003485static PyObject *
Martin v. Löwisf30d60e2004-06-08 08:17:44 +00003486call_function(PyObject ***pp_stack, int oparg
3487#ifdef WITH_TSC
3488 , uint64* pintr0, uint64* pintr1
3489#endif
3490 )
Jeremy Hyltone8c04322002-08-16 17:47:26 +00003491{
3492 int na = oparg & 0xff;
3493 int nk = (oparg>>8) & 0xff;
3494 int n = na + 2 * nk;
3495 PyObject **pfunc = (*pp_stack) - n - 1;
3496 PyObject *func = *pfunc;
3497 PyObject *x, *w;
3498
Jeremy Hylton985eba52003-02-05 23:13:00 +00003499 /* Always dispatch PyCFunction first, because these are
3500 presumed to be the most frequent callable object.
Jeremy Hyltone8c04322002-08-16 17:47:26 +00003501 */
3502 if (PyCFunction_Check(func) && nk == 0) {
3503 int flags = PyCFunction_GET_FLAGS(func);
Nicholas Bastind858a772004-06-25 23:31:06 +00003504 PyThreadState *tstate = PyThreadState_GET();
Raymond Hettingera7f56bc2004-06-26 04:34:33 +00003505
3506 PCALL(PCALL_CFUNCTION);
Jeremy Hylton192690e2002-08-16 18:36:11 +00003507 if (flags & (METH_NOARGS | METH_O)) {
3508 PyCFunction meth = PyCFunction_GET_FUNCTION(func);
3509 PyObject *self = PyCFunction_GET_SELF(func);
Nicholas Bastinc69ebe82004-03-24 21:57:10 +00003510 if (flags & METH_NOARGS && na == 0) {
Armin Rigo1c2d7e52005-09-20 18:34:01 +00003511 C_TRACE(x, (*meth)(self,NULL));
Nicholas Bastinc69ebe82004-03-24 21:57:10 +00003512 }
Jeremy Hylton192690e2002-08-16 18:36:11 +00003513 else if (flags & METH_O && na == 1) {
3514 PyObject *arg = EXT_POP(*pp_stack);
Armin Rigo1c2d7e52005-09-20 18:34:01 +00003515 C_TRACE(x, (*meth)(self,arg));
Jeremy Hylton192690e2002-08-16 18:36:11 +00003516 Py_DECREF(arg);
3517 }
3518 else {
3519 err_args(func, flags, na);
3520 x = NULL;
3521 }
3522 }
3523 else {
Jeremy Hyltone8c04322002-08-16 17:47:26 +00003524 PyObject *callargs;
3525 callargs = load_args(pp_stack, na);
Michael W. Hudson75eabd22005-01-18 15:56:11 +00003526 READ_TIMESTAMP(*pintr0);
Armin Rigo1c2d7e52005-09-20 18:34:01 +00003527 C_TRACE(x, PyCFunction_Call(func,callargs,NULL));
Michael W. Hudson75eabd22005-01-18 15:56:11 +00003528 READ_TIMESTAMP(*pintr1);
Tim Peters8a5c3c72004-04-05 19:36:21 +00003529 Py_XDECREF(callargs);
3530 }
Jeremy Hyltone8c04322002-08-16 17:47:26 +00003531 } else {
3532 if (PyMethod_Check(func) && PyMethod_GET_SELF(func) != NULL) {
3533 /* optimize access to bound methods */
3534 PyObject *self = PyMethod_GET_SELF(func);
Jeremy Hylton985eba52003-02-05 23:13:00 +00003535 PCALL(PCALL_METHOD);
3536 PCALL(PCALL_BOUND_METHOD);
Jeremy Hyltone8c04322002-08-16 17:47:26 +00003537 Py_INCREF(self);
3538 func = PyMethod_GET_FUNCTION(func);
3539 Py_INCREF(func);
3540 Py_DECREF(*pfunc);
3541 *pfunc = self;
3542 na++;
3543 n++;
3544 } else
3545 Py_INCREF(func);
Michael W. Hudson75eabd22005-01-18 15:56:11 +00003546 READ_TIMESTAMP(*pintr0);
Jeremy Hyltone8c04322002-08-16 17:47:26 +00003547 if (PyFunction_Check(func))
3548 x = fast_function(func, pp_stack, n, na, nk);
Tim Peters8a5c3c72004-04-05 19:36:21 +00003549 else
Jeremy Hyltone8c04322002-08-16 17:47:26 +00003550 x = do_call(func, pp_stack, na, nk);
Michael W. Hudson75eabd22005-01-18 15:56:11 +00003551 READ_TIMESTAMP(*pintr1);
Jeremy Hyltone8c04322002-08-16 17:47:26 +00003552 Py_DECREF(func);
3553 }
Tim Peters8a5c3c72004-04-05 19:36:21 +00003554
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00003555 /* Clear the stack of the function object. Also removes
3556 the arguments in case they weren't consumed already
3557 (fast_function() and err_args() leave them on the stack).
Thomas Wouters7f597322006-03-01 05:32:33 +00003558 */
Jeremy Hyltone8c04322002-08-16 17:47:26 +00003559 while ((*pp_stack) > pfunc) {
3560 w = EXT_POP(*pp_stack);
3561 Py_DECREF(w);
Jeremy Hylton985eba52003-02-05 23:13:00 +00003562 PCALL(PCALL_POP);
Jeremy Hyltone8c04322002-08-16 17:47:26 +00003563 }
3564 return x;
3565}
3566
Jeremy Hylton192690e2002-08-16 18:36:11 +00003567/* The fast_function() function optimize calls for which no argument
Jeremy Hylton52820442001-01-03 23:52:36 +00003568 tuple is necessary; the objects are passed directly from the stack.
Jeremy Hylton985eba52003-02-05 23:13:00 +00003569 For the simplest case -- a function that takes only positional
3570 arguments and is called with only positional arguments -- it
3571 inlines the most primitive frame setup code from
3572 PyEval_EvalCodeEx(), which vastly reduces the checks that must be
3573 done before evaluating the frame.
Jeremy Hylton52820442001-01-03 23:52:36 +00003574*/
3575
3576static PyObject *
Guido van Rossumac7be682001-01-17 15:42:30 +00003577fast_function(PyObject *func, PyObject ***pp_stack, int n, int na, int nk)
Jeremy Hylton52820442001-01-03 23:52:36 +00003578{
Jeremy Hylton985eba52003-02-05 23:13:00 +00003579 PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
Jeremy Hylton52820442001-01-03 23:52:36 +00003580 PyObject *globals = PyFunction_GET_GLOBALS(func);
3581 PyObject *argdefs = PyFunction_GET_DEFAULTS(func);
Guido van Rossum4f72a782006-10-27 23:31:49 +00003582 PyObject *kwdefs = PyFunction_GET_KW_DEFAULTS(func);
Jeremy Hylton52820442001-01-03 23:52:36 +00003583 PyObject **d = NULL;
3584 int nd = 0;
3585
Jeremy Hylton985eba52003-02-05 23:13:00 +00003586 PCALL(PCALL_FUNCTION);
3587 PCALL(PCALL_FAST_FUNCTION);
Guido van Rossum4f72a782006-10-27 23:31:49 +00003588 if (argdefs == NULL && co->co_argcount == n &&
3589 co->co_kwonlyargcount == 0 && nk==0 &&
Jeremy Hylton985eba52003-02-05 23:13:00 +00003590 co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) {
3591 PyFrameObject *f;
3592 PyObject *retval = NULL;
3593 PyThreadState *tstate = PyThreadState_GET();
3594 PyObject **fastlocals, **stack;
3595 int i;
3596
3597 PCALL(PCALL_FASTER_FUNCTION);
3598 assert(globals != NULL);
3599 /* XXX Perhaps we should create a specialized
3600 PyFrame_New() that doesn't take locals, but does
3601 take builtins without sanity checking them.
3602 */
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00003603 assert(tstate != NULL);
Jeremy Hylton985eba52003-02-05 23:13:00 +00003604 f = PyFrame_New(tstate, co, globals, NULL);
3605 if (f == NULL)
3606 return NULL;
3607
3608 fastlocals = f->f_localsplus;
3609 stack = (*pp_stack) - n;
3610
3611 for (i = 0; i < n; i++) {
3612 Py_INCREF(*stack);
3613 fastlocals[i] = *stack++;
3614 }
Phillip J. Eby0d6615f2005-08-02 00:46:46 +00003615 retval = PyEval_EvalFrameEx(f,0);
Jeremy Hylton985eba52003-02-05 23:13:00 +00003616 ++tstate->recursion_depth;
3617 Py_DECREF(f);
3618 --tstate->recursion_depth;
3619 return retval;
3620 }
Jeremy Hylton52820442001-01-03 23:52:36 +00003621 if (argdefs != NULL) {
3622 d = &PyTuple_GET_ITEM(argdefs, 0);
3623 nd = ((PyTupleObject *)argdefs)->ob_size;
3624 }
Jeremy Hylton985eba52003-02-05 23:13:00 +00003625 return PyEval_EvalCodeEx(co, globals,
3626 (PyObject *)NULL, (*pp_stack)-n, na,
Guido van Rossum4f72a782006-10-27 23:31:49 +00003627 (*pp_stack)-2*nk, nk, d, nd, kwdefs,
Jeremy Hylton985eba52003-02-05 23:13:00 +00003628 PyFunction_GET_CLOSURE(func));
Jeremy Hylton52820442001-01-03 23:52:36 +00003629}
3630
3631static PyObject *
Ka-Ping Yee20579702001-01-15 22:14:16 +00003632update_keyword_args(PyObject *orig_kwdict, int nk, PyObject ***pp_stack,
3633 PyObject *func)
Jeremy Hylton52820442001-01-03 23:52:36 +00003634{
3635 PyObject *kwdict = NULL;
3636 if (orig_kwdict == NULL)
3637 kwdict = PyDict_New();
3638 else {
3639 kwdict = PyDict_Copy(orig_kwdict);
3640 Py_DECREF(orig_kwdict);
3641 }
3642 if (kwdict == NULL)
3643 return NULL;
Raymond Hettinger5bed4562004-04-10 23:34:17 +00003644 while (--nk >= 0) {
Jeremy Hylton52820442001-01-03 23:52:36 +00003645 int err;
3646 PyObject *value = EXT_POP(*pp_stack);
3647 PyObject *key = EXT_POP(*pp_stack);
3648 if (PyDict_GetItem(kwdict, key) != NULL) {
Guido van Rossumac7be682001-01-17 15:42:30 +00003649 PyErr_Format(PyExc_TypeError,
Ka-Ping Yee20579702001-01-15 22:14:16 +00003650 "%.200s%s got multiple values "
Jeremy Hylton512a2372001-04-11 13:52:29 +00003651 "for keyword argument '%.200s'",
Tim Peters6d6c1a32001-08-02 04:15:00 +00003652 PyEval_GetFuncName(func),
3653 PyEval_GetFuncDesc(func),
Jeremy Hylton512a2372001-04-11 13:52:29 +00003654 PyString_AsString(key));
Jeremy Hylton52820442001-01-03 23:52:36 +00003655 Py_DECREF(key);
3656 Py_DECREF(value);
3657 Py_DECREF(kwdict);
3658 return NULL;
3659 }
3660 err = PyDict_SetItem(kwdict, key, value);
3661 Py_DECREF(key);
3662 Py_DECREF(value);
3663 if (err) {
3664 Py_DECREF(kwdict);
3665 return NULL;
3666 }
3667 }
3668 return kwdict;
3669}
3670
3671static PyObject *
3672update_star_args(int nstack, int nstar, PyObject *stararg,
3673 PyObject ***pp_stack)
3674{
3675 PyObject *callargs, *w;
3676
3677 callargs = PyTuple_New(nstack + nstar);
3678 if (callargs == NULL) {
3679 return NULL;
3680 }
3681 if (nstar) {
3682 int i;
3683 for (i = 0; i < nstar; i++) {
3684 PyObject *a = PyTuple_GET_ITEM(stararg, i);
3685 Py_INCREF(a);
3686 PyTuple_SET_ITEM(callargs, nstack + i, a);
3687 }
3688 }
Raymond Hettinger5bed4562004-04-10 23:34:17 +00003689 while (--nstack >= 0) {
Jeremy Hylton52820442001-01-03 23:52:36 +00003690 w = EXT_POP(*pp_stack);
3691 PyTuple_SET_ITEM(callargs, nstack, w);
3692 }
3693 return callargs;
3694}
3695
3696static PyObject *
3697load_args(PyObject ***pp_stack, int na)
3698{
3699 PyObject *args = PyTuple_New(na);
3700 PyObject *w;
3701
3702 if (args == NULL)
3703 return NULL;
Raymond Hettinger5bed4562004-04-10 23:34:17 +00003704 while (--na >= 0) {
Jeremy Hylton52820442001-01-03 23:52:36 +00003705 w = EXT_POP(*pp_stack);
3706 PyTuple_SET_ITEM(args, na, w);
3707 }
3708 return args;
3709}
3710
3711static PyObject *
3712do_call(PyObject *func, PyObject ***pp_stack, int na, int nk)
3713{
3714 PyObject *callargs = NULL;
3715 PyObject *kwdict = NULL;
3716 PyObject *result = NULL;
3717
3718 if (nk > 0) {
Ka-Ping Yee20579702001-01-15 22:14:16 +00003719 kwdict = update_keyword_args(NULL, nk, pp_stack, func);
Jeremy Hylton52820442001-01-03 23:52:36 +00003720 if (kwdict == NULL)
3721 goto call_fail;
3722 }
3723 callargs = load_args(pp_stack, na);
3724 if (callargs == NULL)
3725 goto call_fail;
Jeremy Hylton985eba52003-02-05 23:13:00 +00003726#ifdef CALL_PROFILE
3727 /* At this point, we have to look at the type of func to
3728 update the call stats properly. Do it here so as to avoid
3729 exposing the call stats machinery outside ceval.c
3730 */
3731 if (PyFunction_Check(func))
3732 PCALL(PCALL_FUNCTION);
3733 else if (PyMethod_Check(func))
3734 PCALL(PCALL_METHOD);
3735 else if (PyType_Check(func))
3736 PCALL(PCALL_TYPE);
3737 else
3738 PCALL(PCALL_OTHER);
3739#endif
Tim Peters6d6c1a32001-08-02 04:15:00 +00003740 result = PyObject_Call(func, callargs, kwdict);
Jeremy Hylton52820442001-01-03 23:52:36 +00003741 call_fail:
3742 Py_XDECREF(callargs);
3743 Py_XDECREF(kwdict);
3744 return result;
3745}
3746
3747static PyObject *
3748ext_do_call(PyObject *func, PyObject ***pp_stack, int flags, int na, int nk)
3749{
3750 int nstar = 0;
3751 PyObject *callargs = NULL;
3752 PyObject *stararg = NULL;
3753 PyObject *kwdict = NULL;
3754 PyObject *result = NULL;
3755
3756 if (flags & CALL_FLAG_KW) {
3757 kwdict = EXT_POP(*pp_stack);
3758 if (!(kwdict && PyDict_Check(kwdict))) {
Ka-Ping Yee20579702001-01-15 22:14:16 +00003759 PyErr_Format(PyExc_TypeError,
Jeremy Hylton512a2372001-04-11 13:52:29 +00003760 "%s%s argument after ** "
3761 "must be a dictionary",
Tim Peters6d6c1a32001-08-02 04:15:00 +00003762 PyEval_GetFuncName(func),
3763 PyEval_GetFuncDesc(func));
Jeremy Hylton52820442001-01-03 23:52:36 +00003764 goto ext_call_fail;
3765 }
3766 }
3767 if (flags & CALL_FLAG_VAR) {
3768 stararg = EXT_POP(*pp_stack);
3769 if (!PyTuple_Check(stararg)) {
3770 PyObject *t = NULL;
3771 t = PySequence_Tuple(stararg);
3772 if (t == NULL) {
Jeremy Hylton512a2372001-04-11 13:52:29 +00003773 if (PyErr_ExceptionMatches(PyExc_TypeError)) {
3774 PyErr_Format(PyExc_TypeError,
3775 "%s%s argument after * "
3776 "must be a sequence",
Tim Peters6d6c1a32001-08-02 04:15:00 +00003777 PyEval_GetFuncName(func),
3778 PyEval_GetFuncDesc(func));
Jeremy Hylton512a2372001-04-11 13:52:29 +00003779 }
Jeremy Hylton52820442001-01-03 23:52:36 +00003780 goto ext_call_fail;
3781 }
3782 Py_DECREF(stararg);
3783 stararg = t;
3784 }
3785 nstar = PyTuple_GET_SIZE(stararg);
3786 }
3787 if (nk > 0) {
Ka-Ping Yee20579702001-01-15 22:14:16 +00003788 kwdict = update_keyword_args(kwdict, nk, pp_stack, func);
Jeremy Hylton52820442001-01-03 23:52:36 +00003789 if (kwdict == NULL)
3790 goto ext_call_fail;
3791 }
3792 callargs = update_star_args(na, nstar, stararg, pp_stack);
3793 if (callargs == NULL)
3794 goto ext_call_fail;
Jeremy Hylton985eba52003-02-05 23:13:00 +00003795#ifdef CALL_PROFILE
3796 /* At this point, we have to look at the type of func to
3797 update the call stats properly. Do it here so as to avoid
3798 exposing the call stats machinery outside ceval.c
3799 */
3800 if (PyFunction_Check(func))
3801 PCALL(PCALL_FUNCTION);
3802 else if (PyMethod_Check(func))
3803 PCALL(PCALL_METHOD);
3804 else if (PyType_Check(func))
3805 PCALL(PCALL_TYPE);
3806 else
3807 PCALL(PCALL_OTHER);
3808#endif
Tim Peters6d6c1a32001-08-02 04:15:00 +00003809 result = PyObject_Call(func, callargs, kwdict);
Jeremy Hylton52820442001-01-03 23:52:36 +00003810 ext_call_fail:
3811 Py_XDECREF(callargs);
3812 Py_XDECREF(kwdict);
3813 Py_XDECREF(stararg);
3814 return result;
3815}
3816
Guido van Rossum38fff8c2006-03-07 18:50:55 +00003817/* Extract a slice index from a PyInt or PyLong or an object with the
3818 nb_index slot defined, and store in *pi.
3819 Silently reduce values larger than PY_SSIZE_T_MAX to PY_SSIZE_T_MAX,
3820 and silently boost values less than -PY_SSIZE_T_MAX-1 to -PY_SSIZE_T_MAX-1.
Martin v. Löwisdde99d22006-02-17 15:57:41 +00003821 Return 0 on error, 1 on success.
Tim Peterscb479e72001-12-16 19:11:44 +00003822*/
Tim Petersb5196382001-12-16 19:44:20 +00003823/* Note: If v is NULL, return success without storing into *pi. This
3824 is because_PyEval_SliceIndex() is called by apply_slice(), which can be
3825 called by the SLICE opcode with v and/or w equal to NULL.
Tim Peterscb479e72001-12-16 19:11:44 +00003826*/
Guido van Rossum20c6add2000-05-08 14:06:50 +00003827int
Martin v. Löwis18e16552006-02-15 17:27:45 +00003828_PyEval_SliceIndex(PyObject *v, Py_ssize_t *pi)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003829{
Tim Petersb5196382001-12-16 19:44:20 +00003830 if (v != NULL) {
Martin v. Löwisdde99d22006-02-17 15:57:41 +00003831 Py_ssize_t x;
Guido van Rossumddefaf32007-01-14 03:31:43 +00003832 if (PyInt_CheckExact(v)) {
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00003833 /* XXX(nnorwitz): I think PyInt_AS_LONG is correct,
3834 however, it looks like it should be AsSsize_t.
3835 There should be a comment here explaining why.
3836 */
3837 x = PyInt_AS_LONG(v);
Thomas Wouters477c8d52006-05-27 19:21:47 +00003838 }
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00003839 else if (PyIndex_Check(v)) {
3840 x = PyNumber_AsSsize_t(v, NULL);
Guido van Rossum38fff8c2006-03-07 18:50:55 +00003841 if (x == -1 && PyErr_Occurred())
3842 return 0;
3843 }
3844 else {
Guido van Rossuma027efa1997-05-05 20:56:21 +00003845 PyErr_SetString(PyExc_TypeError,
Guido van Rossum38fff8c2006-03-07 18:50:55 +00003846 "slice indices must be integers or "
3847 "None or have an __index__ method");
Guido van Rossum20c6add2000-05-08 14:06:50 +00003848 return 0;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003849 }
Guido van Rossuma027efa1997-05-05 20:56:21 +00003850 *pi = x;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003851 }
Guido van Rossum20c6add2000-05-08 14:06:50 +00003852 return 1;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003853}
3854
Guido van Rossum38fff8c2006-03-07 18:50:55 +00003855#undef ISINDEX
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00003856#define ISINDEX(x) ((x) == NULL || \
3857 PyInt_Check(x) || PyLong_Check(x) || PyIndex_Check(x))
Guido van Rossum50d756e2001-08-18 17:43:36 +00003858
Guido van Rossumb209a111997-04-29 18:18:01 +00003859static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003860apply_slice(PyObject *u, PyObject *v, PyObject *w) /* return u[v:w] */
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003861{
Guido van Rossum50d756e2001-08-18 17:43:36 +00003862 PyTypeObject *tp = u->ob_type;
3863 PySequenceMethods *sq = tp->tp_as_sequence;
3864
Guido van Rossum38fff8c2006-03-07 18:50:55 +00003865 if (sq && sq->sq_slice && ISINDEX(v) && ISINDEX(w)) {
Martin v. Löwisdde99d22006-02-17 15:57:41 +00003866 Py_ssize_t ilow = 0, ihigh = PY_SSIZE_T_MAX;
Guido van Rossum50d756e2001-08-18 17:43:36 +00003867 if (!_PyEval_SliceIndex(v, &ilow))
3868 return NULL;
3869 if (!_PyEval_SliceIndex(w, &ihigh))
3870 return NULL;
3871 return PySequence_GetSlice(u, ilow, ihigh);
3872 }
3873 else {
3874 PyObject *slice = PySlice_New(v, w, NULL);
Guido van Rossum354797c2001-12-03 19:45:06 +00003875 if (slice != NULL) {
3876 PyObject *res = PyObject_GetItem(u, slice);
3877 Py_DECREF(slice);
3878 return res;
3879 }
Guido van Rossum50d756e2001-08-18 17:43:36 +00003880 else
3881 return NULL;
3882 }
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003883}
Guido van Rossum3f5da241990-12-20 15:06:42 +00003884
3885static int
Guido van Rossumac7be682001-01-17 15:42:30 +00003886assign_slice(PyObject *u, PyObject *v, PyObject *w, PyObject *x)
3887 /* u[v:w] = x */
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003888{
Guido van Rossum50d756e2001-08-18 17:43:36 +00003889 PyTypeObject *tp = u->ob_type;
3890 PySequenceMethods *sq = tp->tp_as_sequence;
3891
Guido van Rossum38fff8c2006-03-07 18:50:55 +00003892 if (sq && sq->sq_slice && ISINDEX(v) && ISINDEX(w)) {
Martin v. Löwisdde99d22006-02-17 15:57:41 +00003893 Py_ssize_t ilow = 0, ihigh = PY_SSIZE_T_MAX;
Guido van Rossum50d756e2001-08-18 17:43:36 +00003894 if (!_PyEval_SliceIndex(v, &ilow))
3895 return -1;
3896 if (!_PyEval_SliceIndex(w, &ihigh))
3897 return -1;
3898 if (x == NULL)
3899 return PySequence_DelSlice(u, ilow, ihigh);
3900 else
3901 return PySequence_SetSlice(u, ilow, ihigh, x);
3902 }
3903 else {
3904 PyObject *slice = PySlice_New(v, w, NULL);
3905 if (slice != NULL) {
Guido van Rossum354797c2001-12-03 19:45:06 +00003906 int res;
Guido van Rossum50d756e2001-08-18 17:43:36 +00003907 if (x != NULL)
Guido van Rossum354797c2001-12-03 19:45:06 +00003908 res = PyObject_SetItem(u, slice, x);
Guido van Rossum50d756e2001-08-18 17:43:36 +00003909 else
Guido van Rossum354797c2001-12-03 19:45:06 +00003910 res = PyObject_DelItem(u, slice);
3911 Py_DECREF(slice);
3912 return res;
Guido van Rossum50d756e2001-08-18 17:43:36 +00003913 }
3914 else
3915 return -1;
3916 }
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003917}
3918
Brett Cannonf74225d2007-02-26 21:10:16 +00003919/*
3920 Return a true value if the exception is allowed to be in an 'except' clause,
3921 otherwise return a false value.
3922*/
3923static int
3924can_catch_exc(PyObject *exc)
3925{
3926 if (!(PyExceptionClass_Check(exc) || PyExceptionInstance_Check(exc))) {
3927 PyErr_SetString(PyExc_TypeError,
3928 "catching an object must be a class or "
3929 "instance of BaseException");
3930 return 0;
3931 }
3932 else {
3933 return 1;
3934 }
3935}
3936
Guido van Rossumb209a111997-04-29 18:18:01 +00003937static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003938cmp_outcome(int op, register PyObject *v, register PyObject *w)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003939{
Guido van Rossumac7be682001-01-17 15:42:30 +00003940 int res = 0;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003941 switch (op) {
Martin v. Löwis7198a522002-01-01 19:59:11 +00003942 case PyCmp_IS:
Guido van Rossum3f5da241990-12-20 15:06:42 +00003943 res = (v == w);
Raymond Hettinger4bad9ba2003-01-19 05:08:13 +00003944 break;
3945 case PyCmp_IS_NOT:
3946 res = (v != w);
Guido van Rossum3f5da241990-12-20 15:06:42 +00003947 break;
Martin v. Löwis7198a522002-01-01 19:59:11 +00003948 case PyCmp_IN:
Raymond Hettinger4bad9ba2003-01-19 05:08:13 +00003949 res = PySequence_Contains(w, v);
3950 if (res < 0)
3951 return NULL;
3952 break;
Martin v. Löwis7198a522002-01-01 19:59:11 +00003953 case PyCmp_NOT_IN:
Guido van Rossum7e33c6e1998-05-22 00:52:29 +00003954 res = PySequence_Contains(w, v);
Guido van Rossum3f5da241990-12-20 15:06:42 +00003955 if (res < 0)
3956 return NULL;
Raymond Hettinger4bad9ba2003-01-19 05:08:13 +00003957 res = !res;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003958 break;
Martin v. Löwis7198a522002-01-01 19:59:11 +00003959 case PyCmp_EXC_MATCH:
Thomas Wouters9fe394c2007-02-05 01:24:16 +00003960 if (PyTuple_Check(w)) {
3961 Py_ssize_t i, length;
3962 length = PyTuple_Size(w);
3963 for (i = 0; i < length; i += 1) {
3964 PyObject *exc = PyTuple_GET_ITEM(w, i);
Brett Cannonf74225d2007-02-26 21:10:16 +00003965 if (!can_catch_exc(exc)) {
3966 return NULL;
Thomas Wouters9fe394c2007-02-05 01:24:16 +00003967 }
3968 }
3969 }
3970 else {
Brett Cannonf74225d2007-02-26 21:10:16 +00003971 if (!can_catch_exc(w)) {
3972 return NULL;
Thomas Wouters9fe394c2007-02-05 01:24:16 +00003973 }
3974 }
Barry Warsaw4249f541997-08-22 21:26:19 +00003975 res = PyErr_GivenExceptionMatches(v, w);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003976 break;
3977 default:
Guido van Rossumac7be682001-01-17 15:42:30 +00003978 return PyObject_RichCompare(v, w, op);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003979 }
Guido van Rossumb209a111997-04-29 18:18:01 +00003980 v = res ? Py_True : Py_False;
3981 Py_INCREF(v);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003982 return v;
3983}
3984
Thomas Wouters52152252000-08-17 22:55:00 +00003985static PyObject *
3986import_from(PyObject *v, PyObject *name)
Guido van Rossume9736fc1990-11-18 17:33:06 +00003987{
Guido van Rossum18d4d8f2001-01-12 16:24:03 +00003988 PyObject *x;
3989
3990 x = PyObject_GetAttr(v, name);
3991 if (x == NULL && PyErr_ExceptionMatches(PyExc_AttributeError)) {
Thomas Wouters52152252000-08-17 22:55:00 +00003992 PyErr_Format(PyExc_ImportError,
3993 "cannot import name %.230s",
3994 PyString_AsString(name));
Guido van Rossum18d4d8f2001-01-12 16:24:03 +00003995 }
Thomas Wouters52152252000-08-17 22:55:00 +00003996 return x;
3997}
Guido van Rossumac7be682001-01-17 15:42:30 +00003998
Thomas Wouters52152252000-08-17 22:55:00 +00003999static int
4000import_all_from(PyObject *locals, PyObject *v)
4001{
Guido van Rossum18d4d8f2001-01-12 16:24:03 +00004002 PyObject *all = PyObject_GetAttrString(v, "__all__");
4003 PyObject *dict, *name, *value;
4004 int skip_leading_underscores = 0;
4005 int pos, err;
Thomas Wouters52152252000-08-17 22:55:00 +00004006
Guido van Rossum18d4d8f2001-01-12 16:24:03 +00004007 if (all == NULL) {
4008 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
4009 return -1; /* Unexpected error */
4010 PyErr_Clear();
4011 dict = PyObject_GetAttrString(v, "__dict__");
4012 if (dict == NULL) {
4013 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
4014 return -1;
4015 PyErr_SetString(PyExc_ImportError,
4016 "from-import-* object has no __dict__ and no __all__");
Guido van Rossum3f5da241990-12-20 15:06:42 +00004017 return -1;
Guido van Rossum18d4d8f2001-01-12 16:24:03 +00004018 }
4019 all = PyMapping_Keys(dict);
4020 Py_DECREF(dict);
4021 if (all == NULL)
4022 return -1;
4023 skip_leading_underscores = 1;
Guido van Rossume9736fc1990-11-18 17:33:06 +00004024 }
Guido van Rossum18d4d8f2001-01-12 16:24:03 +00004025
4026 for (pos = 0, err = 0; ; pos++) {
4027 name = PySequence_GetItem(all, pos);
4028 if (name == NULL) {
4029 if (!PyErr_ExceptionMatches(PyExc_IndexError))
4030 err = -1;
4031 else
4032 PyErr_Clear();
4033 break;
4034 }
4035 if (skip_leading_underscores &&
4036 PyString_Check(name) &&
4037 PyString_AS_STRING(name)[0] == '_')
4038 {
4039 Py_DECREF(name);
4040 continue;
4041 }
4042 value = PyObject_GetAttr(v, name);
4043 if (value == NULL)
4044 err = -1;
Thomas Wouters89f507f2006-12-13 04:49:30 +00004045 else if (PyDict_CheckExact(locals))
Guido van Rossum18d4d8f2001-01-12 16:24:03 +00004046 err = PyDict_SetItem(locals, name, value);
Thomas Wouters89f507f2006-12-13 04:49:30 +00004047 else
4048 err = PyObject_SetItem(locals, name, value);
Guido van Rossum18d4d8f2001-01-12 16:24:03 +00004049 Py_DECREF(name);
4050 Py_XDECREF(value);
4051 if (err != 0)
4052 break;
4053 }
4054 Py_DECREF(all);
4055 return err;
Guido van Rossume9736fc1990-11-18 17:33:06 +00004056}
4057
Guido van Rossumb209a111997-04-29 18:18:01 +00004058static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00004059build_class(PyObject *methods, PyObject *bases, PyObject *name)
Guido van Rossume9736fc1990-11-18 17:33:06 +00004060{
Guido van Rossum7851eea2001-09-12 19:19:18 +00004061 PyObject *metaclass = NULL, *result, *base;
Tim Peters6d6c1a32001-08-02 04:15:00 +00004062
4063 if (PyDict_Check(methods))
4064 metaclass = PyDict_GetItemString(methods, "__metaclass__");
Guido van Rossum7851eea2001-09-12 19:19:18 +00004065 if (metaclass != NULL)
Guido van Rossum2556f2e2001-12-06 14:09:56 +00004066 Py_INCREF(metaclass);
Guido van Rossum7851eea2001-09-12 19:19:18 +00004067 else if (PyTuple_Check(bases) && PyTuple_GET_SIZE(bases) > 0) {
4068 base = PyTuple_GET_ITEM(bases, 0);
4069 metaclass = PyObject_GetAttrString(base, "__class__");
4070 if (metaclass == NULL) {
4071 PyErr_Clear();
4072 metaclass = (PyObject *)base->ob_type;
4073 Py_INCREF(metaclass);
Guido van Rossum25831651993-05-19 14:50:45 +00004074 }
4075 }
Guido van Rossum7851eea2001-09-12 19:19:18 +00004076 else {
4077 PyObject *g = PyEval_GetGlobals();
4078 if (g != NULL && PyDict_Check(g))
4079 metaclass = PyDict_GetItemString(g, "__metaclass__");
4080 if (metaclass == NULL)
Guido van Rossum45aecf42006-03-15 04:58:47 +00004081 metaclass = (PyObject *) &PyType_Type;
Guido van Rossum7851eea2001-09-12 19:19:18 +00004082 Py_INCREF(metaclass);
4083 }
Thomas Woutersa44f3a32007-02-26 18:20:15 +00004084 result = PyObject_CallFunctionObjArgs(metaclass, name, bases, methods,
4085 NULL);
Guido van Rossum7851eea2001-09-12 19:19:18 +00004086 Py_DECREF(metaclass);
Raymond Hettingerf2c08302004-06-05 06:16:22 +00004087 if (result == NULL && PyErr_ExceptionMatches(PyExc_TypeError)) {
Thomas Wouters477c8d52006-05-27 19:21:47 +00004088 /* A type error here likely means that the user passed
Raymond Hettingerf2c08302004-06-05 06:16:22 +00004089 in a base that was not a class (such the random module
4090 instead of the random.random type). Help them out with
Raymond Hettingercfc31922004-09-16 16:41:57 +00004091 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(
Thomas Woutersa44f3a32007-02-26 18:20:15 +00004099 "Error when calling the metaclass bases\n"
4100 " %s",
Raymond Hettingercfc31922004-09-16 16:41:57 +00004101 PyString_AS_STRING(pvalue));
4102 if (newmsg != NULL) {
4103 Py_DECREF(pvalue);
4104 pvalue = newmsg;
4105 }
4106 }
4107 PyErr_Restore(ptype, pvalue, ptraceback);
Raymond Hettingerf2c08302004-06-05 06:16:22 +00004108 }
Guido van Rossum7851eea2001-09-12 19:19:18 +00004109 return result;
Guido van Rossum25831651993-05-19 14:50:45 +00004110}
4111
Guido van Rossumac7be682001-01-17 15:42:30 +00004112static void
Paul Prescode68140d2000-08-30 20:25:01 +00004113format_exc_check_arg(PyObject *exc, char *format_str, PyObject *obj)
4114{
4115 char *obj_str;
4116
4117 if (!obj)
4118 return;
4119
4120 obj_str = PyString_AsString(obj);
4121 if (!obj_str)
4122 return;
4123
4124 PyErr_Format(exc, format_str, obj_str);
4125}
Guido van Rossum950361c1997-01-24 13:49:28 +00004126
Raymond Hettinger52a21b82004-08-06 18:43:09 +00004127static PyObject *
4128string_concatenate(PyObject *v, PyObject *w,
4129 PyFrameObject *f, unsigned char *next_instr)
4130{
4131 /* This function implements 'variable += expr' when both arguments
4132 are strings. */
Thomas Wouters0e3f5912006-08-11 14:57:12 +00004133 Py_ssize_t v_len = PyString_GET_SIZE(v);
4134 Py_ssize_t w_len = PyString_GET_SIZE(w);
4135 Py_ssize_t new_len = v_len + w_len;
4136 if (new_len < 0) {
4137 PyErr_SetString(PyExc_OverflowError,
4138 "strings are too large to concat");
4139 return NULL;
4140 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00004141
Raymond Hettinger52a21b82004-08-06 18:43:09 +00004142 if (v->ob_refcnt == 2) {
4143 /* In the common case, there are 2 references to the value
4144 * stored in 'variable' when the += is performed: one on the
4145 * value stack (in 'v') and one still stored in the 'variable'.
4146 * We try to delete the variable now to reduce the refcnt to 1.
4147 */
4148 switch (*next_instr) {
4149 case STORE_FAST:
4150 {
4151 int oparg = PEEKARG();
4152 PyObject **fastlocals = f->f_localsplus;
4153 if (GETLOCAL(oparg) == v)
4154 SETLOCAL(oparg, NULL);
4155 break;
4156 }
4157 case STORE_DEREF:
4158 {
Thomas Wouters477c8d52006-05-27 19:21:47 +00004159 PyObject **freevars = f->f_localsplus + f->f_code->co_nlocals;
Raymond Hettinger52a21b82004-08-06 18:43:09 +00004160 PyObject *c = freevars[PEEKARG()];
4161 if (PyCell_GET(c) == v)
4162 PyCell_Set(c, NULL);
4163 break;
4164 }
4165 case STORE_NAME:
4166 {
4167 PyObject *names = f->f_code->co_names;
4168 PyObject *name = GETITEM(names, PEEKARG());
4169 PyObject *locals = f->f_locals;
4170 if (PyDict_CheckExact(locals) &&
4171 PyDict_GetItem(locals, name) == v) {
4172 if (PyDict_DelItem(locals, name) != 0) {
4173 PyErr_Clear();
4174 }
4175 }
4176 break;
4177 }
4178 }
4179 }
4180
Armin Rigo618fbf52004-08-07 20:58:32 +00004181 if (v->ob_refcnt == 1 && !PyString_CHECK_INTERNED(v)) {
Raymond Hettinger52a21b82004-08-06 18:43:09 +00004182 /* Now we own the last reference to 'v', so we can resize it
4183 * in-place.
4184 */
Thomas Wouters0e3f5912006-08-11 14:57:12 +00004185 if (_PyString_Resize(&v, new_len) != 0) {
Raymond Hettinger52a21b82004-08-06 18:43:09 +00004186 /* XXX if _PyString_Resize() fails, 'v' has been
4187 * deallocated so it cannot be put back into 'variable'.
4188 * The MemoryError is raised when there is no value in
4189 * 'variable', which might (very remotely) be a cause
4190 * of incompatibilities.
4191 */
4192 return NULL;
4193 }
4194 /* copy 'w' into the newly allocated area of 'v' */
4195 memcpy(PyString_AS_STRING(v) + v_len,
4196 PyString_AS_STRING(w), w_len);
4197 return v;
4198 }
4199 else {
4200 /* When in-place resizing is not an option. */
4201 PyString_Concat(&v, w);
4202 return v;
4203 }
4204}
4205
Guido van Rossum950361c1997-01-24 13:49:28 +00004206#ifdef DYNAMIC_EXECUTION_PROFILE
4207
Skip Montanarof118cb12001-10-15 20:51:38 +00004208static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00004209getarray(long a[256])
Guido van Rossum950361c1997-01-24 13:49:28 +00004210{
4211 int i;
4212 PyObject *l = PyList_New(256);
4213 if (l == NULL) return NULL;
4214 for (i = 0; i < 256; i++) {
4215 PyObject *x = PyInt_FromLong(a[i]);
4216 if (x == NULL) {
4217 Py_DECREF(l);
4218 return NULL;
4219 }
4220 PyList_SetItem(l, i, x);
4221 }
4222 for (i = 0; i < 256; i++)
4223 a[i] = 0;
4224 return l;
4225}
4226
4227PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00004228_Py_GetDXProfile(PyObject *self, PyObject *args)
Guido van Rossum950361c1997-01-24 13:49:28 +00004229{
4230#ifndef DXPAIRS
4231 return getarray(dxp);
4232#else
4233 int i;
4234 PyObject *l = PyList_New(257);
4235 if (l == NULL) return NULL;
4236 for (i = 0; i < 257; i++) {
4237 PyObject *x = getarray(dxpairs[i]);
4238 if (x == NULL) {
4239 Py_DECREF(l);
4240 return NULL;
4241 }
4242 PyList_SetItem(l, i, x);
4243 }
4244 return l;
4245#endif
4246}
4247
4248#endif