blob: 3ef853ea1b2f9ae9ba533c38e41205ba1db1d243 [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
Guido van Rossumb209a111997-04-29 18:18:01 +00009#include "Python.h"
Guido van Rossum10dc2e81990-11-18 17:27:39 +000010
Jeremy Hylton3e0055f2005-10-20 19:59:25 +000011#include "code.h"
Guido van Rossum3f5da241990-12-20 15:06:42 +000012#include "frameobject.h"
Guido van Rossumff4949e1992-08-05 19:58:53 +000013#include "eval.h"
Guido van Rossum10dc2e81990-11-18 17:27:39 +000014#include "opcode.h"
Tim Peters6d6c1a32001-08-02 04:15:00 +000015#include "structmember.h"
Guido van Rossum10dc2e81990-11-18 17:27:39 +000016
Guido van Rossumc6004111993-11-05 10:22:19 +000017#include <ctype.h>
18
Martin v. Löwis87fa7852004-08-29 15:51:52 +000019#ifndef WITH_TSC
Michael W. Hudson75eabd22005-01-18 15:56:11 +000020
21#define READ_TIMESTAMP(var)
22
23#else
Martin v. Löwisf30d60e2004-06-08 08:17:44 +000024
25typedef unsigned long long uint64;
26
Michael W. Hudson800ba232004-08-12 18:19:17 +000027#if defined(__ppc__) /* <- Don't know if this is the correct symbol; this
28 section should work for GCC on any PowerPC platform,
29 irrespective of OS. POWER? Who knows :-) */
30
Michael W. Hudson75eabd22005-01-18 15:56:11 +000031#define READ_TIMESTAMP(var) ppc_getcounter(&var)
Michael W. Hudson800ba232004-08-12 18:19:17 +000032
33static void
34ppc_getcounter(uint64 *v)
35{
36 register unsigned long tbu, tb, tbu2;
37
38 loop:
39 asm volatile ("mftbu %0" : "=r" (tbu) );
40 asm volatile ("mftb %0" : "=r" (tb) );
41 asm volatile ("mftbu %0" : "=r" (tbu2));
42 if (__builtin_expect(tbu != tbu2, 0)) goto loop;
43
44 /* The slightly peculiar way of writing the next lines is
45 compiled better by GCC than any other way I tried. */
46 ((long*)(v))[0] = tbu;
47 ((long*)(v))[1] = tb;
48}
49
Michael W. Hudson75eabd22005-01-18 15:56:11 +000050#else /* this is for linux/x86 (and probably any other GCC/x86 combo) */
Michael W. Hudson800ba232004-08-12 18:19:17 +000051
Michael W. Hudson75eabd22005-01-18 15:56:11 +000052#define READ_TIMESTAMP(val) \
53 __asm__ __volatile__("rdtsc" : "=A" (val))
Michael W. Hudson800ba232004-08-12 18:19:17 +000054
55#endif
56
Martin v. Löwisf30d60e2004-06-08 08:17:44 +000057void dump_tsc(int opcode, int ticked, uint64 inst0, uint64 inst1,
58 uint64 loop0, uint64 loop1, uint64 intr0, uint64 intr1)
59{
60 uint64 intr, inst, loop;
61 PyThreadState *tstate = PyThreadState_Get();
62 if (!tstate->interp->tscdump)
63 return;
64 intr = intr1 - intr0;
65 inst = inst1 - inst0 - intr;
66 loop = loop1 - loop0 - intr;
67 fprintf(stderr, "opcode=%03d t=%d inst=%06lld loop=%06lld\n",
68 opcode, ticked, inst, loop);
69}
Michael W. Hudson800ba232004-08-12 18:19:17 +000070
Martin v. Löwisf30d60e2004-06-08 08:17:44 +000071#endif
72
Guido van Rossum04691fc1992-08-12 15:35:34 +000073/* Turn this on if your compiler chokes on the big switch: */
Guido van Rossum1ae940a1995-01-02 19:04:15 +000074/* #define CASE_TOO_BIG 1 */
Guido van Rossum04691fc1992-08-12 15:35:34 +000075
Guido van Rossum408027e1996-12-30 16:17:54 +000076#ifdef Py_DEBUG
Guido van Rossum96a42c81992-01-12 02:29:51 +000077/* For debugging the interpreter: */
78#define LLTRACE 1 /* Low-level trace feature */
79#define CHECKEXC 1 /* Double-check exception checking */
Guido van Rossum10dc2e81990-11-18 17:27:39 +000080#endif
81
Jeremy Hylton52820442001-01-03 23:52:36 +000082typedef PyObject *(*callproc)(PyObject *, PyObject *, PyObject *);
Guido van Rossum5b722181993-03-30 17:46:03 +000083
Guido van Rossum374a9221991-04-04 10:40:29 +000084/* Forward declarations */
Martin v. Löwisf30d60e2004-06-08 08:17:44 +000085#ifdef WITH_TSC
86static PyObject *call_function(PyObject ***, int, uint64*, uint64*);
87#else
Jeremy Hyltone8c04322002-08-16 17:47:26 +000088static PyObject *call_function(PyObject ***, int);
Martin v. Löwisf30d60e2004-06-08 08:17:44 +000089#endif
Jeremy Hylton52820442001-01-03 23:52:36 +000090static PyObject *fast_function(PyObject *, PyObject ***, int, int, int);
Jeremy Hylton52820442001-01-03 23:52:36 +000091static PyObject *do_call(PyObject *, PyObject ***, int, int);
92static PyObject *ext_do_call(PyObject *, PyObject ***, int, int, int);
Guido van Rossumac7be682001-01-17 15:42:30 +000093static PyObject *update_keyword_args(PyObject *, int, PyObject ***,PyObject *);
Ka-Ping Yee20579702001-01-15 22:14:16 +000094static PyObject *update_star_args(int, int, PyObject *, PyObject ***);
Jeremy Hylton52820442001-01-03 23:52:36 +000095static PyObject *load_args(PyObject ***, int);
96#define CALL_FLAG_VAR 1
97#define CALL_FLAG_KW 2
98
Guido van Rossum0a066c01992-03-27 17:29:15 +000099#ifdef LLTRACE
Guido van Rossumc2e20742006-02-27 22:32:47 +0000100static int lltrace;
Tim Petersdbd9ba62000-07-09 03:09:57 +0000101static int prtrace(PyObject *, char *);
Guido van Rossum0a066c01992-03-27 17:29:15 +0000102#endif
Fred Drake5755ce62001-06-27 19:19:46 +0000103static int call_trace(Py_tracefunc, PyObject *, PyFrameObject *,
104 int, PyObject *);
Fred Drake4ec5d562001-10-04 19:26:43 +0000105static void call_trace_protected(Py_tracefunc, PyObject *,
Armin Rigo1c2d7e52005-09-20 18:34:01 +0000106 PyFrameObject *, int, PyObject *);
Fred Drake5755ce62001-06-27 19:19:46 +0000107static void call_exc_trace(Py_tracefunc, PyObject *, PyFrameObject *);
Tim Peters8a5c3c72004-04-05 19:36:21 +0000108static int maybe_call_line_trace(Py_tracefunc, PyObject *,
Armin Rigobf57a142004-03-22 19:24:58 +0000109 PyFrameObject *, int *, int *, int *);
Michael W. Hudsondd32a912002-08-15 14:59:02 +0000110
Tim Petersdbd9ba62000-07-09 03:09:57 +0000111static PyObject *apply_slice(PyObject *, PyObject *, PyObject *);
112static int assign_slice(PyObject *, PyObject *,
113 PyObject *, PyObject *);
114static PyObject *cmp_outcome(int, PyObject *, PyObject *);
Thomas Wouters52152252000-08-17 22:55:00 +0000115static PyObject *import_from(PyObject *, PyObject *);
116static int import_all_from(PyObject *, PyObject *);
Tim Petersdbd9ba62000-07-09 03:09:57 +0000117static PyObject *build_class(PyObject *, PyObject *, PyObject *);
118static int exec_statement(PyFrameObject *,
119 PyObject *, PyObject *, PyObject *);
Tim Petersdbd9ba62000-07-09 03:09:57 +0000120static void set_exc_info(PyThreadState *, PyObject *, PyObject *, PyObject *);
121static void reset_exc_info(PyThreadState *);
Paul Prescode68140d2000-08-30 20:25:01 +0000122static void format_exc_check_arg(PyObject *, char *, PyObject *);
Raymond Hettinger52a21b82004-08-06 18:43:09 +0000123static PyObject *string_concatenate(PyObject *, PyObject *,
124 PyFrameObject *, unsigned char *);
Guido van Rossum374a9221991-04-04 10:40:29 +0000125
Paul Prescode68140d2000-08-30 20:25:01 +0000126#define NAME_ERROR_MSG \
Fred Drake661ea262000-10-24 19:57:45 +0000127 "name '%.200s' is not defined"
Jeremy Hylton64949cb2001-01-25 20:06:59 +0000128#define GLOBAL_NAME_ERROR_MSG \
129 "global name '%.200s' is not defined"
Paul Prescode68140d2000-08-30 20:25:01 +0000130#define UNBOUNDLOCAL_ERROR_MSG \
Fred Drake661ea262000-10-24 19:57:45 +0000131 "local variable '%.200s' referenced before assignment"
Jeremy Hyltonc76770c2001-04-13 16:51:46 +0000132#define UNBOUNDFREE_ERROR_MSG \
133 "free variable '%.200s' referenced before assignment" \
134 " in enclosing scope"
Guido van Rossum374a9221991-04-04 10:40:29 +0000135
Guido van Rossum950361c1997-01-24 13:49:28 +0000136/* Dynamic execution profile */
137#ifdef DYNAMIC_EXECUTION_PROFILE
138#ifdef DXPAIRS
139static long dxpairs[257][256];
140#define dxp dxpairs[256]
141#else
142static long dxp[256];
143#endif
144#endif
145
Jeremy Hylton985eba52003-02-05 23:13:00 +0000146/* Function call profile */
147#ifdef CALL_PROFILE
148#define PCALL_NUM 11
149static int pcall[PCALL_NUM];
150
151#define PCALL_ALL 0
152#define PCALL_FUNCTION 1
153#define PCALL_FAST_FUNCTION 2
154#define PCALL_FASTER_FUNCTION 3
155#define PCALL_METHOD 4
156#define PCALL_BOUND_METHOD 5
157#define PCALL_CFUNCTION 6
158#define PCALL_TYPE 7
159#define PCALL_GENERATOR 8
160#define PCALL_OTHER 9
161#define PCALL_POP 10
162
163/* Notes about the statistics
164
165 PCALL_FAST stats
166
167 FAST_FUNCTION means no argument tuple needs to be created.
168 FASTER_FUNCTION means that the fast-path frame setup code is used.
169
170 If there is a method call where the call can be optimized by changing
171 the argument tuple and calling the function directly, it gets recorded
172 twice.
173
174 As a result, the relationship among the statistics appears to be
175 PCALL_ALL == PCALL_FUNCTION + PCALL_METHOD - PCALL_BOUND_METHOD +
176 PCALL_CFUNCTION + PCALL_TYPE + PCALL_GENERATOR + PCALL_OTHER
177 PCALL_FUNCTION > PCALL_FAST_FUNCTION > PCALL_FASTER_FUNCTION
178 PCALL_METHOD > PCALL_BOUND_METHOD
179*/
180
181#define PCALL(POS) pcall[POS]++
182
183PyObject *
184PyEval_GetCallStats(PyObject *self)
185{
Tim Peters8a5c3c72004-04-05 19:36:21 +0000186 return Py_BuildValue("iiiiiiiiii",
Jeremy Hylton985eba52003-02-05 23:13:00 +0000187 pcall[0], pcall[1], pcall[2], pcall[3],
188 pcall[4], pcall[5], pcall[6], pcall[7],
189 pcall[8], pcall[9]);
190}
191#else
192#define PCALL(O)
193
194PyObject *
195PyEval_GetCallStats(PyObject *self)
196{
197 Py_INCREF(Py_None);
198 return Py_None;
199}
200#endif
201
Tim Peters5ca576e2001-06-18 22:08:13 +0000202
Guido van Rossume59214e1994-08-30 08:01:59 +0000203#ifdef WITH_THREAD
Guido van Rossumff4949e1992-08-05 19:58:53 +0000204
Guido van Rossum2571cc81999-04-07 16:07:23 +0000205#ifndef DONT_HAVE_ERRNO_H
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000206#include <errno.h>
Guido van Rossum2571cc81999-04-07 16:07:23 +0000207#endif
Guido van Rossum49b56061998-10-01 20:42:43 +0000208#include "pythread.h"
Guido van Rossumff4949e1992-08-05 19:58:53 +0000209
Guido van Rossumb8b6d0c2003-06-28 21:53:52 +0000210static PyThread_type_lock interpreter_lock = 0; /* This is the GIL */
Guido van Rossuma9672091994-09-14 13:31:22 +0000211static long main_thread = 0;
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000212
Tim Peters7f468f22004-10-11 02:40:51 +0000213int
214PyEval_ThreadsInitialized(void)
215{
216 return interpreter_lock != 0;
217}
218
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000219void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000220PyEval_InitThreads(void)
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000221{
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000222 if (interpreter_lock)
Sjoerd Mullendered59d201993-01-06 13:36:38 +0000223 return;
Guido van Rossum65d5b571998-12-21 19:32:43 +0000224 interpreter_lock = PyThread_allocate_lock();
225 PyThread_acquire_lock(interpreter_lock, 1);
226 main_thread = PyThread_get_thread_ident();
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000227}
Guido van Rossumff4949e1992-08-05 19:58:53 +0000228
Guido van Rossum9cc8a201997-07-19 19:55:50 +0000229void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000230PyEval_AcquireLock(void)
Guido van Rossum25ce5661997-08-02 03:10:38 +0000231{
Guido van Rossum65d5b571998-12-21 19:32:43 +0000232 PyThread_acquire_lock(interpreter_lock, 1);
Guido van Rossum25ce5661997-08-02 03:10:38 +0000233}
234
235void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000236PyEval_ReleaseLock(void)
Guido van Rossum25ce5661997-08-02 03:10:38 +0000237{
Guido van Rossum65d5b571998-12-21 19:32:43 +0000238 PyThread_release_lock(interpreter_lock);
Guido van Rossum25ce5661997-08-02 03:10:38 +0000239}
240
241void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000242PyEval_AcquireThread(PyThreadState *tstate)
Guido van Rossum9cc8a201997-07-19 19:55:50 +0000243{
244 if (tstate == NULL)
245 Py_FatalError("PyEval_AcquireThread: NULL new thread state");
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000246 /* Check someone has called PyEval_InitThreads() to create the lock */
247 assert(interpreter_lock);
Guido van Rossum65d5b571998-12-21 19:32:43 +0000248 PyThread_acquire_lock(interpreter_lock, 1);
Guido van Rossum9cc8a201997-07-19 19:55:50 +0000249 if (PyThreadState_Swap(tstate) != NULL)
250 Py_FatalError(
251 "PyEval_AcquireThread: non-NULL old thread state");
252}
253
254void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000255PyEval_ReleaseThread(PyThreadState *tstate)
Guido van Rossum9cc8a201997-07-19 19:55:50 +0000256{
257 if (tstate == NULL)
258 Py_FatalError("PyEval_ReleaseThread: NULL thread state");
259 if (PyThreadState_Swap(NULL) != tstate)
260 Py_FatalError("PyEval_ReleaseThread: wrong thread state");
Guido van Rossum65d5b571998-12-21 19:32:43 +0000261 PyThread_release_lock(interpreter_lock);
Guido van Rossum9cc8a201997-07-19 19:55:50 +0000262}
Guido van Rossumfee3a2d2000-08-27 17:34:07 +0000263
264/* This function is called from PyOS_AfterFork to ensure that newly
265 created child processes don't hold locks referring to threads which
266 are not running in the child process. (This could also be done using
267 pthread_atfork mechanism, at least for the pthreads implementation.) */
268
269void
270PyEval_ReInitThreads(void)
271{
272 if (!interpreter_lock)
273 return;
274 /*XXX Can't use PyThread_free_lock here because it does too
275 much error-checking. Doing this cleanly would require
276 adding a new function to each thread_*.h. Instead, just
277 create a new lock and waste a little bit of memory */
278 interpreter_lock = PyThread_allocate_lock();
279 PyThread_acquire_lock(interpreter_lock, 1);
280 main_thread = PyThread_get_thread_ident();
281}
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000282#endif
283
Guido van Rossumff4949e1992-08-05 19:58:53 +0000284/* Functions save_thread and restore_thread are always defined so
285 dynamically loaded modules needn't be compiled separately for use
286 with and without threads: */
287
Guido van Rossum2fca21f71997-07-18 23:56:58 +0000288PyThreadState *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000289PyEval_SaveThread(void)
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000290{
Guido van Rossumb74eca91997-09-30 22:03:16 +0000291 PyThreadState *tstate = PyThreadState_Swap(NULL);
292 if (tstate == NULL)
293 Py_FatalError("PyEval_SaveThread: NULL tstate");
Guido van Rossume59214e1994-08-30 08:01:59 +0000294#ifdef WITH_THREAD
Guido van Rossumb74eca91997-09-30 22:03:16 +0000295 if (interpreter_lock)
Guido van Rossum65d5b571998-12-21 19:32:43 +0000296 PyThread_release_lock(interpreter_lock);
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000297#endif
Guido van Rossumb74eca91997-09-30 22:03:16 +0000298 return tstate;
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000299}
300
301void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000302PyEval_RestoreThread(PyThreadState *tstate)
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000303{
Guido van Rossumb74eca91997-09-30 22:03:16 +0000304 if (tstate == NULL)
305 Py_FatalError("PyEval_RestoreThread: NULL tstate");
Guido van Rossume59214e1994-08-30 08:01:59 +0000306#ifdef WITH_THREAD
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000307 if (interpreter_lock) {
Guido van Rossumb74eca91997-09-30 22:03:16 +0000308 int err = errno;
Guido van Rossum65d5b571998-12-21 19:32:43 +0000309 PyThread_acquire_lock(interpreter_lock, 1);
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000310 errno = err;
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000311 }
312#endif
Guido van Rossumb74eca91997-09-30 22:03:16 +0000313 PyThreadState_Swap(tstate);
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000314}
315
316
Guido van Rossuma9672091994-09-14 13:31:22 +0000317/* Mechanism whereby asynchronously executing callbacks (e.g. UNIX
318 signal handlers or Mac I/O completion routines) can schedule calls
319 to a function to be called synchronously.
320 The synchronous function is called with one void* argument.
321 It should return 0 for success or -1 for failure -- failure should
322 be accompanied by an exception.
323
324 If registry succeeds, the registry function returns 0; if it fails
325 (e.g. due to too many pending calls) it returns -1 (without setting
326 an exception condition).
327
328 Note that because registry may occur from within signal handlers,
329 or other asynchronous events, calling malloc() is unsafe!
330
331#ifdef WITH_THREAD
332 Any thread can schedule pending calls, but only the main thread
333 will execute them.
334#endif
335
336 XXX WARNING! ASYNCHRONOUSLY EXECUTING CODE!
337 There are two possible race conditions:
338 (1) nested asynchronous registry calls;
339 (2) registry calls made while pending calls are being processed.
340 While (1) is very unlikely, (2) is a real possibility.
341 The current code is safe against (2), but not against (1).
342 The safety against (2) is derived from the fact that only one
343 thread (the main thread) ever takes things out of the queue.
Guido van Rossuma9672091994-09-14 13:31:22 +0000344
Guido van Rossuma027efa1997-05-05 20:56:21 +0000345 XXX Darn! With the advent of thread state, we should have an array
346 of pending calls per thread in the thread state! Later...
347*/
Guido van Rossum8861b741996-07-30 16:49:37 +0000348
Guido van Rossuma9672091994-09-14 13:31:22 +0000349#define NPENDINGCALLS 32
350static struct {
Thomas Wouters334fb892000-07-25 12:56:38 +0000351 int (*func)(void *);
352 void *arg;
Guido van Rossuma9672091994-09-14 13:31:22 +0000353} pendingcalls[NPENDINGCALLS];
354static volatile int pendingfirst = 0;
355static volatile int pendinglast = 0;
Guido van Rossuma027efa1997-05-05 20:56:21 +0000356static volatile int things_to_do = 0;
Guido van Rossuma9672091994-09-14 13:31:22 +0000357
358int
Thomas Wouters334fb892000-07-25 12:56:38 +0000359Py_AddPendingCall(int (*func)(void *), void *arg)
Guido van Rossuma9672091994-09-14 13:31:22 +0000360{
Michael W. Hudson30ea2f22004-07-07 17:44:12 +0000361 static volatile int busy = 0;
Guido van Rossuma9672091994-09-14 13:31:22 +0000362 int i, j;
363 /* XXX Begin critical section */
364 /* XXX If you want this to be safe against nested
365 XXX asynchronous calls, you'll have to work harder! */
Guido van Rossum180d7b41994-09-29 09:45:57 +0000366 if (busy)
367 return -1;
368 busy = 1;
Guido van Rossuma9672091994-09-14 13:31:22 +0000369 i = pendinglast;
370 j = (i + 1) % NPENDINGCALLS;
Guido van Rossum04e70322002-07-17 16:57:13 +0000371 if (j == pendingfirst) {
372 busy = 0;
Guido van Rossuma9672091994-09-14 13:31:22 +0000373 return -1; /* Queue full */
Guido van Rossum04e70322002-07-17 16:57:13 +0000374 }
Guido van Rossuma9672091994-09-14 13:31:22 +0000375 pendingcalls[i].func = func;
376 pendingcalls[i].arg = arg;
377 pendinglast = j;
Skip Montanarod581d772002-09-03 20:10:45 +0000378
379 _Py_Ticker = 0;
Guido van Rossuma027efa1997-05-05 20:56:21 +0000380 things_to_do = 1; /* Signal main loop */
Guido van Rossum180d7b41994-09-29 09:45:57 +0000381 busy = 0;
Guido van Rossuma9672091994-09-14 13:31:22 +0000382 /* XXX End critical section */
383 return 0;
384}
385
Guido van Rossum180d7b41994-09-29 09:45:57 +0000386int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000387Py_MakePendingCalls(void)
Guido van Rossuma9672091994-09-14 13:31:22 +0000388{
Guido van Rossum180d7b41994-09-29 09:45:57 +0000389 static int busy = 0;
Guido van Rossuma9672091994-09-14 13:31:22 +0000390#ifdef WITH_THREAD
Guido van Rossum65d5b571998-12-21 19:32:43 +0000391 if (main_thread && PyThread_get_thread_ident() != main_thread)
Guido van Rossuma9672091994-09-14 13:31:22 +0000392 return 0;
393#endif
Guido van Rossuma027efa1997-05-05 20:56:21 +0000394 if (busy)
Guido van Rossum180d7b41994-09-29 09:45:57 +0000395 return 0;
396 busy = 1;
Guido van Rossuma027efa1997-05-05 20:56:21 +0000397 things_to_do = 0;
Guido van Rossuma9672091994-09-14 13:31:22 +0000398 for (;;) {
399 int i;
Thomas Wouters334fb892000-07-25 12:56:38 +0000400 int (*func)(void *);
401 void *arg;
Guido van Rossuma9672091994-09-14 13:31:22 +0000402 i = pendingfirst;
403 if (i == pendinglast)
404 break; /* Queue empty */
405 func = pendingcalls[i].func;
406 arg = pendingcalls[i].arg;
407 pendingfirst = (i + 1) % NPENDINGCALLS;
Guido van Rossum180d7b41994-09-29 09:45:57 +0000408 if (func(arg) < 0) {
409 busy = 0;
Guido van Rossuma027efa1997-05-05 20:56:21 +0000410 things_to_do = 1; /* We're not done yet */
Guido van Rossuma9672091994-09-14 13:31:22 +0000411 return -1;
Guido van Rossum180d7b41994-09-29 09:45:57 +0000412 }
Guido van Rossuma9672091994-09-14 13:31:22 +0000413 }
Guido van Rossum180d7b41994-09-29 09:45:57 +0000414 busy = 0;
Guido van Rossuma9672091994-09-14 13:31:22 +0000415 return 0;
416}
417
418
Jeremy Hyltonee5adfb2000-08-31 19:23:01 +0000419/* The interpreter's recursion limit */
420
Hye-Shik Changb6fa2812005-04-04 15:49:02 +0000421#ifndef Py_DEFAULT_RECURSION_LIMIT
422#define Py_DEFAULT_RECURSION_LIMIT 1000
423#endif
424static int recursion_limit = Py_DEFAULT_RECURSION_LIMIT;
425int _Py_CheckRecursionLimit = Py_DEFAULT_RECURSION_LIMIT;
Jeremy Hyltonee5adfb2000-08-31 19:23:01 +0000426
Vladimir Marangozov7bd25be2000-09-01 11:07:19 +0000427int
428Py_GetRecursionLimit(void)
Jeremy Hyltonee5adfb2000-08-31 19:23:01 +0000429{
430 return recursion_limit;
431}
432
Vladimir Marangozov7bd25be2000-09-01 11:07:19 +0000433void
434Py_SetRecursionLimit(int new_limit)
Jeremy Hyltonee5adfb2000-08-31 19:23:01 +0000435{
436 recursion_limit = new_limit;
Armin Rigo2b3eb402003-10-28 12:05:48 +0000437 _Py_CheckRecursionLimit = recursion_limit;
Jeremy Hyltonee5adfb2000-08-31 19:23:01 +0000438}
439
Armin Rigo2b3eb402003-10-28 12:05:48 +0000440/* the macro Py_EnterRecursiveCall() only calls _Py_CheckRecursiveCall()
441 if the recursion_depth reaches _Py_CheckRecursionLimit.
442 If USE_STACKCHECK, the macro decrements _Py_CheckRecursionLimit
443 to guarantee that _Py_CheckRecursiveCall() is regularly called.
444 Without USE_STACKCHECK, there is no need for this. */
445int
446_Py_CheckRecursiveCall(char *where)
447{
448 PyThreadState *tstate = PyThreadState_GET();
449
450#ifdef USE_STACKCHECK
451 if (PyOS_CheckStack()) {
452 --tstate->recursion_depth;
453 PyErr_SetString(PyExc_MemoryError, "Stack overflow");
454 return -1;
455 }
456#endif
457 if (tstate->recursion_depth > recursion_limit) {
458 --tstate->recursion_depth;
459 PyErr_Format(PyExc_RuntimeError,
460 "maximum recursion depth exceeded%s",
461 where);
462 return -1;
463 }
464 _Py_CheckRecursionLimit = recursion_limit;
465 return 0;
466}
467
Guido van Rossum374a9221991-04-04 10:40:29 +0000468/* Status code for main loop (reason for stack unwind) */
Raymond Hettinger7c958652004-04-06 10:11:10 +0000469enum why_code {
470 WHY_NOT = 0x0001, /* No error */
471 WHY_EXCEPTION = 0x0002, /* Exception occurred */
472 WHY_RERAISE = 0x0004, /* Exception re-raised by 'finally' */
473 WHY_RETURN = 0x0008, /* 'return' statement */
474 WHY_BREAK = 0x0010, /* 'break' statement */
475 WHY_CONTINUE = 0x0020, /* 'continue' statement */
476 WHY_YIELD = 0x0040 /* 'yield' operator */
477};
Guido van Rossum374a9221991-04-04 10:40:29 +0000478
Raymond Hettinger7c958652004-04-06 10:11:10 +0000479static enum why_code do_raise(PyObject *, PyObject *, PyObject *);
Tim Petersd6d010b2001-06-21 02:49:55 +0000480static int unpack_iterable(PyObject *, int, PyObject **);
Guido van Rossum1aa14831997-01-21 05:34:20 +0000481
Skip Montanarod581d772002-09-03 20:10:45 +0000482/* for manipulating the thread switch and periodic "stuff" - used to be
483 per thread, now just a pair o' globals */
Skip Montanaro99dba272002-09-03 20:19:06 +0000484int _Py_CheckInterval = 100;
485volatile int _Py_Ticker = 100;
Guido van Rossum374a9221991-04-04 10:40:29 +0000486
Guido van Rossumb209a111997-04-29 18:18:01 +0000487PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000488PyEval_EvalCode(PyCodeObject *co, PyObject *globals, PyObject *locals)
Guido van Rossum681d79a1995-07-18 14:51:37 +0000489{
Jeremy Hylton985eba52003-02-05 23:13:00 +0000490 /* XXX raise SystemError if globals is NULL */
Tim Peters6d6c1a32001-08-02 04:15:00 +0000491 return PyEval_EvalCodeEx(co,
Guido van Rossum681d79a1995-07-18 14:51:37 +0000492 globals, locals,
Guido van Rossumb209a111997-04-29 18:18:01 +0000493 (PyObject **)NULL, 0,
494 (PyObject **)NULL, 0,
Jeremy Hylton64949cb2001-01-25 20:06:59 +0000495 (PyObject **)NULL, 0,
496 NULL);
Guido van Rossum681d79a1995-07-18 14:51:37 +0000497}
498
499
500/* Interpreter main loop */
501
Martin v. Löwis8d97e332004-06-27 15:43:12 +0000502PyObject *
Phillip J. Eby0d6615f2005-08-02 00:46:46 +0000503PyEval_EvalFrame(PyFrameObject *f) {
504 /* This is for backward compatibility with extension modules that
505 used this API; core interpreter code should call PyEval_EvalFrameEx() */
506 return PyEval_EvalFrameEx(f, 0);
507}
508
509PyObject *
510PyEval_EvalFrameEx(PyFrameObject *f, int throw)
Guido van Rossum374a9221991-04-04 10:40:29 +0000511{
Guido van Rossum950361c1997-01-24 13:49:28 +0000512#ifdef DXPAIRS
513 int lastopcode = 0;
514#endif
Armin Rigo8817fcd2004-06-17 10:22:40 +0000515 register PyObject **stack_pointer; /* Next free slot in value stack */
Guido van Rossum374a9221991-04-04 10:40:29 +0000516 register unsigned char *next_instr;
Armin Rigo8817fcd2004-06-17 10:22:40 +0000517 register int opcode; /* Current opcode */
518 register int oparg; /* Current opcode argument, if any */
Raymond Hettinger7c958652004-04-06 10:11:10 +0000519 register enum why_code why; /* Reason for block stack unwind */
Guido van Rossum374a9221991-04-04 10:40:29 +0000520 register int err; /* Error status -- nonzero if error */
Guido van Rossumb209a111997-04-29 18:18:01 +0000521 register PyObject *x; /* Result object -- NULL if error */
522 register PyObject *v; /* Temporary objects popped off stack */
523 register PyObject *w;
524 register PyObject *u;
525 register PyObject *t;
Barry Warsaw23c9ec82000-08-21 15:44:01 +0000526 register PyObject *stream = NULL; /* for PRINT opcodes */
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
562 loop1 -- place where control returns again to top of mainloop
563 (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
580 EXEC_STMT
581 IMPORT_STAR
582 IMPORT_FROM
583 CALL_FUNCTION (and friends)
584
585 */
586 uint64 inst0, inst1, loop0, loop1, intr0 = 0, intr1 = 0;
587 int ticked = 0;
588
Michael W. Hudson75eabd22005-01-18 15:56:11 +0000589 READ_TIMESTAMP(inst0);
590 READ_TIMESTAMP(inst1);
591 READ_TIMESTAMP(loop0);
592 READ_TIMESTAMP(loop1);
Michael W. Hudson800ba232004-08-12 18:19:17 +0000593
594 /* shut up the compiler */
595 opcode = 0;
Martin v. Löwisf30d60e2004-06-08 08:17:44 +0000596#endif
597
Guido van Rossum374a9221991-04-04 10:40:29 +0000598/* Code access macros */
599
Martin v. Löwis18e16552006-02-15 17:27:45 +0000600#define INSTR_OFFSET() ((int)(next_instr - first_instr))
Guido van Rossum374a9221991-04-04 10:40:29 +0000601#define NEXTOP() (*next_instr++)
Raymond Hettinger5bed4562004-04-10 23:34:17 +0000602#define NEXTARG() (next_instr += 2, (next_instr[-1]<<8) + next_instr[-2])
Raymond Hettinger52a21b82004-08-06 18:43:09 +0000603#define PEEKARG() ((next_instr[2]<<8) + next_instr[1])
Guido van Rossumd076c731998-10-07 19:42:25 +0000604#define JUMPTO(x) (next_instr = first_instr + (x))
Guido van Rossum374a9221991-04-04 10:40:29 +0000605#define JUMPBY(x) (next_instr += (x))
606
Raymond Hettingerf606f872003-03-16 03:11:04 +0000607/* OpCode prediction macros
608 Some opcodes tend to come in pairs thus making it possible to predict
609 the second code when the first is run. For example, COMPARE_OP is often
610 followed by JUMP_IF_FALSE or JUMP_IF_TRUE. And, those opcodes are often
611 followed by a POP_TOP.
612
613 Verifying the prediction costs a single high-speed test of register
Raymond Hettingerac2072922003-03-16 15:41:11 +0000614 variable against a constant. If the pairing was good, then the
Raymond Hettingerf606f872003-03-16 03:11:04 +0000615 processor has a high likelihood of making its own successful branch
616 prediction which results in a nearly zero overhead transition to the
617 next opcode.
618
619 A successful prediction saves a trip through the eval-loop including
620 its two unpredictable branches, the HASARG test and the switch-case.
Raymond Hettingera7216982004-02-08 19:59:27 +0000621
Tim Peters8a5c3c72004-04-05 19:36:21 +0000622 If collecting opcode statistics, turn off prediction so that
623 statistics are accurately maintained (the predictions bypass
Raymond Hettingera7216982004-02-08 19:59:27 +0000624 the opcode frequency counter updates).
Raymond Hettingerf606f872003-03-16 03:11:04 +0000625*/
626
Raymond Hettingera7216982004-02-08 19:59:27 +0000627#ifdef DYNAMIC_EXECUTION_PROFILE
628#define PREDICT(op) if (0) goto PRED_##op
629#else
Raymond Hettingerac2072922003-03-16 15:41:11 +0000630#define PREDICT(op) if (*next_instr == op) goto PRED_##op
Raymond Hettingera7216982004-02-08 19:59:27 +0000631#endif
632
Raymond Hettingerf606f872003-03-16 03:11:04 +0000633#define PREDICTED(op) PRED_##op: next_instr++
Raymond Hettinger52a21b82004-08-06 18:43:09 +0000634#define PREDICTED_WITH_ARG(op) PRED_##op: oparg = PEEKARG(); next_instr += 3
Raymond Hettingerf606f872003-03-16 03:11:04 +0000635
Guido van Rossum374a9221991-04-04 10:40:29 +0000636/* Stack manipulation macros */
637
Martin v. Löwis18e16552006-02-15 17:27:45 +0000638/* The stack can grow at most MAXINT deep, as co_nlocals and
639 co_stacksize are ints. */
640#define STACK_LEVEL() ((int)(stack_pointer - f->f_valuestack))
Guido van Rossum374a9221991-04-04 10:40:29 +0000641#define EMPTY() (STACK_LEVEL() == 0)
642#define TOP() (stack_pointer[-1])
Raymond Hettinger663004b2003-01-09 15:24:30 +0000643#define SECOND() (stack_pointer[-2])
644#define THIRD() (stack_pointer[-3])
645#define FOURTH() (stack_pointer[-4])
Raymond Hettinger663004b2003-01-09 15:24:30 +0000646#define SET_TOP(v) (stack_pointer[-1] = (v))
647#define SET_SECOND(v) (stack_pointer[-2] = (v))
648#define SET_THIRD(v) (stack_pointer[-3] = (v))
649#define SET_FOURTH(v) (stack_pointer[-4] = (v))
Raymond Hettinger663004b2003-01-09 15:24:30 +0000650#define BASIC_STACKADJ(n) (stack_pointer += n)
Guido van Rossum374a9221991-04-04 10:40:29 +0000651#define BASIC_PUSH(v) (*stack_pointer++ = (v))
652#define BASIC_POP() (*--stack_pointer)
653
Guido van Rossum96a42c81992-01-12 02:29:51 +0000654#ifdef LLTRACE
Jeremy Hylton14368152001-10-17 13:29:30 +0000655#define PUSH(v) { (void)(BASIC_PUSH(v), \
656 lltrace && prtrace(TOP(), "push")); \
657 assert(STACK_LEVEL() <= f->f_stacksize); }
Fred Drakede26cfc2001-10-13 06:11:28 +0000658#define POP() ((void)(lltrace && prtrace(TOP(), "pop")), BASIC_POP())
Raymond Hettinger663004b2003-01-09 15:24:30 +0000659#define STACKADJ(n) { (void)(BASIC_STACKADJ(n), \
660 lltrace && prtrace(TOP(), "stackadj")); \
661 assert(STACK_LEVEL() <= f->f_stacksize); }
Guido van Rossumc2e20742006-02-27 22:32:47 +0000662#define EXT_POP(STACK_POINTER) (lltrace && prtrace(*(STACK_POINTER), "ext_pop"), *--(STACK_POINTER))
Guido van Rossum374a9221991-04-04 10:40:29 +0000663#else
664#define PUSH(v) BASIC_PUSH(v)
665#define POP() BASIC_POP()
Raymond Hettinger663004b2003-01-09 15:24:30 +0000666#define STACKADJ(n) BASIC_STACKADJ(n)
Guido van Rossumc2e20742006-02-27 22:32:47 +0000667#define EXT_POP(STACK_POINTER) (*--(STACK_POINTER))
Guido van Rossum374a9221991-04-04 10:40:29 +0000668#endif
669
Guido van Rossum681d79a1995-07-18 14:51:37 +0000670/* Local variable macros */
671
672#define GETLOCAL(i) (fastlocals[i])
Guido van Rossumcfbf1a32002-03-28 20:17:52 +0000673
674/* The SETLOCAL() macro must not DECREF the local variable in-place and
675 then store the new value; it must copy the old value to a temporary
676 value, then store the new value, and then DECREF the temporary value.
677 This is because it is possible that during the DECREF the frame is
678 accessed by other code (e.g. a __del__ method or gc.collect()) and the
679 variable would be pointing to already-freed memory. */
680#define SETLOCAL(i, value) do { PyObject *tmp = GETLOCAL(i); \
681 GETLOCAL(i) = value; \
682 Py_XDECREF(tmp); } while (0)
Guido van Rossum681d79a1995-07-18 14:51:37 +0000683
Guido van Rossuma027efa1997-05-05 20:56:21 +0000684/* Start of code */
685
Tim Peters5ca576e2001-06-18 22:08:13 +0000686 if (f == NULL)
687 return NULL;
688
Armin Rigo1d313ab2003-10-25 14:33:09 +0000689 /* push frame */
Armin Rigo2b3eb402003-10-28 12:05:48 +0000690 if (Py_EnterRecursiveCall(""))
Armin Rigo1d313ab2003-10-25 14:33:09 +0000691 return NULL;
Guido van Rossum8861b741996-07-30 16:49:37 +0000692
Tim Peters5ca576e2001-06-18 22:08:13 +0000693 tstate->frame = f;
Tim Peters5ca576e2001-06-18 22:08:13 +0000694
Neil Schemenauer6c0f2002001-09-04 19:03:35 +0000695 if (tstate->use_tracing) {
696 if (tstate->c_tracefunc != NULL) {
697 /* tstate->c_tracefunc, if defined, is a
698 function that will be called on *every* entry
699 to a code block. Its return value, if not
700 None, is a function that will be called at
701 the start of each executed line of code.
702 (Actually, the function must return itself
703 in order to continue tracing.) The trace
704 functions are called with three arguments:
705 a pointer to the current frame, a string
706 indicating why the function is called, and
707 an argument which depends on the situation.
708 The global trace function is also called
709 whenever an exception is detected. */
710 if (call_trace(tstate->c_tracefunc, tstate->c_traceobj,
711 f, PyTrace_CALL, Py_None)) {
Neil Schemenauer6c0f2002001-09-04 19:03:35 +0000712 /* Trace function raised an error */
Armin Rigo2b3eb402003-10-28 12:05:48 +0000713 goto exit_eval_frame;
Neil Schemenauer6c0f2002001-09-04 19:03:35 +0000714 }
715 }
716 if (tstate->c_profilefunc != NULL) {
717 /* Similar for c_profilefunc, except it needn't
718 return itself and isn't called for "line" events */
719 if (call_trace(tstate->c_profilefunc,
720 tstate->c_profileobj,
721 f, PyTrace_CALL, Py_None)) {
Neil Schemenauer6c0f2002001-09-04 19:03:35 +0000722 /* Profile function raised an error */
Armin Rigo2b3eb402003-10-28 12:05:48 +0000723 goto exit_eval_frame;
Neil Schemenauer6c0f2002001-09-04 19:03:35 +0000724 }
725 }
726 }
727
Michael W. Hudson019a78e2002-11-08 12:53:11 +0000728 co = f->f_code;
729 names = co->co_names;
730 consts = co->co_consts;
731 fastlocals = f->f_localsplus;
732 freevars = f->f_localsplus + f->f_nlocals;
Brett Cannonc9371d42005-06-25 08:23:41 +0000733 first_instr = (unsigned char*) PyString_AS_STRING(co->co_code);
Michael W. Hudson019a78e2002-11-08 12:53:11 +0000734 /* An explanation is in order for the next line.
735
736 f->f_lasti now refers to the index of the last instruction
737 executed. You might think this was obvious from the name, but
738 this wasn't always true before 2.3! PyFrame_New now sets
739 f->f_lasti to -1 (i.e. the index *before* the first instruction)
740 and YIELD_VALUE doesn't fiddle with f_lasti any more. So this
741 does work. Promise. */
742 next_instr = first_instr + f->f_lasti + 1;
743 stack_pointer = f->f_stacktop;
744 assert(stack_pointer != NULL);
745 f->f_stacktop = NULL; /* remains NULL unless yield suspends frame */
746
Tim Peters5ca576e2001-06-18 22:08:13 +0000747#ifdef LLTRACE
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000748 lltrace = PyDict_GetItemString(f->f_globals, "__lltrace__") != NULL;
Tim Peters5ca576e2001-06-18 22:08:13 +0000749#endif
Neal Norwitz5f5153e2005-10-21 04:28:38 +0000750#if defined(Py_DEBUG) || defined(LLTRACE)
Tim Peters5ca576e2001-06-18 22:08:13 +0000751 filename = PyString_AsString(co->co_filename);
752#endif
Guido van Rossumac7be682001-01-17 15:42:30 +0000753
Guido van Rossum374a9221991-04-04 10:40:29 +0000754 why = WHY_NOT;
755 err = 0;
Guido van Rossumb209a111997-04-29 18:18:01 +0000756 x = Py_None; /* Not a reference, just anything non-NULL */
Fred Drake48fba732000-10-11 13:54:07 +0000757 w = NULL;
Guido van Rossumac7be682001-01-17 15:42:30 +0000758
Phillip J. Eby0d6615f2005-08-02 00:46:46 +0000759 if (throw) { /* support for generator.throw() */
760 why = WHY_EXCEPTION;
761 goto on_error;
762 }
763
Guido van Rossum374a9221991-04-04 10:40:29 +0000764 for (;;) {
Martin v. Löwisf30d60e2004-06-08 08:17:44 +0000765#ifdef WITH_TSC
766 if (inst1 == 0) {
767 /* Almost surely, the opcode executed a break
768 or a continue, preventing inst1 from being set
769 on the way out of the loop.
770 */
Michael W. Hudson75eabd22005-01-18 15:56:11 +0000771 READ_TIMESTAMP(inst1);
Martin v. Löwisf30d60e2004-06-08 08:17:44 +0000772 loop1 = inst1;
773 }
774 dump_tsc(opcode, ticked, inst0, inst1, loop0, loop1,
775 intr0, intr1);
776 ticked = 0;
777 inst1 = 0;
778 intr0 = 0;
779 intr1 = 0;
Michael W. Hudson75eabd22005-01-18 15:56:11 +0000780 READ_TIMESTAMP(loop0);
Martin v. Löwisf30d60e2004-06-08 08:17:44 +0000781#endif
Michael W. Hudsondd32a912002-08-15 14:59:02 +0000782 assert(stack_pointer >= f->f_valuestack); /* else underflow */
783 assert(STACK_LEVEL() <= f->f_stacksize); /* else overflow */
784
Guido van Rossuma027efa1997-05-05 20:56:21 +0000785 /* Do periodic things. Doing this every time through
786 the loop would add too much overhead, so we do it
787 only every Nth instruction. We also do it if
788 ``things_to_do'' is set, i.e. when an asynchronous
789 event needs attention (e.g. a signal handler or
790 async I/O handler); see Py_AddPendingCall() and
791 Py_MakePendingCalls() above. */
Guido van Rossumac7be682001-01-17 15:42:30 +0000792
Skip Montanarod581d772002-09-03 20:10:45 +0000793 if (--_Py_Ticker < 0) {
Guido van Rossumb8b6d0c2003-06-28 21:53:52 +0000794 if (*next_instr == SETUP_FINALLY) {
795 /* Make the last opcode before
796 a try: finally: block uninterruptable. */
797 goto fast_next_opcode;
798 }
Skip Montanarod581d772002-09-03 20:10:45 +0000799 _Py_Ticker = _Py_CheckInterval;
Michael W. Hudson019a78e2002-11-08 12:53:11 +0000800 tstate->tick_counter++;
Martin v. Löwisf30d60e2004-06-08 08:17:44 +0000801#ifdef WITH_TSC
802 ticked = 1;
803#endif
Guido van Rossuma027efa1997-05-05 20:56:21 +0000804 if (things_to_do) {
Guido van Rossum8861b741996-07-30 16:49:37 +0000805 if (Py_MakePendingCalls() < 0) {
806 why = WHY_EXCEPTION;
807 goto on_error;
808 }
Kurt B. Kaiser4c79a832004-11-23 18:06:08 +0000809 if (things_to_do)
810 /* MakePendingCalls() didn't succeed.
811 Force early re-execution of this
812 "periodic" code, possibly after
813 a thread switch */
814 _Py_Ticker = 0;
Guido van Rossum8861b741996-07-30 16:49:37 +0000815 }
Guido van Rossume59214e1994-08-30 08:01:59 +0000816#ifdef WITH_THREAD
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000817 if (interpreter_lock) {
818 /* Give another thread a chance */
819
Guido van Rossum25ce5661997-08-02 03:10:38 +0000820 if (PyThreadState_Swap(NULL) != tstate)
821 Py_FatalError("ceval: tstate mix-up");
Guido van Rossum65d5b571998-12-21 19:32:43 +0000822 PyThread_release_lock(interpreter_lock);
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000823
824 /* Other threads may run now */
825
Guido van Rossum65d5b571998-12-21 19:32:43 +0000826 PyThread_acquire_lock(interpreter_lock, 1);
Guido van Rossum25ce5661997-08-02 03:10:38 +0000827 if (PyThreadState_Swap(tstate) != NULL)
828 Py_FatalError("ceval: orphan tstate");
Guido van Rossumb8b6d0c2003-06-28 21:53:52 +0000829
830 /* Check for thread interrupts */
831
832 if (tstate->async_exc != NULL) {
833 x = tstate->async_exc;
834 tstate->async_exc = NULL;
835 PyErr_SetNone(x);
836 Py_DECREF(x);
837 why = WHY_EXCEPTION;
838 goto on_error;
839 }
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000840 }
841#endif
Guido van Rossum374a9221991-04-04 10:40:29 +0000842 }
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000843
Neil Schemenauer63543862002-02-17 19:10:14 +0000844 fast_next_opcode:
Guido van Rossum99bec951992-09-03 20:29:45 +0000845 f->f_lasti = INSTR_OFFSET();
Guido van Rossumac7be682001-01-17 15:42:30 +0000846
Michael W. Hudson019a78e2002-11-08 12:53:11 +0000847 /* line-by-line tracing support */
848
849 if (tstate->c_tracefunc != NULL && !tstate->tracing) {
850 /* see maybe_call_line_trace
851 for expository comments */
852 f->f_stacktop = stack_pointer;
Tim Peters8a5c3c72004-04-05 19:36:21 +0000853
Michael W. Hudson58ee2af2003-04-29 16:18:47 +0000854 err = maybe_call_line_trace(tstate->c_tracefunc,
855 tstate->c_traceobj,
Armin Rigobf57a142004-03-22 19:24:58 +0000856 f, &instr_lb, &instr_ub,
857 &instr_prev);
Michael W. Hudson019a78e2002-11-08 12:53:11 +0000858 /* Reload possibly changed frame fields */
859 JUMPTO(f->f_lasti);
Michael W. Hudson58ee2af2003-04-29 16:18:47 +0000860 if (f->f_stacktop != NULL) {
861 stack_pointer = f->f_stacktop;
862 f->f_stacktop = NULL;
863 }
864 if (err) {
865 /* trace function raised an exception */
866 goto on_error;
867 }
Michael W. Hudson019a78e2002-11-08 12:53:11 +0000868 }
869
870 /* Extract opcode and argument */
871
Guido van Rossum374a9221991-04-04 10:40:29 +0000872 opcode = NEXTOP();
Armin Rigo8817fcd2004-06-17 10:22:40 +0000873 oparg = 0; /* allows oparg to be stored in a register because
874 it doesn't have to be remembered across a full loop */
Raymond Hettinger5bed4562004-04-10 23:34:17 +0000875 if (HAS_ARG(opcode))
876 oparg = NEXTARG();
Fred Drakeef8ace32000-08-24 00:32:09 +0000877 dispatch_opcode:
Guido van Rossum950361c1997-01-24 13:49:28 +0000878#ifdef DYNAMIC_EXECUTION_PROFILE
879#ifdef DXPAIRS
880 dxpairs[lastopcode][opcode]++;
881 lastopcode = opcode;
882#endif
883 dxp[opcode]++;
884#endif
Guido van Rossum374a9221991-04-04 10:40:29 +0000885
Guido van Rossum96a42c81992-01-12 02:29:51 +0000886#ifdef LLTRACE
Guido van Rossum374a9221991-04-04 10:40:29 +0000887 /* Instruction tracing */
Guido van Rossumac7be682001-01-17 15:42:30 +0000888
Guido van Rossum96a42c81992-01-12 02:29:51 +0000889 if (lltrace) {
Guido van Rossum374a9221991-04-04 10:40:29 +0000890 if (HAS_ARG(opcode)) {
891 printf("%d: %d, %d\n",
Michael W. Hudsondd32a912002-08-15 14:59:02 +0000892 f->f_lasti, opcode, oparg);
Guido van Rossum374a9221991-04-04 10:40:29 +0000893 }
894 else {
895 printf("%d: %d\n",
Michael W. Hudsondd32a912002-08-15 14:59:02 +0000896 f->f_lasti, opcode);
Guido van Rossum374a9221991-04-04 10:40:29 +0000897 }
898 }
899#endif
Michael W. Hudsondd32a912002-08-15 14:59:02 +0000900
Guido van Rossum374a9221991-04-04 10:40:29 +0000901 /* Main switch on opcode */
Michael W. Hudson75eabd22005-01-18 15:56:11 +0000902 READ_TIMESTAMP(inst0);
Jeremy Hylton52820442001-01-03 23:52:36 +0000903
Guido van Rossum374a9221991-04-04 10:40:29 +0000904 switch (opcode) {
Guido van Rossumac7be682001-01-17 15:42:30 +0000905
Guido van Rossum374a9221991-04-04 10:40:29 +0000906 /* BEWARE!
907 It is essential that any operation that fails sets either
908 x to NULL, err to nonzero, or why to anything but WHY_NOT,
909 and that no operation that succeeds does this! */
Guido van Rossumac7be682001-01-17 15:42:30 +0000910
Guido van Rossum374a9221991-04-04 10:40:29 +0000911 /* case STOP_CODE: this is an error! */
Guido van Rossumac7be682001-01-17 15:42:30 +0000912
Raymond Hettinger9c18e812004-06-21 16:31:15 +0000913 case NOP:
914 goto fast_next_opcode;
915
Neil Schemenauer63543862002-02-17 19:10:14 +0000916 case LOAD_FAST:
917 x = GETLOCAL(oparg);
918 if (x != NULL) {
919 Py_INCREF(x);
920 PUSH(x);
921 goto fast_next_opcode;
922 }
923 format_exc_check_arg(PyExc_UnboundLocalError,
924 UNBOUNDLOCAL_ERROR_MSG,
925 PyTuple_GetItem(co->co_varnames, oparg));
926 break;
927
928 case LOAD_CONST:
Skip Montanaro04d80f82002-08-04 21:03:35 +0000929 x = GETITEM(consts, oparg);
Neil Schemenauer63543862002-02-17 19:10:14 +0000930 Py_INCREF(x);
931 PUSH(x);
932 goto fast_next_opcode;
933
Raymond Hettinger7dc52212003-03-16 20:14:44 +0000934 PREDICTED_WITH_ARG(STORE_FAST);
Neil Schemenauer63543862002-02-17 19:10:14 +0000935 case STORE_FAST:
936 v = POP();
937 SETLOCAL(oparg, v);
938 goto fast_next_opcode;
939
Raymond Hettingerf606f872003-03-16 03:11:04 +0000940 PREDICTED(POP_TOP);
Guido van Rossum374a9221991-04-04 10:40:29 +0000941 case POP_TOP:
942 v = POP();
Guido van Rossumb209a111997-04-29 18:18:01 +0000943 Py_DECREF(v);
Neil Schemenauer63543862002-02-17 19:10:14 +0000944 goto fast_next_opcode;
Guido van Rossumac7be682001-01-17 15:42:30 +0000945
Guido van Rossum374a9221991-04-04 10:40:29 +0000946 case ROT_TWO:
Raymond Hettinger663004b2003-01-09 15:24:30 +0000947 v = TOP();
948 w = SECOND();
949 SET_TOP(w);
950 SET_SECOND(v);
Raymond Hettinger080cb322003-03-14 01:37:42 +0000951 goto fast_next_opcode;
Guido van Rossumac7be682001-01-17 15:42:30 +0000952
Guido van Rossum374a9221991-04-04 10:40:29 +0000953 case ROT_THREE:
Raymond Hettinger663004b2003-01-09 15:24:30 +0000954 v = TOP();
955 w = SECOND();
956 x = THIRD();
957 SET_TOP(w);
958 SET_SECOND(x);
959 SET_THIRD(v);
Raymond Hettinger080cb322003-03-14 01:37:42 +0000960 goto fast_next_opcode;
Guido van Rossumac7be682001-01-17 15:42:30 +0000961
Thomas Wouters434d0822000-08-24 20:11:32 +0000962 case ROT_FOUR:
Raymond Hettinger663004b2003-01-09 15:24:30 +0000963 u = TOP();
964 v = SECOND();
965 w = THIRD();
966 x = FOURTH();
967 SET_TOP(v);
968 SET_SECOND(w);
969 SET_THIRD(x);
970 SET_FOURTH(u);
Raymond Hettinger080cb322003-03-14 01:37:42 +0000971 goto fast_next_opcode;
Guido van Rossumac7be682001-01-17 15:42:30 +0000972
Guido van Rossum374a9221991-04-04 10:40:29 +0000973 case DUP_TOP:
974 v = TOP();
Guido van Rossumb209a111997-04-29 18:18:01 +0000975 Py_INCREF(v);
Guido van Rossum374a9221991-04-04 10:40:29 +0000976 PUSH(v);
Raymond Hettinger080cb322003-03-14 01:37:42 +0000977 goto fast_next_opcode;
Guido van Rossumac7be682001-01-17 15:42:30 +0000978
Thomas Wouters434d0822000-08-24 20:11:32 +0000979 case DUP_TOPX:
Raymond Hettinger4bad9ba2003-01-19 05:08:13 +0000980 if (oparg == 2) {
Raymond Hettinger663004b2003-01-09 15:24:30 +0000981 x = TOP();
Tim Peters35ba6892000-10-11 07:04:49 +0000982 Py_INCREF(x);
Raymond Hettinger663004b2003-01-09 15:24:30 +0000983 w = SECOND();
Tim Peters35ba6892000-10-11 07:04:49 +0000984 Py_INCREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +0000985 STACKADJ(2);
986 SET_TOP(x);
987 SET_SECOND(w);
Raymond Hettingerf606f872003-03-16 03:11:04 +0000988 goto fast_next_opcode;
Raymond Hettinger4bad9ba2003-01-19 05:08:13 +0000989 } else if (oparg == 3) {
Raymond Hettinger663004b2003-01-09 15:24:30 +0000990 x = TOP();
Tim Peters35ba6892000-10-11 07:04:49 +0000991 Py_INCREF(x);
Raymond Hettinger663004b2003-01-09 15:24:30 +0000992 w = SECOND();
Tim Peters35ba6892000-10-11 07:04:49 +0000993 Py_INCREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +0000994 v = THIRD();
Tim Peters35ba6892000-10-11 07:04:49 +0000995 Py_INCREF(v);
Raymond Hettinger663004b2003-01-09 15:24:30 +0000996 STACKADJ(3);
997 SET_TOP(x);
998 SET_SECOND(w);
999 SET_THIRD(v);
Raymond Hettingerf606f872003-03-16 03:11:04 +00001000 goto fast_next_opcode;
Thomas Wouters434d0822000-08-24 20:11:32 +00001001 }
Raymond Hettinger4bad9ba2003-01-19 05:08:13 +00001002 Py_FatalError("invalid argument to DUP_TOPX"
1003 " (bytecode corruption?)");
Tim Peters35ba6892000-10-11 07:04:49 +00001004 break;
Thomas Wouters434d0822000-08-24 20:11:32 +00001005
Guido van Rossum374a9221991-04-04 10:40:29 +00001006 case UNARY_POSITIVE:
Raymond Hettinger663004b2003-01-09 15:24:30 +00001007 v = TOP();
Guido van Rossumfc490731997-05-06 15:06:49 +00001008 x = PyNumber_Positive(v);
Guido van Rossumb209a111997-04-29 18:18:01 +00001009 Py_DECREF(v);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001010 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001011 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001012 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001013
Guido van Rossum374a9221991-04-04 10:40:29 +00001014 case UNARY_NEGATIVE:
Raymond Hettinger663004b2003-01-09 15:24:30 +00001015 v = TOP();
Guido van Rossumfc490731997-05-06 15:06:49 +00001016 x = PyNumber_Negative(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_NOT:
Raymond Hettinger663004b2003-01-09 15:24:30 +00001023 v = TOP();
Guido van Rossumfc490731997-05-06 15:06:49 +00001024 err = PyObject_IsTrue(v);
Guido van Rossumb209a111997-04-29 18:18:01 +00001025 Py_DECREF(v);
Guido van Rossumfc490731997-05-06 15:06:49 +00001026 if (err == 0) {
1027 Py_INCREF(Py_True);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001028 SET_TOP(Py_True);
Guido van Rossumfc490731997-05-06 15:06:49 +00001029 continue;
1030 }
1031 else if (err > 0) {
1032 Py_INCREF(Py_False);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001033 SET_TOP(Py_False);
Guido van Rossumfc490731997-05-06 15:06:49 +00001034 err = 0;
1035 continue;
1036 }
Raymond Hettinger8bb90a52003-01-14 12:43:10 +00001037 STACKADJ(-1);
Guido van Rossum374a9221991-04-04 10:40:29 +00001038 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001039
Guido van Rossum374a9221991-04-04 10:40:29 +00001040 case UNARY_CONVERT:
Raymond Hettinger663004b2003-01-09 15:24:30 +00001041 v = TOP();
Guido van Rossumb209a111997-04-29 18:18:01 +00001042 x = PyObject_Repr(v);
1043 Py_DECREF(v);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001044 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001045 if (x != NULL) continue;
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
Guido van Rossum374a9221991-04-04 10:40:29 +00001076 case BINARY_DIVIDE:
Tim Peters3caca232001-12-06 06:23:26 +00001077 if (!_Py_QnewFlag) {
1078 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001079 v = TOP();
Tim Peters3caca232001-12-06 06:23:26 +00001080 x = PyNumber_Divide(v, w);
1081 Py_DECREF(v);
1082 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001083 SET_TOP(x);
Tim Peters3caca232001-12-06 06:23:26 +00001084 if (x != NULL) continue;
1085 break;
1086 }
Raymond Hettinger663004b2003-01-09 15:24:30 +00001087 /* -Qnew is in effect: fall through to
Tim Peters3caca232001-12-06 06:23:26 +00001088 BINARY_TRUE_DIVIDE */
1089 case BINARY_TRUE_DIVIDE:
Guido van Rossum374a9221991-04-04 10:40:29 +00001090 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001091 v = TOP();
Tim Peters3caca232001-12-06 06:23:26 +00001092 x = PyNumber_TrueDivide(v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +00001093 Py_DECREF(v);
1094 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001095 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001096 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001097 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001098
Guido van Rossum4668b002001-08-08 05:00:18 +00001099 case BINARY_FLOOR_DIVIDE:
1100 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001101 v = TOP();
Guido van Rossum4668b002001-08-08 05:00:18 +00001102 x = PyNumber_FloorDivide(v, w);
1103 Py_DECREF(v);
1104 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001105 SET_TOP(x);
Guido van Rossum4668b002001-08-08 05:00:18 +00001106 if (x != NULL) continue;
1107 break;
1108
Guido van Rossum374a9221991-04-04 10:40:29 +00001109 case BINARY_MODULO:
1110 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001111 v = TOP();
Guido van Rossumfc490731997-05-06 15:06:49 +00001112 x = PyNumber_Remainder(v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +00001113 Py_DECREF(v);
1114 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001115 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001116 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001117 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001118
Guido van Rossum374a9221991-04-04 10:40:29 +00001119 case BINARY_ADD:
1120 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001121 v = TOP();
Tim Petersc1e6d962001-10-05 20:21:03 +00001122 if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
Guido van Rossumc12da691997-07-17 23:12:42 +00001123 /* INLINE: int + int */
1124 register long a, b, i;
Guido van Rossumcf183ac1998-12-04 18:51:36 +00001125 a = PyInt_AS_LONG(v);
1126 b = PyInt_AS_LONG(w);
Guido van Rossumc12da691997-07-17 23:12:42 +00001127 i = a + b;
Guido van Rossum87780df2001-08-23 02:58:07 +00001128 if ((i^a) < 0 && (i^b) < 0)
1129 goto slow_add;
1130 x = PyInt_FromLong(i);
Guido van Rossumc12da691997-07-17 23:12:42 +00001131 }
Raymond Hettinger52a21b82004-08-06 18:43:09 +00001132 else if (PyString_CheckExact(v) &&
1133 PyString_CheckExact(w)) {
1134 x = string_concatenate(v, w, f, next_instr);
1135 /* string_concatenate consumed the ref to v */
1136 goto skip_decref_vx;
1137 }
Guido van Rossum87780df2001-08-23 02:58:07 +00001138 else {
1139 slow_add:
Guido van Rossumc12da691997-07-17 23:12:42 +00001140 x = PyNumber_Add(v, w);
Guido van Rossum87780df2001-08-23 02:58:07 +00001141 }
Guido van Rossumb209a111997-04-29 18:18:01 +00001142 Py_DECREF(v);
Raymond Hettinger52a21b82004-08-06 18:43:09 +00001143 skip_decref_vx:
Guido van Rossumb209a111997-04-29 18:18:01 +00001144 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001145 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001146 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001147 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001148
Guido van Rossum374a9221991-04-04 10:40:29 +00001149 case BINARY_SUBTRACT:
1150 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001151 v = TOP();
Tim Petersc1e6d962001-10-05 20:21:03 +00001152 if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
Guido van Rossumc12da691997-07-17 23:12:42 +00001153 /* INLINE: int - int */
1154 register long a, b, i;
Guido van Rossumcf183ac1998-12-04 18:51:36 +00001155 a = PyInt_AS_LONG(v);
1156 b = PyInt_AS_LONG(w);
Guido van Rossumc12da691997-07-17 23:12:42 +00001157 i = a - b;
Guido van Rossum87780df2001-08-23 02:58:07 +00001158 if ((i^a) < 0 && (i^~b) < 0)
1159 goto slow_sub;
1160 x = PyInt_FromLong(i);
Guido van Rossumc12da691997-07-17 23:12:42 +00001161 }
Guido van Rossum87780df2001-08-23 02:58:07 +00001162 else {
1163 slow_sub:
Guido van Rossumc12da691997-07-17 23:12:42 +00001164 x = PyNumber_Subtract(v, w);
Guido van Rossum87780df2001-08-23 02:58:07 +00001165 }
Guido van Rossumb209a111997-04-29 18:18:01 +00001166 Py_DECREF(v);
1167 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001168 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001169 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001170 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001171
Guido van Rossum374a9221991-04-04 10:40:29 +00001172 case BINARY_SUBSCR:
1173 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001174 v = TOP();
Tim Petersb1c46982001-10-05 20:41:38 +00001175 if (PyList_CheckExact(v) && PyInt_CheckExact(w)) {
Guido van Rossumc12da691997-07-17 23:12:42 +00001176 /* INLINE: list[int] */
1177 long i = PyInt_AsLong(w);
1178 if (i < 0)
Guido van Rossumfa00e951998-07-08 15:02:37 +00001179 i += PyList_GET_SIZE(v);
Raymond Hettinger467a6982004-04-07 11:39:21 +00001180 if (i >= 0 && i < PyList_GET_SIZE(v)) {
Guido van Rossumfa00e951998-07-08 15:02:37 +00001181 x = PyList_GET_ITEM(v, i);
Guido van Rossumc12da691997-07-17 23:12:42 +00001182 Py_INCREF(x);
1183 }
Raymond Hettinger467a6982004-04-07 11:39:21 +00001184 else
1185 goto slow_get;
Guido van Rossumc12da691997-07-17 23:12:42 +00001186 }
1187 else
Raymond Hettinger467a6982004-04-07 11:39:21 +00001188 slow_get:
Guido van Rossumc12da691997-07-17 23:12:42 +00001189 x = PyObject_GetItem(v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +00001190 Py_DECREF(v);
1191 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001192 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001193 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001194 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001195
Guido van Rossum7928cd71991-10-24 14:59:31 +00001196 case BINARY_LSHIFT:
1197 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001198 v = TOP();
Guido van Rossumfc490731997-05-06 15:06:49 +00001199 x = PyNumber_Lshift(v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +00001200 Py_DECREF(v);
1201 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001202 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001203 if (x != NULL) continue;
Guido van Rossum7928cd71991-10-24 14:59:31 +00001204 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001205
Guido van Rossum7928cd71991-10-24 14:59:31 +00001206 case BINARY_RSHIFT:
1207 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001208 v = TOP();
Guido van Rossumfc490731997-05-06 15:06:49 +00001209 x = PyNumber_Rshift(v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +00001210 Py_DECREF(v);
1211 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001212 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001213 if (x != NULL) continue;
Guido van Rossum7928cd71991-10-24 14:59:31 +00001214 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001215
Guido van Rossum7928cd71991-10-24 14:59:31 +00001216 case BINARY_AND:
1217 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001218 v = TOP();
Guido van Rossumfc490731997-05-06 15:06:49 +00001219 x = PyNumber_And(v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +00001220 Py_DECREF(v);
1221 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001222 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001223 if (x != NULL) continue;
Guido van Rossum7928cd71991-10-24 14:59:31 +00001224 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001225
Guido van Rossum7928cd71991-10-24 14:59:31 +00001226 case BINARY_XOR:
1227 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001228 v = TOP();
Guido van Rossumfc490731997-05-06 15:06:49 +00001229 x = PyNumber_Xor(v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +00001230 Py_DECREF(v);
1231 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001232 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001233 if (x != NULL) continue;
Guido van Rossum7928cd71991-10-24 14:59:31 +00001234 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001235
Guido van Rossum7928cd71991-10-24 14:59:31 +00001236 case BINARY_OR:
1237 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001238 v = TOP();
Guido van Rossumfc490731997-05-06 15:06:49 +00001239 x = PyNumber_Or(v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +00001240 Py_DECREF(v);
1241 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001242 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001243 if (x != NULL) continue;
Guido van Rossum7928cd71991-10-24 14:59:31 +00001244 break;
Thomas Wouters434d0822000-08-24 20:11:32 +00001245
Raymond Hettingerdd80f762004-03-07 07:31:06 +00001246 case LIST_APPEND:
1247 w = POP();
1248 v = POP();
1249 err = PyList_Append(v, w);
1250 Py_DECREF(v);
1251 Py_DECREF(w);
Raymond Hettingerfba1cfc2004-03-12 16:33:17 +00001252 if (err == 0) {
1253 PREDICT(JUMP_ABSOLUTE);
1254 continue;
1255 }
Raymond Hettingerdd80f762004-03-07 07:31:06 +00001256 break;
1257
Thomas Wouters434d0822000-08-24 20:11:32 +00001258 case INPLACE_POWER:
1259 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001260 v = TOP();
Thomas Wouters434d0822000-08-24 20:11:32 +00001261 x = PyNumber_InPlacePower(v, w, Py_None);
1262 Py_DECREF(v);
1263 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001264 SET_TOP(x);
Thomas Wouters434d0822000-08-24 20:11:32 +00001265 if (x != NULL) continue;
1266 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001267
Thomas Wouters434d0822000-08-24 20:11:32 +00001268 case INPLACE_MULTIPLY:
1269 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001270 v = TOP();
Thomas Wouters434d0822000-08-24 20:11:32 +00001271 x = PyNumber_InPlaceMultiply(v, w);
1272 Py_DECREF(v);
1273 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001274 SET_TOP(x);
Thomas Wouters434d0822000-08-24 20:11:32 +00001275 if (x != NULL) continue;
1276 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001277
Thomas Wouters434d0822000-08-24 20:11:32 +00001278 case INPLACE_DIVIDE:
Tim Peters54b11912001-12-25 18:49:11 +00001279 if (!_Py_QnewFlag) {
1280 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001281 v = TOP();
Tim Peters54b11912001-12-25 18:49:11 +00001282 x = PyNumber_InPlaceDivide(v, w);
1283 Py_DECREF(v);
1284 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001285 SET_TOP(x);
Tim Peters54b11912001-12-25 18:49:11 +00001286 if (x != NULL) continue;
1287 break;
1288 }
Raymond Hettinger663004b2003-01-09 15:24:30 +00001289 /* -Qnew is in effect: fall through to
Tim Peters54b11912001-12-25 18:49:11 +00001290 INPLACE_TRUE_DIVIDE */
1291 case INPLACE_TRUE_DIVIDE:
Thomas Wouters434d0822000-08-24 20:11:32 +00001292 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001293 v = TOP();
Tim Peters54b11912001-12-25 18:49:11 +00001294 x = PyNumber_InPlaceTrueDivide(v, w);
Thomas Wouters434d0822000-08-24 20:11:32 +00001295 Py_DECREF(v);
1296 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001297 SET_TOP(x);
Thomas Wouters434d0822000-08-24 20:11:32 +00001298 if (x != NULL) continue;
1299 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001300
Guido van Rossum4668b002001-08-08 05:00:18 +00001301 case INPLACE_FLOOR_DIVIDE:
1302 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001303 v = TOP();
Guido van Rossum4668b002001-08-08 05:00:18 +00001304 x = PyNumber_InPlaceFloorDivide(v, w);
1305 Py_DECREF(v);
1306 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001307 SET_TOP(x);
Guido van Rossum4668b002001-08-08 05:00:18 +00001308 if (x != NULL) continue;
1309 break;
1310
Thomas Wouters434d0822000-08-24 20:11:32 +00001311 case INPLACE_MODULO:
1312 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001313 v = TOP();
Thomas Wouters434d0822000-08-24 20:11:32 +00001314 x = PyNumber_InPlaceRemainder(v, w);
1315 Py_DECREF(v);
1316 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001317 SET_TOP(x);
Thomas Wouters434d0822000-08-24 20:11:32 +00001318 if (x != NULL) continue;
1319 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001320
Thomas Wouters434d0822000-08-24 20:11:32 +00001321 case INPLACE_ADD:
1322 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001323 v = TOP();
Tim Petersc1e6d962001-10-05 20:21:03 +00001324 if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
Thomas Wouters434d0822000-08-24 20:11:32 +00001325 /* INLINE: int + int */
1326 register long a, b, i;
1327 a = PyInt_AS_LONG(v);
1328 b = PyInt_AS_LONG(w);
1329 i = a + b;
Guido van Rossum87780df2001-08-23 02:58:07 +00001330 if ((i^a) < 0 && (i^b) < 0)
1331 goto slow_iadd;
1332 x = PyInt_FromLong(i);
Thomas Wouters434d0822000-08-24 20:11:32 +00001333 }
Raymond Hettinger52a21b82004-08-06 18:43:09 +00001334 else if (PyString_CheckExact(v) &&
1335 PyString_CheckExact(w)) {
1336 x = string_concatenate(v, w, f, next_instr);
1337 /* string_concatenate consumed the ref to v */
1338 goto skip_decref_v;
1339 }
Guido van Rossum87780df2001-08-23 02:58:07 +00001340 else {
1341 slow_iadd:
Thomas Wouters434d0822000-08-24 20:11:32 +00001342 x = PyNumber_InPlaceAdd(v, w);
Guido van Rossum87780df2001-08-23 02:58:07 +00001343 }
Thomas Wouters434d0822000-08-24 20:11:32 +00001344 Py_DECREF(v);
Raymond Hettinger52a21b82004-08-06 18:43:09 +00001345 skip_decref_v:
Thomas Wouters434d0822000-08-24 20:11:32 +00001346 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001347 SET_TOP(x);
Thomas Wouters434d0822000-08-24 20:11:32 +00001348 if (x != NULL) continue;
1349 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001350
Thomas Wouters434d0822000-08-24 20:11:32 +00001351 case INPLACE_SUBTRACT:
1352 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001353 v = TOP();
Tim Petersc1e6d962001-10-05 20:21:03 +00001354 if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
Thomas Wouters434d0822000-08-24 20:11:32 +00001355 /* INLINE: int - int */
1356 register long a, b, i;
1357 a = PyInt_AS_LONG(v);
1358 b = PyInt_AS_LONG(w);
1359 i = a - b;
Guido van Rossum87780df2001-08-23 02:58:07 +00001360 if ((i^a) < 0 && (i^~b) < 0)
1361 goto slow_isub;
1362 x = PyInt_FromLong(i);
Thomas Wouters434d0822000-08-24 20:11:32 +00001363 }
Guido van Rossum87780df2001-08-23 02:58:07 +00001364 else {
1365 slow_isub:
Thomas Wouters434d0822000-08-24 20:11:32 +00001366 x = PyNumber_InPlaceSubtract(v, w);
Guido van Rossum87780df2001-08-23 02:58:07 +00001367 }
Thomas Wouters434d0822000-08-24 20:11:32 +00001368 Py_DECREF(v);
1369 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001370 SET_TOP(x);
Thomas Wouters434d0822000-08-24 20:11:32 +00001371 if (x != NULL) continue;
1372 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001373
Thomas Wouters434d0822000-08-24 20:11:32 +00001374 case INPLACE_LSHIFT:
1375 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001376 v = TOP();
Thomas Wouters434d0822000-08-24 20:11:32 +00001377 x = PyNumber_InPlaceLshift(v, w);
1378 Py_DECREF(v);
1379 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001380 SET_TOP(x);
Thomas Wouters434d0822000-08-24 20:11:32 +00001381 if (x != NULL) continue;
1382 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001383
Thomas Wouters434d0822000-08-24 20:11:32 +00001384 case INPLACE_RSHIFT:
1385 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001386 v = TOP();
Thomas Wouters434d0822000-08-24 20:11:32 +00001387 x = PyNumber_InPlaceRshift(v, w);
1388 Py_DECREF(v);
1389 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001390 SET_TOP(x);
Thomas Wouters434d0822000-08-24 20:11:32 +00001391 if (x != NULL) continue;
1392 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001393
Thomas Wouters434d0822000-08-24 20:11:32 +00001394 case INPLACE_AND:
1395 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001396 v = TOP();
Thomas Wouters434d0822000-08-24 20:11:32 +00001397 x = PyNumber_InPlaceAnd(v, w);
1398 Py_DECREF(v);
1399 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001400 SET_TOP(x);
Thomas Wouters434d0822000-08-24 20:11:32 +00001401 if (x != NULL) continue;
1402 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001403
Thomas Wouters434d0822000-08-24 20:11:32 +00001404 case INPLACE_XOR:
1405 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001406 v = TOP();
Thomas Wouters434d0822000-08-24 20:11:32 +00001407 x = PyNumber_InPlaceXor(v, w);
1408 Py_DECREF(v);
1409 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001410 SET_TOP(x);
Thomas Wouters434d0822000-08-24 20:11:32 +00001411 if (x != NULL) continue;
1412 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001413
Thomas Wouters434d0822000-08-24 20:11:32 +00001414 case INPLACE_OR:
1415 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001416 v = TOP();
Thomas Wouters434d0822000-08-24 20:11:32 +00001417 x = PyNumber_InPlaceOr(v, w);
1418 Py_DECREF(v);
1419 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001420 SET_TOP(x);
Thomas Wouters434d0822000-08-24 20:11:32 +00001421 if (x != NULL) continue;
1422 break;
1423
Guido van Rossum374a9221991-04-04 10:40:29 +00001424 case SLICE+0:
1425 case SLICE+1:
1426 case SLICE+2:
1427 case SLICE+3:
1428 if ((opcode-SLICE) & 2)
1429 w = POP();
1430 else
1431 w = NULL;
1432 if ((opcode-SLICE) & 1)
1433 v = POP();
1434 else
1435 v = NULL;
Raymond Hettinger663004b2003-01-09 15:24:30 +00001436 u = TOP();
Guido van Rossum374a9221991-04-04 10:40:29 +00001437 x = apply_slice(u, v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +00001438 Py_DECREF(u);
1439 Py_XDECREF(v);
1440 Py_XDECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001441 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001442 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001443 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001444
Guido van Rossum374a9221991-04-04 10:40:29 +00001445 case STORE_SLICE+0:
1446 case STORE_SLICE+1:
1447 case STORE_SLICE+2:
1448 case STORE_SLICE+3:
1449 if ((opcode-STORE_SLICE) & 2)
1450 w = POP();
1451 else
1452 w = NULL;
1453 if ((opcode-STORE_SLICE) & 1)
1454 v = POP();
1455 else
1456 v = NULL;
1457 u = POP();
1458 t = POP();
1459 err = assign_slice(u, v, w, t); /* u[v:w] = t */
Guido van Rossumb209a111997-04-29 18:18:01 +00001460 Py_DECREF(t);
1461 Py_DECREF(u);
1462 Py_XDECREF(v);
1463 Py_XDECREF(w);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001464 if (err == 0) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001465 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001466
Guido van Rossum374a9221991-04-04 10:40:29 +00001467 case DELETE_SLICE+0:
1468 case DELETE_SLICE+1:
1469 case DELETE_SLICE+2:
1470 case DELETE_SLICE+3:
1471 if ((opcode-DELETE_SLICE) & 2)
1472 w = POP();
1473 else
1474 w = NULL;
1475 if ((opcode-DELETE_SLICE) & 1)
1476 v = POP();
1477 else
1478 v = NULL;
1479 u = POP();
Guido van Rossumb209a111997-04-29 18:18:01 +00001480 err = assign_slice(u, v, w, (PyObject *)NULL);
Guido van Rossum374a9221991-04-04 10:40:29 +00001481 /* del u[v:w] */
Guido van Rossumb209a111997-04-29 18:18:01 +00001482 Py_DECREF(u);
1483 Py_XDECREF(v);
1484 Py_XDECREF(w);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001485 if (err == 0) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001486 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001487
Guido van Rossum374a9221991-04-04 10:40:29 +00001488 case STORE_SUBSCR:
Raymond Hettinger663004b2003-01-09 15:24:30 +00001489 w = TOP();
1490 v = SECOND();
1491 u = THIRD();
1492 STACKADJ(-3);
Guido van Rossum374a9221991-04-04 10:40:29 +00001493 /* v[w] = u */
Guido van Rossumfc490731997-05-06 15:06:49 +00001494 err = PyObject_SetItem(v, w, u);
Guido van Rossumb209a111997-04-29 18:18:01 +00001495 Py_DECREF(u);
1496 Py_DECREF(v);
1497 Py_DECREF(w);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001498 if (err == 0) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001499 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001500
Guido van Rossum374a9221991-04-04 10:40:29 +00001501 case DELETE_SUBSCR:
Raymond Hettinger663004b2003-01-09 15:24:30 +00001502 w = TOP();
1503 v = SECOND();
1504 STACKADJ(-2);
Guido van Rossum374a9221991-04-04 10:40:29 +00001505 /* del v[w] */
Guido van Rossumfc490731997-05-06 15:06:49 +00001506 err = PyObject_DelItem(v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +00001507 Py_DECREF(v);
1508 Py_DECREF(w);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001509 if (err == 0) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001510 break;
Barry Warsaw23c9ec82000-08-21 15:44:01 +00001511
Guido van Rossum374a9221991-04-04 10:40:29 +00001512 case PRINT_EXPR:
1513 v = POP();
Moshe Zadkaf68f2fe2001-01-11 05:41:27 +00001514 w = PySys_GetObject("displayhook");
1515 if (w == NULL) {
1516 PyErr_SetString(PyExc_RuntimeError,
1517 "lost sys.displayhook");
1518 err = -1;
Moshe Zadkaf5df3832001-01-11 11:55:37 +00001519 x = NULL;
Moshe Zadkaf68f2fe2001-01-11 05:41:27 +00001520 }
1521 if (err == 0) {
Raymond Hettinger8ae46892003-10-12 19:09:37 +00001522 x = PyTuple_Pack(1, v);
Moshe Zadkaf68f2fe2001-01-11 05:41:27 +00001523 if (x == NULL)
1524 err = -1;
1525 }
1526 if (err == 0) {
1527 w = PyEval_CallObject(w, x);
Moshe Zadkaf5df3832001-01-11 11:55:37 +00001528 Py_XDECREF(w);
Moshe Zadkaf68f2fe2001-01-11 05:41:27 +00001529 if (w == NULL)
1530 err = -1;
Guido van Rossum374a9221991-04-04 10:40:29 +00001531 }
Guido van Rossumb209a111997-04-29 18:18:01 +00001532 Py_DECREF(v);
Moshe Zadkaf68f2fe2001-01-11 05:41:27 +00001533 Py_XDECREF(x);
Guido van Rossum374a9221991-04-04 10:40:29 +00001534 break;
Moshe Zadkaf68f2fe2001-01-11 05:41:27 +00001535
Barry Warsaw23c9ec82000-08-21 15:44:01 +00001536 case PRINT_ITEM_TO:
1537 w = stream = POP();
1538 /* fall through to PRINT_ITEM */
1539
Guido van Rossum374a9221991-04-04 10:40:29 +00001540 case PRINT_ITEM:
1541 v = POP();
Barry Warsaw093abe02000-08-29 04:56:13 +00001542 if (stream == NULL || stream == Py_None) {
Barry Warsaw23c9ec82000-08-21 15:44:01 +00001543 w = PySys_GetObject("stdout");
1544 if (w == NULL) {
1545 PyErr_SetString(PyExc_RuntimeError,
1546 "lost sys.stdout");
1547 err = -1;
1548 }
Guido van Rossum8f183201997-12-31 05:53:15 +00001549 }
Neal Norwitzc5131bc2003-06-29 14:48:32 +00001550 /* PyFile_SoftSpace() can exececute arbitrary code
1551 if sys.stdout is an instance with a __getattr__.
1552 If __getattr__ raises an exception, w will
1553 be freed, so we need to prevent that temporarily. */
1554 Py_XINCREF(w);
Tim Peters8e5fd532002-03-24 19:25:00 +00001555 if (w != NULL && PyFile_SoftSpace(w, 0))
Guido van Rossumbe270261997-05-22 22:26:18 +00001556 err = PyFile_WriteString(" ", w);
1557 if (err == 0)
1558 err = PyFile_WriteObject(v, w, Py_PRINT_RAW);
Marc-André Lemburg0c4d8d02001-11-20 15:17:25 +00001559 if (err == 0) {
Tim Peters8e5fd532002-03-24 19:25:00 +00001560 /* XXX move into writeobject() ? */
Marc-André Lemburg0c4d8d02001-11-20 15:17:25 +00001561 if (PyString_Check(v)) {
1562 char *s = PyString_AS_STRING(v);
1563 int len = PyString_GET_SIZE(v);
Tim Peters8e5fd532002-03-24 19:25:00 +00001564 if (len == 0 ||
1565 !isspace(Py_CHARMASK(s[len-1])) ||
1566 s[len-1] == ' ')
1567 PyFile_SoftSpace(w, 1);
Tim Peters8a5c3c72004-04-05 19:36:21 +00001568 }
Martin v. Löwis8d3ce5a2001-12-18 22:36:40 +00001569#ifdef Py_USING_UNICODE
Marc-André Lemburg0c4d8d02001-11-20 15:17:25 +00001570 else if (PyUnicode_Check(v)) {
1571 Py_UNICODE *s = PyUnicode_AS_UNICODE(v);
1572 int len = PyUnicode_GET_SIZE(v);
Tim Peters8e5fd532002-03-24 19:25:00 +00001573 if (len == 0 ||
1574 !Py_UNICODE_ISSPACE(s[len-1]) ||
1575 s[len-1] == ' ')
1576 PyFile_SoftSpace(w, 1);
Marc-André Lemburg0c4d8d02001-11-20 15:17:25 +00001577 }
Michael W. Hudsond95c8282002-05-20 13:56:11 +00001578#endif
Tim Peters8e5fd532002-03-24 19:25:00 +00001579 else
1580 PyFile_SoftSpace(w, 1);
Guido van Rossum374a9221991-04-04 10:40:29 +00001581 }
Neal Norwitzc5131bc2003-06-29 14:48:32 +00001582 Py_XDECREF(w);
Guido van Rossumb209a111997-04-29 18:18:01 +00001583 Py_DECREF(v);
Barry Warsaw23c9ec82000-08-21 15:44:01 +00001584 Py_XDECREF(stream);
1585 stream = NULL;
1586 if (err == 0)
1587 continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001588 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001589
Barry Warsaw23c9ec82000-08-21 15:44:01 +00001590 case PRINT_NEWLINE_TO:
1591 w = stream = POP();
1592 /* fall through to PRINT_NEWLINE */
1593
Guido van Rossum374a9221991-04-04 10:40:29 +00001594 case PRINT_NEWLINE:
Barry Warsaw093abe02000-08-29 04:56:13 +00001595 if (stream == NULL || stream == Py_None) {
Barry Warsaw23c9ec82000-08-21 15:44:01 +00001596 w = PySys_GetObject("stdout");
1597 if (w == NULL)
1598 PyErr_SetString(PyExc_RuntimeError,
1599 "lost sys.stdout");
Guido van Rossum3165fe61992-09-25 21:59:05 +00001600 }
Barry Warsaw23c9ec82000-08-21 15:44:01 +00001601 if (w != NULL) {
1602 err = PyFile_WriteString("\n", w);
1603 if (err == 0)
1604 PyFile_SoftSpace(w, 0);
1605 }
1606 Py_XDECREF(stream);
1607 stream = NULL;
Guido van Rossum374a9221991-04-04 10:40:29 +00001608 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001609
Thomas Wouters434d0822000-08-24 20:11:32 +00001610
1611#ifdef CASE_TOO_BIG
1612 default: switch (opcode) {
1613#endif
Guido van Rossumf10570b1995-07-07 22:53:21 +00001614 case RAISE_VARARGS:
1615 u = v = w = NULL;
1616 switch (oparg) {
1617 case 3:
1618 u = POP(); /* traceback */
Guido van Rossumf10570b1995-07-07 22:53:21 +00001619 /* Fallthrough */
1620 case 2:
1621 v = POP(); /* value */
1622 /* Fallthrough */
1623 case 1:
1624 w = POP(); /* exc */
Guido van Rossumd295f121998-04-09 21:39:57 +00001625 case 0: /* Fallthrough */
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00001626 why = do_raise(w, v, u);
Guido van Rossumf10570b1995-07-07 22:53:21 +00001627 break;
1628 default:
Guido van Rossumb209a111997-04-29 18:18:01 +00001629 PyErr_SetString(PyExc_SystemError,
Guido van Rossumf10570b1995-07-07 22:53:21 +00001630 "bad RAISE_VARARGS oparg");
Guido van Rossumf10570b1995-07-07 22:53:21 +00001631 why = WHY_EXCEPTION;
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00001632 break;
1633 }
Guido van Rossum374a9221991-04-04 10:40:29 +00001634 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001635
Guido van Rossum374a9221991-04-04 10:40:29 +00001636 case LOAD_LOCALS:
Raymond Hettinger467a6982004-04-07 11:39:21 +00001637 if ((x = f->f_locals) != NULL) {
1638 Py_INCREF(x);
1639 PUSH(x);
1640 continue;
Guido van Rossum681d79a1995-07-18 14:51:37 +00001641 }
Raymond Hettinger467a6982004-04-07 11:39:21 +00001642 PyErr_SetString(PyExc_SystemError, "no locals");
Guido van Rossum374a9221991-04-04 10:40:29 +00001643 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001644
Guido van Rossum374a9221991-04-04 10:40:29 +00001645 case RETURN_VALUE:
1646 retval = POP();
1647 why = WHY_RETURN;
Raymond Hettinger1dd83092004-02-06 18:32:33 +00001648 goto fast_block_end;
Guido van Rossumdb3165e1993-10-18 17:06:59 +00001649
Tim Peters5ca576e2001-06-18 22:08:13 +00001650 case YIELD_VALUE:
1651 retval = POP();
Tim Peters8c963692001-06-23 05:26:56 +00001652 f->f_stacktop = stack_pointer;
Tim Peters5ca576e2001-06-18 22:08:13 +00001653 why = WHY_YIELD;
Raymond Hettinger1dd83092004-02-06 18:32:33 +00001654 goto fast_yield;
Tim Peters5ca576e2001-06-18 22:08:13 +00001655
Guido van Rossumdb3165e1993-10-18 17:06:59 +00001656 case EXEC_STMT:
Raymond Hettinger663004b2003-01-09 15:24:30 +00001657 w = TOP();
1658 v = SECOND();
1659 u = THIRD();
1660 STACKADJ(-3);
Michael W. Hudson75eabd22005-01-18 15:56:11 +00001661 READ_TIMESTAMP(intr0);
Guido van Rossuma027efa1997-05-05 20:56:21 +00001662 err = exec_statement(f, u, v, w);
Michael W. Hudson75eabd22005-01-18 15:56:11 +00001663 READ_TIMESTAMP(intr1);
Guido van Rossumb209a111997-04-29 18:18:01 +00001664 Py_DECREF(u);
1665 Py_DECREF(v);
1666 Py_DECREF(w);
Guido van Rossumdb3165e1993-10-18 17:06:59 +00001667 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001668
Guido van Rossum374a9221991-04-04 10:40:29 +00001669 case POP_BLOCK:
1670 {
Guido van Rossumb209a111997-04-29 18:18:01 +00001671 PyTryBlock *b = PyFrame_BlockPop(f);
Guido van Rossum374a9221991-04-04 10:40:29 +00001672 while (STACK_LEVEL() > b->b_level) {
1673 v = POP();
Guido van Rossumb209a111997-04-29 18:18:01 +00001674 Py_DECREF(v);
Guido van Rossum374a9221991-04-04 10:40:29 +00001675 }
1676 }
Raymond Hettinger7eddd782004-04-07 14:38:08 +00001677 continue;
Guido van Rossumac7be682001-01-17 15:42:30 +00001678
Guido van Rossum374a9221991-04-04 10:40:29 +00001679 case END_FINALLY:
1680 v = POP();
Guido van Rossumb209a111997-04-29 18:18:01 +00001681 if (PyInt_Check(v)) {
Raymond Hettinger7c958652004-04-06 10:11:10 +00001682 why = (enum why_code) PyInt_AS_LONG(v);
Tim Peters8a5c3c72004-04-05 19:36:21 +00001683 assert(why != WHY_YIELD);
Raymond Hettingerc8aa08b2004-04-11 14:59:33 +00001684 if (why == WHY_RETURN ||
1685 why == WHY_CONTINUE)
Guido van Rossum374a9221991-04-04 10:40:29 +00001686 retval = POP();
1687 }
Raymond Hettingerd3b836d2004-04-07 13:17:27 +00001688 else if (PyClass_Check(v) || PyString_Check(v)) {
Guido van Rossum374a9221991-04-04 10:40:29 +00001689 w = POP();
Guido van Rossumf10570b1995-07-07 22:53:21 +00001690 u = POP();
Guido van Rossumb209a111997-04-29 18:18:01 +00001691 PyErr_Restore(v, w, u);
Guido van Rossum374a9221991-04-04 10:40:29 +00001692 why = WHY_RERAISE;
Guido van Rossum0db1ef91995-07-28 23:06:00 +00001693 break;
Guido van Rossum374a9221991-04-04 10:40:29 +00001694 }
Guido van Rossumb209a111997-04-29 18:18:01 +00001695 else if (v != Py_None) {
1696 PyErr_SetString(PyExc_SystemError,
Guido van Rossum374a9221991-04-04 10:40:29 +00001697 "'finally' pops bad exception");
1698 why = WHY_EXCEPTION;
1699 }
Guido van Rossumb209a111997-04-29 18:18:01 +00001700 Py_DECREF(v);
Guido van Rossum374a9221991-04-04 10:40:29 +00001701 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001702
Guido van Rossum374a9221991-04-04 10:40:29 +00001703 case BUILD_CLASS:
Raymond Hettinger663004b2003-01-09 15:24:30 +00001704 u = TOP();
1705 v = SECOND();
1706 w = THIRD();
1707 STACKADJ(-2);
Guido van Rossum25831651993-05-19 14:50:45 +00001708 x = build_class(u, v, w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001709 SET_TOP(x);
Guido van Rossumb209a111997-04-29 18:18:01 +00001710 Py_DECREF(u);
1711 Py_DECREF(v);
1712 Py_DECREF(w);
Guido van Rossum374a9221991-04-04 10:40:29 +00001713 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001714
Guido van Rossum374a9221991-04-04 10:40:29 +00001715 case STORE_NAME:
Skip Montanaro496e6582002-08-06 17:47:40 +00001716 w = GETITEM(names, oparg);
Guido van Rossum374a9221991-04-04 10:40:29 +00001717 v = POP();
Raymond Hettinger467a6982004-04-07 11:39:21 +00001718 if ((x = f->f_locals) != NULL) {
Raymond Hettinger66bd2332004-08-02 08:30:07 +00001719 if (PyDict_CheckExact(x))
Raymond Hettinger214b1c32004-07-02 06:41:07 +00001720 err = PyDict_SetItem(x, w, v);
1721 else
1722 err = PyObject_SetItem(x, w, v);
Raymond Hettinger467a6982004-04-07 11:39:21 +00001723 Py_DECREF(v);
Raymond Hettinger7eddd782004-04-07 14:38:08 +00001724 if (err == 0) continue;
Guido van Rossum681d79a1995-07-18 14:51:37 +00001725 break;
1726 }
Raymond Hettinger467a6982004-04-07 11:39:21 +00001727 PyErr_Format(PyExc_SystemError,
1728 "no locals found when storing %s",
1729 PyObject_REPR(w));
Guido van Rossum374a9221991-04-04 10:40:29 +00001730 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001731
Guido van Rossum374a9221991-04-04 10:40:29 +00001732 case DELETE_NAME:
Skip Montanaro496e6582002-08-06 17:47:40 +00001733 w = GETITEM(names, oparg);
Raymond Hettinger467a6982004-04-07 11:39:21 +00001734 if ((x = f->f_locals) != NULL) {
Raymond Hettinger214b1c32004-07-02 06:41:07 +00001735 if ((err = PyObject_DelItem(x, w)) != 0)
Raymond Hettinger467a6982004-04-07 11:39:21 +00001736 format_exc_check_arg(PyExc_NameError,
1737 NAME_ERROR_MSG ,w);
Guido van Rossum681d79a1995-07-18 14:51:37 +00001738 break;
1739 }
Raymond Hettinger467a6982004-04-07 11:39:21 +00001740 PyErr_Format(PyExc_SystemError,
1741 "no locals when deleting %s",
1742 PyObject_REPR(w));
Guido van Rossum374a9221991-04-04 10:40:29 +00001743 break;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001744
Raymond Hettinger7dc52212003-03-16 20:14:44 +00001745 PREDICTED_WITH_ARG(UNPACK_SEQUENCE);
Thomas Wouters0be5aab2000-08-11 22:15:52 +00001746 case UNPACK_SEQUENCE:
Guido van Rossum374a9221991-04-04 10:40:29 +00001747 v = POP();
Raymond Hettingerf114a3a2004-03-08 23:25:30 +00001748 if (PyTuple_CheckExact(v) && PyTuple_GET_SIZE(v) == oparg) {
1749 PyObject **items = ((PyTupleObject *)v)->ob_item;
1750 while (oparg--) {
1751 w = items[oparg];
1752 Py_INCREF(w);
1753 PUSH(w);
Barry Warsawe42b18f1997-08-25 22:13:04 +00001754 }
Raymond Hettinger7eddd782004-04-07 14:38:08 +00001755 Py_DECREF(v);
1756 continue;
Raymond Hettingerf114a3a2004-03-08 23:25:30 +00001757 } else if (PyList_CheckExact(v) && PyList_GET_SIZE(v) == oparg) {
1758 PyObject **items = ((PyListObject *)v)->ob_item;
1759 while (oparg--) {
1760 w = items[oparg];
1761 Py_INCREF(w);
1762 PUSH(w);
Barry Warsawe42b18f1997-08-25 22:13:04 +00001763 }
Raymond Hettingerf114a3a2004-03-08 23:25:30 +00001764 } else if (unpack_iterable(v, oparg,
Tim Petersd6d010b2001-06-21 02:49:55 +00001765 stack_pointer + oparg))
1766 stack_pointer += oparg;
Tim Peters8b13b3e2001-09-30 05:58:42 +00001767 else {
1768 if (PyErr_ExceptionMatches(PyExc_TypeError))
1769 PyErr_SetString(PyExc_TypeError,
1770 "unpack non-sequence");
Barry Warsawe42b18f1997-08-25 22:13:04 +00001771 why = WHY_EXCEPTION;
Tim Peters8b13b3e2001-09-30 05:58:42 +00001772 }
Guido van Rossumb209a111997-04-29 18:18:01 +00001773 Py_DECREF(v);
Guido van Rossum374a9221991-04-04 10:40:29 +00001774 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001775
Guido van Rossum374a9221991-04-04 10:40:29 +00001776 case STORE_ATTR:
Skip Montanaro496e6582002-08-06 17:47:40 +00001777 w = GETITEM(names, oparg);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001778 v = TOP();
1779 u = SECOND();
1780 STACKADJ(-2);
Guido van Rossumb209a111997-04-29 18:18:01 +00001781 err = PyObject_SetAttr(v, w, u); /* v.w = u */
1782 Py_DECREF(v);
1783 Py_DECREF(u);
Raymond Hettinger7eddd782004-04-07 14:38:08 +00001784 if (err == 0) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001785 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001786
Guido van Rossum374a9221991-04-04 10:40:29 +00001787 case DELETE_ATTR:
Skip Montanaro496e6582002-08-06 17:47:40 +00001788 w = GETITEM(names, oparg);
Guido van Rossum374a9221991-04-04 10:40:29 +00001789 v = POP();
Guido van Rossuma027efa1997-05-05 20:56:21 +00001790 err = PyObject_SetAttr(v, w, (PyObject *)NULL);
1791 /* del v.w */
Guido van Rossumb209a111997-04-29 18:18:01 +00001792 Py_DECREF(v);
Guido van Rossum374a9221991-04-04 10:40:29 +00001793 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001794
Guido van Rossum32c6cdf1991-12-10 13:52:46 +00001795 case STORE_GLOBAL:
Skip Montanaro496e6582002-08-06 17:47:40 +00001796 w = GETITEM(names, oparg);
Guido van Rossum32c6cdf1991-12-10 13:52:46 +00001797 v = POP();
Guido van Rossumb209a111997-04-29 18:18:01 +00001798 err = PyDict_SetItem(f->f_globals, w, v);
1799 Py_DECREF(v);
Raymond Hettinger7eddd782004-04-07 14:38:08 +00001800 if (err == 0) continue;
Guido van Rossum32c6cdf1991-12-10 13:52:46 +00001801 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001802
Guido van Rossum32c6cdf1991-12-10 13:52:46 +00001803 case DELETE_GLOBAL:
Skip Montanaro496e6582002-08-06 17:47:40 +00001804 w = GETITEM(names, oparg);
Guido van Rossumb209a111997-04-29 18:18:01 +00001805 if ((err = PyDict_DelItem(f->f_globals, w)) != 0)
Paul Prescode68140d2000-08-30 20:25:01 +00001806 format_exc_check_arg(
Jeremy Hylton64949cb2001-01-25 20:06:59 +00001807 PyExc_NameError, GLOBAL_NAME_ERROR_MSG, w);
Guido van Rossum32c6cdf1991-12-10 13:52:46 +00001808 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001809
Guido van Rossum374a9221991-04-04 10:40:29 +00001810 case LOAD_NAME:
Skip Montanaro496e6582002-08-06 17:47:40 +00001811 w = GETITEM(names, oparg);
Raymond Hettinger214b1c32004-07-02 06:41:07 +00001812 if ((v = f->f_locals) == NULL) {
Jeremy Hyltonc862cf42001-01-19 03:25:05 +00001813 PyErr_Format(PyExc_SystemError,
1814 "no locals when loading %s",
Jeremy Hylton483638c2001-02-01 20:20:45 +00001815 PyObject_REPR(w));
Guido van Rossum681d79a1995-07-18 14:51:37 +00001816 break;
1817 }
Michael W. Hudsona3711f72004-08-02 14:50:43 +00001818 if (PyDict_CheckExact(v)) {
Raymond Hettinger214b1c32004-07-02 06:41:07 +00001819 x = PyDict_GetItem(v, w);
Michael W. Hudsona3711f72004-08-02 14:50:43 +00001820 Py_XINCREF(x);
1821 }
Raymond Hettinger214b1c32004-07-02 06:41:07 +00001822 else {
1823 x = PyObject_GetItem(v, w);
1824 if (x == NULL && PyErr_Occurred()) {
1825 if (!PyErr_ExceptionMatches(PyExc_KeyError))
1826 break;
1827 PyErr_Clear();
1828 }
1829 }
Guido van Rossum374a9221991-04-04 10:40:29 +00001830 if (x == NULL) {
Guido van Rossumb209a111997-04-29 18:18:01 +00001831 x = PyDict_GetItem(f->f_globals, w);
Guido van Rossum374a9221991-04-04 10:40:29 +00001832 if (x == NULL) {
Guido van Rossumb209a111997-04-29 18:18:01 +00001833 x = PyDict_GetItem(f->f_builtins, w);
Guido van Rossum374a9221991-04-04 10:40:29 +00001834 if (x == NULL) {
Paul Prescode68140d2000-08-30 20:25:01 +00001835 format_exc_check_arg(
Guido van Rossumac7be682001-01-17 15:42:30 +00001836 PyExc_NameError,
Paul Prescode68140d2000-08-30 20:25:01 +00001837 NAME_ERROR_MSG ,w);
Guido van Rossum374a9221991-04-04 10:40:29 +00001838 break;
1839 }
1840 }
Michael W. Hudsona3711f72004-08-02 14:50:43 +00001841 Py_INCREF(x);
Guido van Rossum374a9221991-04-04 10:40:29 +00001842 }
Guido van Rossum374a9221991-04-04 10:40:29 +00001843 PUSH(x);
Raymond Hettinger467a6982004-04-07 11:39:21 +00001844 continue;
Guido van Rossumac7be682001-01-17 15:42:30 +00001845
Guido van Rossum374a9221991-04-04 10:40:29 +00001846 case LOAD_GLOBAL:
Skip Montanaro496e6582002-08-06 17:47:40 +00001847 w = GETITEM(names, oparg);
Guido van Rossum3a4dfc82002-08-19 20:24:07 +00001848 if (PyString_CheckExact(w)) {
Guido van Rossumd8dbf842002-08-19 21:17:53 +00001849 /* Inline the PyDict_GetItem() calls.
1850 WARNING: this is an extreme speed hack.
1851 Do not try this at home. */
Guido van Rossum3a4dfc82002-08-19 20:24:07 +00001852 long hash = ((PyStringObject *)w)->ob_shash;
1853 if (hash != -1) {
Guido van Rossum3a4dfc82002-08-19 20:24:07 +00001854 PyDictObject *d;
1855 d = (PyDictObject *)(f->f_globals);
1856 x = d->ma_lookup(d, w, hash)->me_value;
1857 if (x != NULL) {
1858 Py_INCREF(x);
1859 PUSH(x);
1860 continue;
1861 }
1862 d = (PyDictObject *)(f->f_builtins);
1863 x = d->ma_lookup(d, w, hash)->me_value;
1864 if (x != NULL) {
1865 Py_INCREF(x);
1866 PUSH(x);
1867 continue;
1868 }
1869 goto load_global_error;
1870 }
1871 }
1872 /* This is the un-inlined version of the code above */
Guido van Rossumb209a111997-04-29 18:18:01 +00001873 x = PyDict_GetItem(f->f_globals, w);
Guido van Rossum374a9221991-04-04 10:40:29 +00001874 if (x == NULL) {
Guido van Rossumb209a111997-04-29 18:18:01 +00001875 x = PyDict_GetItem(f->f_builtins, w);
Guido van Rossum374a9221991-04-04 10:40:29 +00001876 if (x == NULL) {
Guido van Rossum3a4dfc82002-08-19 20:24:07 +00001877 load_global_error:
Paul Prescode68140d2000-08-30 20:25:01 +00001878 format_exc_check_arg(
Guido van Rossumac7be682001-01-17 15:42:30 +00001879 PyExc_NameError,
Guido van Rossum3a4dfc82002-08-19 20:24:07 +00001880 GLOBAL_NAME_ERROR_MSG, w);
Guido van Rossum374a9221991-04-04 10:40:29 +00001881 break;
1882 }
1883 }
Guido van Rossumb209a111997-04-29 18:18:01 +00001884 Py_INCREF(x);
Guido van Rossum374a9221991-04-04 10:40:29 +00001885 PUSH(x);
Raymond Hettinger7eddd782004-04-07 14:38:08 +00001886 continue;
Guido van Rossum681d79a1995-07-18 14:51:37 +00001887
Guido van Rossum8b17d6b1993-03-30 13:18:41 +00001888 case DELETE_FAST:
Guido van Rossum2e4c8991998-05-12 20:27:36 +00001889 x = GETLOCAL(oparg);
Raymond Hettinger467a6982004-04-07 11:39:21 +00001890 if (x != NULL) {
1891 SETLOCAL(oparg, NULL);
1892 continue;
Guido van Rossum2e4c8991998-05-12 20:27:36 +00001893 }
Raymond Hettinger467a6982004-04-07 11:39:21 +00001894 format_exc_check_arg(
1895 PyExc_UnboundLocalError,
1896 UNBOUNDLOCAL_ERROR_MSG,
1897 PyTuple_GetItem(co->co_varnames, oparg)
1898 );
1899 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001900
Jeremy Hylton64949cb2001-01-25 20:06:59 +00001901 case LOAD_CLOSURE:
Jeremy Hylton2b724da2001-01-29 22:51:52 +00001902 x = freevars[oparg];
Jeremy Hylton64949cb2001-01-25 20:06:59 +00001903 Py_INCREF(x);
1904 PUSH(x);
Raymond Hettinger7eddd782004-04-07 14:38:08 +00001905 if (x != NULL) continue;
Jeremy Hylton64949cb2001-01-25 20:06:59 +00001906 break;
1907
1908 case LOAD_DEREF:
Jeremy Hylton2b724da2001-01-29 22:51:52 +00001909 x = freevars[oparg];
Jeremy Hylton64949cb2001-01-25 20:06:59 +00001910 w = PyCell_Get(x);
Raymond Hettinger467a6982004-04-07 11:39:21 +00001911 if (w != NULL) {
1912 PUSH(w);
1913 continue;
Jeremy Hylton2524d692001-02-05 17:23:16 +00001914 }
Raymond Hettinger467a6982004-04-07 11:39:21 +00001915 err = -1;
1916 /* Don't stomp existing exception */
1917 if (PyErr_Occurred())
1918 break;
1919 if (oparg < f->f_ncells) {
1920 v = PyTuple_GetItem(co->co_cellvars,
1921 oparg);
1922 format_exc_check_arg(
1923 PyExc_UnboundLocalError,
1924 UNBOUNDLOCAL_ERROR_MSG,
1925 v);
1926 } else {
1927 v = PyTuple_GetItem(
1928 co->co_freevars,
1929 oparg - f->f_ncells);
1930 format_exc_check_arg(
1931 PyExc_NameError,
1932 UNBOUNDFREE_ERROR_MSG,
1933 v);
1934 }
Jeremy Hylton64949cb2001-01-25 20:06:59 +00001935 break;
1936
1937 case STORE_DEREF:
1938 w = POP();
Jeremy Hylton2b724da2001-01-29 22:51:52 +00001939 x = freevars[oparg];
Jeremy Hylton64949cb2001-01-25 20:06:59 +00001940 PyCell_Set(x, w);
Jeremy Hylton30c9f392001-03-13 01:58:22 +00001941 Py_DECREF(w);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00001942 continue;
1943
Guido van Rossum374a9221991-04-04 10:40:29 +00001944 case BUILD_TUPLE:
Guido van Rossumb209a111997-04-29 18:18:01 +00001945 x = PyTuple_New(oparg);
Guido van Rossum374a9221991-04-04 10:40:29 +00001946 if (x != NULL) {
Raymond Hettinger5bed4562004-04-10 23:34:17 +00001947 for (; --oparg >= 0;) {
Guido van Rossum374a9221991-04-04 10:40:29 +00001948 w = POP();
Guido van Rossumb209a111997-04-29 18:18:01 +00001949 PyTuple_SET_ITEM(x, oparg, w);
Guido van Rossum374a9221991-04-04 10:40:29 +00001950 }
1951 PUSH(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001952 continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001953 }
1954 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001955
Guido van Rossum374a9221991-04-04 10:40:29 +00001956 case BUILD_LIST:
Guido van Rossumb209a111997-04-29 18:18:01 +00001957 x = PyList_New(oparg);
Guido van Rossum374a9221991-04-04 10:40:29 +00001958 if (x != NULL) {
Raymond Hettinger5bed4562004-04-10 23:34:17 +00001959 for (; --oparg >= 0;) {
Guido van Rossum374a9221991-04-04 10:40:29 +00001960 w = POP();
Guido van Rossum5053efc1998-08-04 15:27:50 +00001961 PyList_SET_ITEM(x, oparg, w);
Guido van Rossum374a9221991-04-04 10:40:29 +00001962 }
1963 PUSH(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001964 continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001965 }
1966 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001967
Guido van Rossum374a9221991-04-04 10:40:29 +00001968 case BUILD_MAP:
Guido van Rossumb209a111997-04-29 18:18:01 +00001969 x = PyDict_New();
Guido van Rossum374a9221991-04-04 10:40:29 +00001970 PUSH(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001971 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001972 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001973
Guido van Rossum374a9221991-04-04 10:40:29 +00001974 case LOAD_ATTR:
Skip Montanaro496e6582002-08-06 17:47:40 +00001975 w = GETITEM(names, oparg);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001976 v = TOP();
Guido van Rossumb209a111997-04-29 18:18:01 +00001977 x = PyObject_GetAttr(v, w);
1978 Py_DECREF(v);
Raymond Hettinger663004b2003-01-09 15:24:30 +00001979 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001980 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001981 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00001982
Guido van Rossum374a9221991-04-04 10:40:29 +00001983 case COMPARE_OP:
1984 w = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00001985 v = TOP();
Raymond Hettinger4bad9ba2003-01-19 05:08:13 +00001986 if (PyInt_CheckExact(w) && PyInt_CheckExact(v)) {
Guido van Rossumc12da691997-07-17 23:12:42 +00001987 /* INLINE: cmp(int, int) */
1988 register long a, b;
1989 register int res;
Guido van Rossumcf183ac1998-12-04 18:51:36 +00001990 a = PyInt_AS_LONG(v);
1991 b = PyInt_AS_LONG(w);
Guido van Rossumc12da691997-07-17 23:12:42 +00001992 switch (oparg) {
Martin v. Löwis7198a522002-01-01 19:59:11 +00001993 case PyCmp_LT: res = a < b; break;
1994 case PyCmp_LE: res = a <= b; break;
1995 case PyCmp_EQ: res = a == b; break;
1996 case PyCmp_NE: res = a != b; break;
1997 case PyCmp_GT: res = a > b; break;
1998 case PyCmp_GE: res = a >= b; break;
1999 case PyCmp_IS: res = v == w; break;
2000 case PyCmp_IS_NOT: res = v != w; break;
Guido van Rossumc12da691997-07-17 23:12:42 +00002001 default: goto slow_compare;
2002 }
2003 x = res ? Py_True : Py_False;
2004 Py_INCREF(x);
2005 }
2006 else {
2007 slow_compare:
2008 x = cmp_outcome(oparg, v, w);
2009 }
Guido van Rossumb209a111997-04-29 18:18:01 +00002010 Py_DECREF(v);
2011 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00002012 SET_TOP(x);
Raymond Hettingerf606f872003-03-16 03:11:04 +00002013 if (x == NULL) break;
2014 PREDICT(JUMP_IF_FALSE);
2015 PREDICT(JUMP_IF_TRUE);
2016 continue;
Guido van Rossumac7be682001-01-17 15:42:30 +00002017
Guido van Rossum374a9221991-04-04 10:40:29 +00002018 case IMPORT_NAME:
Skip Montanaro496e6582002-08-06 17:47:40 +00002019 w = GETITEM(names, oparg);
Guido van Rossumb209a111997-04-29 18:18:01 +00002020 x = PyDict_GetItemString(f->f_builtins, "__import__");
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002021 if (x == NULL) {
Guido van Rossumb209a111997-04-29 18:18:01 +00002022 PyErr_SetString(PyExc_ImportError,
Guido van Rossumfc490731997-05-06 15:06:49 +00002023 "__import__ not found");
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002024 break;
2025 }
Thomas Woutersf7f438b2006-02-28 16:09:29 +00002026 v = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00002027 u = TOP();
Thomas Woutersf7f438b2006-02-28 16:09:29 +00002028 if (PyInt_AsLong(u) != -1 || PyErr_Occurred())
2029 w = PyTuple_Pack(5,
2030 w,
2031 f->f_globals,
2032 f->f_locals == NULL ?
2033 Py_None : f->f_locals,
2034 v,
2035 u);
2036 else
2037 w = PyTuple_Pack(4,
2038 w,
2039 f->f_globals,
2040 f->f_locals == NULL ?
2041 Py_None : f->f_locals,
2042 v);
2043 Py_DECREF(v);
Guido van Rossumb209a111997-04-29 18:18:01 +00002044 Py_DECREF(u);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002045 if (w == NULL) {
Raymond Hettinger663004b2003-01-09 15:24:30 +00002046 u = POP();
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002047 x = NULL;
2048 break;
2049 }
Michael W. Hudson75eabd22005-01-18 15:56:11 +00002050 READ_TIMESTAMP(intr0);
Guido van Rossumb209a111997-04-29 18:18:01 +00002051 x = PyEval_CallObject(x, w);
Michael W. Hudson75eabd22005-01-18 15:56:11 +00002052 READ_TIMESTAMP(intr1);
Guido van Rossumb209a111997-04-29 18:18:01 +00002053 Py_DECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00002054 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00002055 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00002056 break;
Guido van Rossumac7be682001-01-17 15:42:30 +00002057
Thomas Wouters52152252000-08-17 22:55:00 +00002058 case IMPORT_STAR:
2059 v = POP();
Guido van Rossumb209a111997-04-29 18:18:01 +00002060 PyFrame_FastToLocals(f);
Guido van Rossum681d79a1995-07-18 14:51:37 +00002061 if ((x = f->f_locals) == NULL) {
Guido van Rossuma027efa1997-05-05 20:56:21 +00002062 PyErr_SetString(PyExc_SystemError,
Jeremy Hyltonc862cf42001-01-19 03:25:05 +00002063 "no locals found during 'import *'");
Guido van Rossum681d79a1995-07-18 14:51:37 +00002064 break;
2065 }
Michael W. Hudson75eabd22005-01-18 15:56:11 +00002066 READ_TIMESTAMP(intr0);
Thomas Wouters52152252000-08-17 22:55:00 +00002067 err = import_all_from(x, v);
Michael W. Hudson75eabd22005-01-18 15:56:11 +00002068 READ_TIMESTAMP(intr1);
Guido van Rossumb209a111997-04-29 18:18:01 +00002069 PyFrame_LocalsToFast(f, 0);
Thomas Wouters52152252000-08-17 22:55:00 +00002070 Py_DECREF(v);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00002071 if (err == 0) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00002072 break;
Guido van Rossum25831651993-05-19 14:50:45 +00002073
Thomas Wouters52152252000-08-17 22:55:00 +00002074 case IMPORT_FROM:
Skip Montanaro496e6582002-08-06 17:47:40 +00002075 w = GETITEM(names, oparg);
Thomas Wouters52152252000-08-17 22:55:00 +00002076 v = TOP();
Michael W. Hudson75eabd22005-01-18 15:56:11 +00002077 READ_TIMESTAMP(intr0);
Thomas Wouters52152252000-08-17 22:55:00 +00002078 x = import_from(v, w);
Michael W. Hudson75eabd22005-01-18 15:56:11 +00002079 READ_TIMESTAMP(intr1);
Thomas Wouters52152252000-08-17 22:55:00 +00002080 PUSH(x);
2081 if (x != NULL) continue;
2082 break;
2083
Guido van Rossum374a9221991-04-04 10:40:29 +00002084 case JUMP_FORWARD:
2085 JUMPBY(oparg);
Neil Schemenauerc4b570f2003-06-01 19:21:12 +00002086 goto fast_next_opcode;
Guido van Rossumac7be682001-01-17 15:42:30 +00002087
Raymond Hettingerf606f872003-03-16 03:11:04 +00002088 PREDICTED_WITH_ARG(JUMP_IF_FALSE);
Guido van Rossum374a9221991-04-04 10:40:29 +00002089 case JUMP_IF_FALSE:
Raymond Hettinger21012b82003-02-26 18:11:50 +00002090 w = TOP();
Raymond Hettingerf606f872003-03-16 03:11:04 +00002091 if (w == Py_True) {
2092 PREDICT(POP_TOP);
Neil Schemenauerc4b570f2003-06-01 19:21:12 +00002093 goto fast_next_opcode;
Raymond Hettingerf606f872003-03-16 03:11:04 +00002094 }
Raymond Hettinger21012b82003-02-26 18:11:50 +00002095 if (w == Py_False) {
2096 JUMPBY(oparg);
Neil Schemenauerc4b570f2003-06-01 19:21:12 +00002097 goto fast_next_opcode;
Raymond Hettinger21012b82003-02-26 18:11:50 +00002098 }
2099 err = PyObject_IsTrue(w);
Guido van Rossum04691fc1992-08-12 15:35:34 +00002100 if (err > 0)
2101 err = 0;
2102 else if (err == 0)
Guido van Rossum374a9221991-04-04 10:40:29 +00002103 JUMPBY(oparg);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00002104 else
2105 break;
2106 continue;
Guido van Rossumac7be682001-01-17 15:42:30 +00002107
Raymond Hettingerf606f872003-03-16 03:11:04 +00002108 PREDICTED_WITH_ARG(JUMP_IF_TRUE);
Guido van Rossum374a9221991-04-04 10:40:29 +00002109 case JUMP_IF_TRUE:
Raymond Hettinger21012b82003-02-26 18:11:50 +00002110 w = TOP();
Raymond Hettingerf606f872003-03-16 03:11:04 +00002111 if (w == Py_False) {
2112 PREDICT(POP_TOP);
Neil Schemenauerc4b570f2003-06-01 19:21:12 +00002113 goto fast_next_opcode;
Raymond Hettingerf606f872003-03-16 03:11:04 +00002114 }
Raymond Hettinger21012b82003-02-26 18:11:50 +00002115 if (w == Py_True) {
2116 JUMPBY(oparg);
Neil Schemenauerc4b570f2003-06-01 19:21:12 +00002117 goto fast_next_opcode;
Raymond Hettinger21012b82003-02-26 18:11:50 +00002118 }
2119 err = PyObject_IsTrue(w);
Guido van Rossum04691fc1992-08-12 15:35:34 +00002120 if (err > 0) {
2121 err = 0;
Guido van Rossum374a9221991-04-04 10:40:29 +00002122 JUMPBY(oparg);
Guido van Rossum04691fc1992-08-12 15:35:34 +00002123 }
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00002124 else if (err == 0)
2125 ;
2126 else
2127 break;
2128 continue;
Guido van Rossumac7be682001-01-17 15:42:30 +00002129
Raymond Hettingerfba1cfc2004-03-12 16:33:17 +00002130 PREDICTED_WITH_ARG(JUMP_ABSOLUTE);
Guido van Rossum374a9221991-04-04 10:40:29 +00002131 case JUMP_ABSOLUTE:
2132 JUMPTO(oparg);
Neil Schemenauerca2a2f12003-05-30 23:59:44 +00002133 continue;
Guido van Rossumac7be682001-01-17 15:42:30 +00002134
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002135 case GET_ITER:
2136 /* before: [obj]; after [getiter(obj)] */
Raymond Hettinger663004b2003-01-09 15:24:30 +00002137 v = TOP();
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002138 x = PyObject_GetIter(v);
2139 Py_DECREF(v);
2140 if (x != NULL) {
Raymond Hettinger663004b2003-01-09 15:24:30 +00002141 SET_TOP(x);
Raymond Hettinger7dc52212003-03-16 20:14:44 +00002142 PREDICT(FOR_ITER);
Guido van Rossum213c7a62001-04-23 14:08:49 +00002143 continue;
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002144 }
Raymond Hettinger8bb90a52003-01-14 12:43:10 +00002145 STACKADJ(-1);
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002146 break;
2147
Raymond Hettinger7dc52212003-03-16 20:14:44 +00002148 PREDICTED_WITH_ARG(FOR_ITER);
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002149 case FOR_ITER:
2150 /* before: [iter]; after: [iter, iter()] *or* [] */
2151 v = TOP();
Raymond Hettingerdb0de9e2004-03-12 08:41:36 +00002152 x = (*v->ob_type->tp_iternext)(v);
Guido van Rossum213c7a62001-04-23 14:08:49 +00002153 if (x != NULL) {
2154 PUSH(x);
Raymond Hettinger7dc52212003-03-16 20:14:44 +00002155 PREDICT(STORE_FAST);
2156 PREDICT(UNPACK_SEQUENCE);
Guido van Rossum213c7a62001-04-23 14:08:49 +00002157 continue;
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002158 }
Raymond Hettingerdb0de9e2004-03-12 08:41:36 +00002159 if (PyErr_Occurred()) {
2160 if (!PyErr_ExceptionMatches(PyExc_StopIteration))
2161 break;
2162 PyErr_Clear();
Guido van Rossum213c7a62001-04-23 14:08:49 +00002163 }
Raymond Hettingerdb0de9e2004-03-12 08:41:36 +00002164 /* iterator ended normally */
2165 x = v = POP();
2166 Py_DECREF(v);
2167 JUMPBY(oparg);
2168 continue;
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002169
Raymond Hettinger2d783e92004-03-12 09:12:22 +00002170 case BREAK_LOOP:
2171 why = WHY_BREAK;
2172 goto fast_block_end;
2173
2174 case CONTINUE_LOOP:
2175 retval = PyInt_FromLong(oparg);
2176 why = WHY_CONTINUE;
2177 goto fast_block_end;
2178
Guido van Rossum374a9221991-04-04 10:40:29 +00002179 case SETUP_LOOP:
2180 case SETUP_EXCEPT:
2181 case SETUP_FINALLY:
Guido van Rossumb209a111997-04-29 18:18:01 +00002182 PyFrame_BlockSetup(f, opcode, INSTR_OFFSET() + oparg,
Jeremy Hylton3faa52e2001-02-01 22:48:12 +00002183 STACK_LEVEL());
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00002184 continue;
Guido van Rossumac7be682001-01-17 15:42:30 +00002185
Guido van Rossumc2e20742006-02-27 22:32:47 +00002186 case WITH_CLEANUP:
2187 {
2188 /* TOP is the context.__exit__ bound method.
2189 Below that are 1-3 values indicating how/why
2190 we entered the finally clause:
2191 - SECOND = None
2192 - (SECOND, THIRD) = (WHY_RETURN or WHY_CONTINUE), retval
2193 - SECOND = WHY_*; no retval below it
2194 - (SECOND, THIRD, FOURTH) = exc_info()
2195 In the last case, we must call
2196 TOP(SECOND, THIRD, FOURTH)
2197 otherwise we must call
2198 TOP(None, None, None)
2199 but we must preserve the stack entries below TOP.
2200 The code here just sets the stack up for the call;
2201 separate CALL_FUNCTION(3) and POP_TOP opcodes are
2202 emitted by the compiler.
Guido van Rossum1a5e21e2006-02-28 21:57:43 +00002203
2204 In addition, if the stack represents an exception,
2205 we "zap" this information; __exit__() should
2206 re-raise the exception if it wants to, and if
2207 __exit__() returns normally, END_FINALLY should
2208 *not* re-raise the exception. (But non-local
2209 gotos should still be resumed.)
Guido van Rossumc2e20742006-02-27 22:32:47 +00002210 */
2211
2212 x = TOP();
2213 u = SECOND();
2214 if (PyInt_Check(u) || u == Py_None) {
2215 u = v = w = Py_None;
Guido van Rossum1a5e21e2006-02-28 21:57:43 +00002216 Py_INCREF(u);
2217 Py_INCREF(v);
2218 Py_INCREF(w);
Guido van Rossumc2e20742006-02-27 22:32:47 +00002219 }
2220 else {
2221 v = THIRD();
2222 w = FOURTH();
Guido van Rossum1a5e21e2006-02-28 21:57:43 +00002223 /* Zap the exception from the stack,
2224 to fool END_FINALLY. */
2225 STACKADJ(-2);
2226 SET_TOP(x);
2227 Py_INCREF(Py_None);
2228 SET_SECOND(Py_None);
Guido van Rossumc2e20742006-02-27 22:32:47 +00002229 }
Guido van Rossum1a5e21e2006-02-28 21:57:43 +00002230 STACKADJ(3);
2231 SET_THIRD(u);
2232 SET_SECOND(v);
2233 SET_TOP(w);
Guido van Rossumc2e20742006-02-27 22:32:47 +00002234 break;
2235 }
2236
Guido van Rossumf10570b1995-07-07 22:53:21 +00002237 case CALL_FUNCTION:
Armin Rigo8817fcd2004-06-17 10:22:40 +00002238 {
2239 PyObject **sp;
Jeremy Hylton985eba52003-02-05 23:13:00 +00002240 PCALL(PCALL_ALL);
Armin Rigo8817fcd2004-06-17 10:22:40 +00002241 sp = stack_pointer;
Martin v. Löwisf30d60e2004-06-08 08:17:44 +00002242#ifdef WITH_TSC
Armin Rigo8817fcd2004-06-17 10:22:40 +00002243 x = call_function(&sp, oparg, &intr0, &intr1);
Martin v. Löwisf30d60e2004-06-08 08:17:44 +00002244#else
Armin Rigo8817fcd2004-06-17 10:22:40 +00002245 x = call_function(&sp, oparg);
Martin v. Löwisf30d60e2004-06-08 08:17:44 +00002246#endif
Armin Rigo8817fcd2004-06-17 10:22:40 +00002247 stack_pointer = sp;
Jeremy Hyltone8c04322002-08-16 17:47:26 +00002248 PUSH(x);
2249 if (x != NULL)
2250 continue;
2251 break;
Armin Rigo8817fcd2004-06-17 10:22:40 +00002252 }
Guido van Rossumac7be682001-01-17 15:42:30 +00002253
Jeremy Hylton76901512000-03-28 23:49:17 +00002254 case CALL_FUNCTION_VAR:
2255 case CALL_FUNCTION_KW:
2256 case CALL_FUNCTION_VAR_KW:
Guido van Rossumf10570b1995-07-07 22:53:21 +00002257 {
Jeremy Hylton76901512000-03-28 23:49:17 +00002258 int na = oparg & 0xff;
2259 int nk = (oparg>>8) & 0xff;
2260 int flags = (opcode - CALL_FUNCTION) & 3;
Jeremy Hylton52820442001-01-03 23:52:36 +00002261 int n = na + 2 * nk;
Armin Rigo8817fcd2004-06-17 10:22:40 +00002262 PyObject **pfunc, *func, **sp;
Jeremy Hylton985eba52003-02-05 23:13:00 +00002263 PCALL(PCALL_ALL);
Jeremy Hylton52820442001-01-03 23:52:36 +00002264 if (flags & CALL_FLAG_VAR)
2265 n++;
2266 if (flags & CALL_FLAG_KW)
2267 n++;
2268 pfunc = stack_pointer - n - 1;
2269 func = *pfunc;
Jeremy Hylton52820442001-01-03 23:52:36 +00002270
Guido van Rossumac7be682001-01-17 15:42:30 +00002271 if (PyMethod_Check(func)
Jeremy Hylton52820442001-01-03 23:52:36 +00002272 && PyMethod_GET_SELF(func) != NULL) {
2273 PyObject *self = PyMethod_GET_SELF(func);
Jeremy Hylton76901512000-03-28 23:49:17 +00002274 Py_INCREF(self);
Jeremy Hylton52820442001-01-03 23:52:36 +00002275 func = PyMethod_GET_FUNCTION(func);
2276 Py_INCREF(func);
Jeremy Hylton76901512000-03-28 23:49:17 +00002277 Py_DECREF(*pfunc);
2278 *pfunc = self;
2279 na++;
2280 n++;
Guido van Rossumac7be682001-01-17 15:42:30 +00002281 } else
Jeremy Hylton52820442001-01-03 23:52:36 +00002282 Py_INCREF(func);
Armin Rigo8817fcd2004-06-17 10:22:40 +00002283 sp = stack_pointer;
Michael W. Hudson75eabd22005-01-18 15:56:11 +00002284 READ_TIMESTAMP(intr0);
Armin Rigo8817fcd2004-06-17 10:22:40 +00002285 x = ext_do_call(func, &sp, flags, na, nk);
Michael W. Hudson75eabd22005-01-18 15:56:11 +00002286 READ_TIMESTAMP(intr1);
Armin Rigo8817fcd2004-06-17 10:22:40 +00002287 stack_pointer = sp;
Jeremy Hylton76901512000-03-28 23:49:17 +00002288 Py_DECREF(func);
Jeremy Hylton52820442001-01-03 23:52:36 +00002289
Jeremy Hylton76901512000-03-28 23:49:17 +00002290 while (stack_pointer > pfunc) {
Jeremy Hylton52820442001-01-03 23:52:36 +00002291 w = POP();
2292 Py_DECREF(w);
Jeremy Hylton76901512000-03-28 23:49:17 +00002293 }
2294 PUSH(x);
Guido van Rossumac7be682001-01-17 15:42:30 +00002295 if (x != NULL)
Jeremy Hylton52820442001-01-03 23:52:36 +00002296 continue;
Jeremy Hylton76901512000-03-28 23:49:17 +00002297 break;
Guido van Rossumf10570b1995-07-07 22:53:21 +00002298 }
Guido van Rossumac7be682001-01-17 15:42:30 +00002299
Guido van Rossum681d79a1995-07-18 14:51:37 +00002300 case MAKE_FUNCTION:
2301 v = POP(); /* code object */
Guido van Rossumb209a111997-04-29 18:18:01 +00002302 x = PyFunction_New(v, f->f_globals);
2303 Py_DECREF(v);
Guido van Rossum681d79a1995-07-18 14:51:37 +00002304 /* XXX Maybe this should be a separate opcode? */
2305 if (x != NULL && oparg > 0) {
Guido van Rossumb209a111997-04-29 18:18:01 +00002306 v = PyTuple_New(oparg);
Guido van Rossum681d79a1995-07-18 14:51:37 +00002307 if (v == NULL) {
Guido van Rossumb209a111997-04-29 18:18:01 +00002308 Py_DECREF(x);
Guido van Rossum681d79a1995-07-18 14:51:37 +00002309 x = NULL;
2310 break;
2311 }
Raymond Hettinger5bed4562004-04-10 23:34:17 +00002312 while (--oparg >= 0) {
Guido van Rossum681d79a1995-07-18 14:51:37 +00002313 w = POP();
Guido van Rossumb209a111997-04-29 18:18:01 +00002314 PyTuple_SET_ITEM(v, oparg, w);
Guido van Rossum681d79a1995-07-18 14:51:37 +00002315 }
2316 err = PyFunction_SetDefaults(x, v);
Guido van Rossumb209a111997-04-29 18:18:01 +00002317 Py_DECREF(v);
Guido van Rossum681d79a1995-07-18 14:51:37 +00002318 }
2319 PUSH(x);
2320 break;
Guido van Rossum8861b741996-07-30 16:49:37 +00002321
Jeremy Hylton64949cb2001-01-25 20:06:59 +00002322 case MAKE_CLOSURE:
2323 {
Jeremy Hylton64949cb2001-01-25 20:06:59 +00002324 v = POP(); /* code object */
2325 x = PyFunction_New(v, f->f_globals);
Jeremy Hylton64949cb2001-01-25 20:06:59 +00002326 Py_DECREF(v);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00002327 if (x != NULL) {
2328 v = POP();
Jeremy Hylton64949cb2001-01-25 20:06:59 +00002329 err = PyFunction_SetClosure(x, v);
2330 Py_DECREF(v);
2331 }
2332 if (x != NULL && oparg > 0) {
2333 v = PyTuple_New(oparg);
2334 if (v == NULL) {
2335 Py_DECREF(x);
2336 x = NULL;
2337 break;
2338 }
Raymond Hettinger5bed4562004-04-10 23:34:17 +00002339 while (--oparg >= 0) {
Jeremy Hylton64949cb2001-01-25 20:06:59 +00002340 w = POP();
2341 PyTuple_SET_ITEM(v, oparg, w);
2342 }
2343 err = PyFunction_SetDefaults(x, v);
2344 Py_DECREF(v);
2345 }
2346 PUSH(x);
2347 break;
2348 }
2349
Guido van Rossum8861b741996-07-30 16:49:37 +00002350 case BUILD_SLICE:
2351 if (oparg == 3)
2352 w = POP();
2353 else
2354 w = NULL;
2355 v = POP();
Raymond Hettinger663004b2003-01-09 15:24:30 +00002356 u = TOP();
Guido van Rossum1aa14831997-01-21 05:34:20 +00002357 x = PySlice_New(u, v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +00002358 Py_DECREF(u);
2359 Py_DECREF(v);
2360 Py_XDECREF(w);
Raymond Hettinger663004b2003-01-09 15:24:30 +00002361 SET_TOP(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00002362 if (x != NULL) continue;
Guido van Rossum8861b741996-07-30 16:49:37 +00002363 break;
2364
Fred Drakeef8ace32000-08-24 00:32:09 +00002365 case EXTENDED_ARG:
2366 opcode = NEXTOP();
Raymond Hettinger5bed4562004-04-10 23:34:17 +00002367 oparg = oparg<<16 | NEXTARG();
Fred Drakeef8ace32000-08-24 00:32:09 +00002368 goto dispatch_opcode;
Guido van Rossum8861b741996-07-30 16:49:37 +00002369
Guido van Rossum374a9221991-04-04 10:40:29 +00002370 default:
2371 fprintf(stderr,
2372 "XXX lineno: %d, opcode: %d\n",
Michael W. Hudsondd32a912002-08-15 14:59:02 +00002373 PyCode_Addr2Line(f->f_code, f->f_lasti),
2374 opcode);
Guido van Rossumb209a111997-04-29 18:18:01 +00002375 PyErr_SetString(PyExc_SystemError, "unknown opcode");
Guido van Rossum374a9221991-04-04 10:40:29 +00002376 why = WHY_EXCEPTION;
2377 break;
Guido van Rossum04691fc1992-08-12 15:35:34 +00002378
2379#ifdef CASE_TOO_BIG
2380 }
2381#endif
2382
Guido van Rossum374a9221991-04-04 10:40:29 +00002383 } /* switch */
2384
2385 on_error:
Guido van Rossumac7be682001-01-17 15:42:30 +00002386
Michael W. Hudson75eabd22005-01-18 15:56:11 +00002387 READ_TIMESTAMP(inst1);
Martin v. Löwisf30d60e2004-06-08 08:17:44 +00002388
Guido van Rossum374a9221991-04-04 10:40:29 +00002389 /* Quickly continue if no error occurred */
Guido van Rossumac7be682001-01-17 15:42:30 +00002390
Guido van Rossum374a9221991-04-04 10:40:29 +00002391 if (why == WHY_NOT) {
Guido van Rossum681d79a1995-07-18 14:51:37 +00002392 if (err == 0 && x != NULL) {
2393#ifdef CHECKEXC
Guido van Rossumeb894eb1999-03-09 16:16:45 +00002394 /* This check is expensive! */
Guido van Rossumb209a111997-04-29 18:18:01 +00002395 if (PyErr_Occurred())
Guido van Rossum681d79a1995-07-18 14:51:37 +00002396 fprintf(stderr,
2397 "XXX undetected error\n");
Martin v. Löwisf30d60e2004-06-08 08:17:44 +00002398 else {
2399#endif
Michael W. Hudson75eabd22005-01-18 15:56:11 +00002400 READ_TIMESTAMP(loop1);
Guido van Rossum681d79a1995-07-18 14:51:37 +00002401 continue; /* Normal, fast path */
Martin v. Löwisf30d60e2004-06-08 08:17:44 +00002402#ifdef CHECKEXC
2403 }
2404#endif
Guido van Rossum681d79a1995-07-18 14:51:37 +00002405 }
Guido van Rossum374a9221991-04-04 10:40:29 +00002406 why = WHY_EXCEPTION;
Guido van Rossumb209a111997-04-29 18:18:01 +00002407 x = Py_None;
Guido van Rossum374a9221991-04-04 10:40:29 +00002408 err = 0;
2409 }
2410
Guido van Rossum374a9221991-04-04 10:40:29 +00002411 /* Double-check exception status */
Guido van Rossumac7be682001-01-17 15:42:30 +00002412
Raymond Hettingerc8aa08b2004-04-11 14:59:33 +00002413 if (why == WHY_EXCEPTION || why == WHY_RERAISE) {
Guido van Rossumb209a111997-04-29 18:18:01 +00002414 if (!PyErr_Occurred()) {
Guido van Rossuma027efa1997-05-05 20:56:21 +00002415 PyErr_SetString(PyExc_SystemError,
Guido van Rossumeb894eb1999-03-09 16:16:45 +00002416 "error return without exception set");
Guido van Rossum374a9221991-04-04 10:40:29 +00002417 why = WHY_EXCEPTION;
2418 }
2419 }
Guido van Rossumeb894eb1999-03-09 16:16:45 +00002420#ifdef CHECKEXC
Guido van Rossum374a9221991-04-04 10:40:29 +00002421 else {
Guido van Rossumeb894eb1999-03-09 16:16:45 +00002422 /* This check is expensive! */
Guido van Rossumb209a111997-04-29 18:18:01 +00002423 if (PyErr_Occurred()) {
Jeremy Hylton904ed862003-11-05 17:29:35 +00002424 char buf[1024];
2425 sprintf(buf, "Stack unwind with exception "
2426 "set and why=%d", why);
2427 Py_FatalError(buf);
Guido van Rossum681d79a1995-07-18 14:51:37 +00002428 }
Guido van Rossum374a9221991-04-04 10:40:29 +00002429 }
2430#endif
2431
2432 /* Log traceback info if this is a real exception */
Guido van Rossumac7be682001-01-17 15:42:30 +00002433
Guido van Rossum374a9221991-04-04 10:40:29 +00002434 if (why == WHY_EXCEPTION) {
Guido van Rossumb209a111997-04-29 18:18:01 +00002435 PyTraceBack_Here(f);
Guido van Rossum96a42c81992-01-12 02:29:51 +00002436
Fred Drake8f51f542001-10-04 14:48:42 +00002437 if (tstate->c_tracefunc != NULL)
2438 call_exc_trace(tstate->c_tracefunc,
2439 tstate->c_traceobj, f);
Guido van Rossum014518f1998-11-23 21:09:51 +00002440 }
Guido van Rossumac7be682001-01-17 15:42:30 +00002441
Guido van Rossum374a9221991-04-04 10:40:29 +00002442 /* For the rest, treat WHY_RERAISE as WHY_EXCEPTION */
Guido van Rossumac7be682001-01-17 15:42:30 +00002443
Guido van Rossum374a9221991-04-04 10:40:29 +00002444 if (why == WHY_RERAISE)
2445 why = WHY_EXCEPTION;
2446
2447 /* Unwind stacks if a (pseudo) exception occurred */
Guido van Rossumac7be682001-01-17 15:42:30 +00002448
Raymond Hettinger1dd83092004-02-06 18:32:33 +00002449fast_block_end:
Tim Peters8a5c3c72004-04-05 19:36:21 +00002450 while (why != WHY_NOT && f->f_iblock > 0) {
Guido van Rossumb209a111997-04-29 18:18:01 +00002451 PyTryBlock *b = PyFrame_BlockPop(f);
Jeremy Hylton3faa52e2001-02-01 22:48:12 +00002452
Tim Peters8a5c3c72004-04-05 19:36:21 +00002453 assert(why != WHY_YIELD);
Jeremy Hylton3faa52e2001-02-01 22:48:12 +00002454 if (b->b_type == SETUP_LOOP && why == WHY_CONTINUE) {
2455 /* For a continue inside a try block,
2456 don't pop the block for the loop. */
Thomas Wouters1ee64222001-09-24 19:32:01 +00002457 PyFrame_BlockSetup(f, b->b_type, b->b_handler,
2458 b->b_level);
Jeremy Hylton3faa52e2001-02-01 22:48:12 +00002459 why = WHY_NOT;
2460 JUMPTO(PyInt_AS_LONG(retval));
2461 Py_DECREF(retval);
2462 break;
2463 }
2464
Guido van Rossum374a9221991-04-04 10:40:29 +00002465 while (STACK_LEVEL() > b->b_level) {
2466 v = POP();
Guido van Rossumb209a111997-04-29 18:18:01 +00002467 Py_XDECREF(v);
Guido van Rossum374a9221991-04-04 10:40:29 +00002468 }
2469 if (b->b_type == SETUP_LOOP && why == WHY_BREAK) {
2470 why = WHY_NOT;
2471 JUMPTO(b->b_handler);
2472 break;
2473 }
2474 if (b->b_type == SETUP_FINALLY ||
Guido van Rossum150b2df1996-12-05 23:17:11 +00002475 (b->b_type == SETUP_EXCEPT &&
2476 why == WHY_EXCEPTION)) {
Guido van Rossum374a9221991-04-04 10:40:29 +00002477 if (why == WHY_EXCEPTION) {
Guido van Rossumb209a111997-04-29 18:18:01 +00002478 PyObject *exc, *val, *tb;
2479 PyErr_Fetch(&exc, &val, &tb);
Guido van Rossum374a9221991-04-04 10:40:29 +00002480 if (val == NULL) {
Guido van Rossumb209a111997-04-29 18:18:01 +00002481 val = Py_None;
2482 Py_INCREF(val);
Guido van Rossum374a9221991-04-04 10:40:29 +00002483 }
Guido van Rossum374a9221991-04-04 10:40:29 +00002484 /* Make the raw exception data
2485 available to the handler,
2486 so a program can emulate the
2487 Python main loop. Don't do
2488 this for 'finally'. */
2489 if (b->b_type == SETUP_EXCEPT) {
Barry Warsaweaedc7c1997-08-28 22:36:40 +00002490 PyErr_NormalizeException(
2491 &exc, &val, &tb);
Guido van Rossuma027efa1997-05-05 20:56:21 +00002492 set_exc_info(tstate,
2493 exc, val, tb);
Guido van Rossum374a9221991-04-04 10:40:29 +00002494 }
Jeremy Hyltonc6314892001-09-26 19:24:45 +00002495 if (tb == NULL) {
2496 Py_INCREF(Py_None);
2497 PUSH(Py_None);
2498 } else
2499 PUSH(tb);
Guido van Rossum374a9221991-04-04 10:40:29 +00002500 PUSH(val);
2501 PUSH(exc);
2502 }
2503 else {
Raymond Hettinger06032cb2004-04-06 09:37:35 +00002504 if (why & (WHY_RETURN | WHY_CONTINUE))
Guido van Rossum374a9221991-04-04 10:40:29 +00002505 PUSH(retval);
Guido van Rossumb209a111997-04-29 18:18:01 +00002506 v = PyInt_FromLong((long)why);
Guido van Rossum374a9221991-04-04 10:40:29 +00002507 PUSH(v);
2508 }
2509 why = WHY_NOT;
2510 JUMPTO(b->b_handler);
2511 break;
2512 }
2513 } /* unwind stack */
2514
2515 /* End the loop if we still have an error (or return) */
Guido van Rossumac7be682001-01-17 15:42:30 +00002516
Guido van Rossum374a9221991-04-04 10:40:29 +00002517 if (why != WHY_NOT)
2518 break;
Michael W. Hudson75eabd22005-01-18 15:56:11 +00002519 READ_TIMESTAMP(loop1);
Guido van Rossumac7be682001-01-17 15:42:30 +00002520
Guido van Rossum374a9221991-04-04 10:40:29 +00002521 } /* main loop */
Guido van Rossumac7be682001-01-17 15:42:30 +00002522
Tim Peters8a5c3c72004-04-05 19:36:21 +00002523 assert(why != WHY_YIELD);
2524 /* Pop remaining stack entries. */
2525 while (!EMPTY()) {
2526 v = POP();
2527 Py_XDECREF(v);
Guido van Rossum35974fb2001-12-06 21:28:18 +00002528 }
2529
Tim Peters8a5c3c72004-04-05 19:36:21 +00002530 if (why != WHY_RETURN)
Guido van Rossum96a42c81992-01-12 02:29:51 +00002531 retval = NULL;
Guido van Rossumac7be682001-01-17 15:42:30 +00002532
Raymond Hettinger1dd83092004-02-06 18:32:33 +00002533fast_yield:
Fred Drake9e3ad782001-07-03 23:39:52 +00002534 if (tstate->use_tracing) {
Barry Warsawe2eca0b2005-08-15 18:14:19 +00002535 if (tstate->c_tracefunc) {
2536 if (why == WHY_RETURN || why == WHY_YIELD) {
2537 if (call_trace(tstate->c_tracefunc,
2538 tstate->c_traceobj, f,
2539 PyTrace_RETURN, retval)) {
2540 Py_XDECREF(retval);
2541 retval = NULL;
2542 why = WHY_EXCEPTION;
2543 }
2544 }
2545 else if (why == WHY_EXCEPTION) {
2546 call_trace_protected(tstate->c_tracefunc,
2547 tstate->c_traceobj, f,
Armin Rigo1c2d7e52005-09-20 18:34:01 +00002548 PyTrace_RETURN, NULL);
Guido van Rossum96a42c81992-01-12 02:29:51 +00002549 }
Guido van Rossum96a42c81992-01-12 02:29:51 +00002550 }
Fred Drake8f51f542001-10-04 14:48:42 +00002551 if (tstate->c_profilefunc) {
Fred Drake4ec5d562001-10-04 19:26:43 +00002552 if (why == WHY_EXCEPTION)
2553 call_trace_protected(tstate->c_profilefunc,
2554 tstate->c_profileobj, f,
Armin Rigo1c2d7e52005-09-20 18:34:01 +00002555 PyTrace_RETURN, NULL);
Fred Drake4ec5d562001-10-04 19:26:43 +00002556 else if (call_trace(tstate->c_profilefunc,
2557 tstate->c_profileobj, f,
2558 PyTrace_RETURN, retval)) {
Fred Drake9e3ad782001-07-03 23:39:52 +00002559 Py_XDECREF(retval);
2560 retval = NULL;
2561 why = WHY_EXCEPTION;
2562 }
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00002563 }
Guido van Rossum96a42c81992-01-12 02:29:51 +00002564 }
Guido van Rossuma4240131997-01-21 21:18:36 +00002565
Guido van Rossuma027efa1997-05-05 20:56:21 +00002566 reset_exc_info(tstate);
2567
Tim Peters5ca576e2001-06-18 22:08:13 +00002568 /* pop frame */
Armin Rigo2b3eb402003-10-28 12:05:48 +00002569 exit_eval_frame:
2570 Py_LeaveRecursiveCall();
Guido van Rossuma027efa1997-05-05 20:56:21 +00002571 tstate->frame = f->f_back;
Guido van Rossumac7be682001-01-17 15:42:30 +00002572
Guido van Rossum96a42c81992-01-12 02:29:51 +00002573 return retval;
Guido van Rossum374a9221991-04-04 10:40:29 +00002574}
2575
Guido van Rossumc2e20742006-02-27 22:32:47 +00002576/* This is gonna seem *real weird*, but if you put some other code between
Martin v. Löwis8d97e332004-06-27 15:43:12 +00002577 PyEval_EvalFrame() and PyEval_EvalCodeEx() you will need to adjust
Guido van Rossumc2e20742006-02-27 22:32:47 +00002578 the test in the if statements in Misc/gdbinit (pystack and pystackv). */
Skip Montanaro786ea6b2004-03-01 15:44:05 +00002579
Tim Peters6d6c1a32001-08-02 04:15:00 +00002580PyObject *
2581PyEval_EvalCodeEx(PyCodeObject *co, PyObject *globals, PyObject *locals,
Tim Peters5ca576e2001-06-18 22:08:13 +00002582 PyObject **args, int argcount, PyObject **kws, int kwcount,
2583 PyObject **defs, int defcount, PyObject *closure)
2584{
2585 register PyFrameObject *f;
2586 register PyObject *retval = NULL;
2587 register PyObject **fastlocals, **freevars;
2588 PyThreadState *tstate = PyThreadState_GET();
2589 PyObject *x, *u;
2590
2591 if (globals == NULL) {
Tim Peters8a5c3c72004-04-05 19:36:21 +00002592 PyErr_SetString(PyExc_SystemError,
Jeremy Hylton910d7d42001-08-12 21:52:24 +00002593 "PyEval_EvalCodeEx: NULL globals");
Tim Peters5ca576e2001-06-18 22:08:13 +00002594 return NULL;
2595 }
2596
Jeremy Hylton985eba52003-02-05 23:13:00 +00002597 assert(globals != NULL);
2598 f = PyFrame_New(tstate, co, globals, locals);
Tim Peters5ca576e2001-06-18 22:08:13 +00002599 if (f == NULL)
2600 return NULL;
2601
2602 fastlocals = f->f_localsplus;
2603 freevars = f->f_localsplus + f->f_nlocals;
2604
2605 if (co->co_argcount > 0 ||
2606 co->co_flags & (CO_VARARGS | CO_VARKEYWORDS)) {
2607 int i;
2608 int n = argcount;
2609 PyObject *kwdict = NULL;
2610 if (co->co_flags & CO_VARKEYWORDS) {
2611 kwdict = PyDict_New();
2612 if (kwdict == NULL)
2613 goto fail;
2614 i = co->co_argcount;
2615 if (co->co_flags & CO_VARARGS)
2616 i++;
2617 SETLOCAL(i, kwdict);
2618 }
2619 if (argcount > co->co_argcount) {
2620 if (!(co->co_flags & CO_VARARGS)) {
2621 PyErr_Format(PyExc_TypeError,
2622 "%.200s() takes %s %d "
2623 "%sargument%s (%d given)",
2624 PyString_AsString(co->co_name),
2625 defcount ? "at most" : "exactly",
2626 co->co_argcount,
2627 kwcount ? "non-keyword " : "",
2628 co->co_argcount == 1 ? "" : "s",
2629 argcount);
2630 goto fail;
2631 }
2632 n = co->co_argcount;
2633 }
2634 for (i = 0; i < n; i++) {
2635 x = args[i];
2636 Py_INCREF(x);
2637 SETLOCAL(i, x);
2638 }
2639 if (co->co_flags & CO_VARARGS) {
2640 u = PyTuple_New(argcount - n);
2641 if (u == NULL)
2642 goto fail;
2643 SETLOCAL(co->co_argcount, u);
2644 for (i = n; i < argcount; i++) {
2645 x = args[i];
2646 Py_INCREF(x);
2647 PyTuple_SET_ITEM(u, i-n, x);
2648 }
2649 }
2650 for (i = 0; i < kwcount; i++) {
2651 PyObject *keyword = kws[2*i];
2652 PyObject *value = kws[2*i + 1];
2653 int j;
2654 if (keyword == NULL || !PyString_Check(keyword)) {
2655 PyErr_Format(PyExc_TypeError,
2656 "%.200s() keywords must be strings",
2657 PyString_AsString(co->co_name));
2658 goto fail;
2659 }
2660 /* XXX slow -- speed up using dictionary? */
2661 for (j = 0; j < co->co_argcount; j++) {
2662 PyObject *nm = PyTuple_GET_ITEM(
2663 co->co_varnames, j);
2664 int cmp = PyObject_RichCompareBool(
2665 keyword, nm, Py_EQ);
2666 if (cmp > 0)
2667 break;
2668 else if (cmp < 0)
2669 goto fail;
2670 }
2671 /* Check errors from Compare */
2672 if (PyErr_Occurred())
2673 goto fail;
2674 if (j >= co->co_argcount) {
2675 if (kwdict == NULL) {
2676 PyErr_Format(PyExc_TypeError,
2677 "%.200s() got an unexpected "
2678 "keyword argument '%.400s'",
2679 PyString_AsString(co->co_name),
2680 PyString_AsString(keyword));
2681 goto fail;
2682 }
2683 PyDict_SetItem(kwdict, keyword, value);
2684 }
2685 else {
2686 if (GETLOCAL(j) != NULL) {
2687 PyErr_Format(PyExc_TypeError,
2688 "%.200s() got multiple "
2689 "values for keyword "
2690 "argument '%.400s'",
2691 PyString_AsString(co->co_name),
2692 PyString_AsString(keyword));
2693 goto fail;
2694 }
2695 Py_INCREF(value);
2696 SETLOCAL(j, value);
2697 }
2698 }
2699 if (argcount < co->co_argcount) {
2700 int m = co->co_argcount - defcount;
2701 for (i = argcount; i < m; i++) {
2702 if (GETLOCAL(i) == NULL) {
2703 PyErr_Format(PyExc_TypeError,
2704 "%.200s() takes %s %d "
2705 "%sargument%s (%d given)",
2706 PyString_AsString(co->co_name),
2707 ((co->co_flags & CO_VARARGS) ||
2708 defcount) ? "at least"
2709 : "exactly",
2710 m, kwcount ? "non-keyword " : "",
2711 m == 1 ? "" : "s", i);
2712 goto fail;
2713 }
2714 }
2715 if (n > m)
2716 i = n - m;
2717 else
2718 i = 0;
2719 for (; i < defcount; i++) {
2720 if (GETLOCAL(m+i) == NULL) {
2721 PyObject *def = defs[i];
2722 Py_INCREF(def);
2723 SETLOCAL(m+i, def);
2724 }
2725 }
2726 }
2727 }
2728 else {
2729 if (argcount > 0 || kwcount > 0) {
2730 PyErr_Format(PyExc_TypeError,
2731 "%.200s() takes no arguments (%d given)",
2732 PyString_AsString(co->co_name),
2733 argcount + kwcount);
2734 goto fail;
2735 }
2736 }
2737 /* Allocate and initialize storage for cell vars, and copy free
2738 vars into frame. This isn't too efficient right now. */
2739 if (f->f_ncells) {
2740 int i = 0, j = 0, nargs, found;
2741 char *cellname, *argname;
2742 PyObject *c;
2743
2744 nargs = co->co_argcount;
2745 if (co->co_flags & CO_VARARGS)
2746 nargs++;
2747 if (co->co_flags & CO_VARKEYWORDS)
2748 nargs++;
2749
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00002750 /* Initialize each cell var, taking into account
2751 cell vars that are initialized from arguments.
2752
2753 Should arrange for the compiler to put cellvars
2754 that are arguments at the beginning of the cellvars
2755 list so that we can march over it more efficiently?
2756 */
2757 for (i = 0; i < f->f_ncells; ++i) {
Tim Peters5ca576e2001-06-18 22:08:13 +00002758 cellname = PyString_AS_STRING(
2759 PyTuple_GET_ITEM(co->co_cellvars, i));
2760 found = 0;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00002761 for (j = 0; j < nargs; j++) {
Tim Peters5ca576e2001-06-18 22:08:13 +00002762 argname = PyString_AS_STRING(
2763 PyTuple_GET_ITEM(co->co_varnames, j));
2764 if (strcmp(cellname, argname) == 0) {
2765 c = PyCell_New(GETLOCAL(j));
2766 if (c == NULL)
2767 goto fail;
2768 GETLOCAL(f->f_nlocals + i) = c;
2769 found = 1;
2770 break;
2771 }
Tim Peters5ca576e2001-06-18 22:08:13 +00002772 }
2773 if (found == 0) {
2774 c = PyCell_New(NULL);
2775 if (c == NULL)
2776 goto fail;
2777 SETLOCAL(f->f_nlocals + i, c);
2778 }
2779 }
Tim Peters5ca576e2001-06-18 22:08:13 +00002780 }
2781 if (f->f_nfreevars) {
2782 int i;
2783 for (i = 0; i < f->f_nfreevars; ++i) {
2784 PyObject *o = PyTuple_GET_ITEM(closure, i);
2785 Py_INCREF(o);
2786 freevars[f->f_ncells + i] = o;
2787 }
2788 }
2789
Tim Peters5ca576e2001-06-18 22:08:13 +00002790 if (co->co_flags & CO_GENERATOR) {
Neil Schemenauer2b13ce82001-06-21 02:41:10 +00002791 /* Don't need to keep the reference to f_back, it will be set
2792 * when the generator is resumed. */
Tim Peters5ba58662001-07-16 02:29:45 +00002793 Py_XDECREF(f->f_back);
Neil Schemenauer2b13ce82001-06-21 02:41:10 +00002794 f->f_back = NULL;
2795
Jeremy Hylton985eba52003-02-05 23:13:00 +00002796 PCALL(PCALL_GENERATOR);
2797
Neil Schemenauer2b13ce82001-06-21 02:41:10 +00002798 /* Create a new generator that owns the ready to run frame
2799 * and return that as the value. */
Martin v. Löwise440e472004-06-01 15:22:42 +00002800 return PyGen_New(f);
Tim Peters5ca576e2001-06-18 22:08:13 +00002801 }
2802
Phillip J. Eby0d6615f2005-08-02 00:46:46 +00002803 retval = PyEval_EvalFrameEx(f,0);
Tim Peters5ca576e2001-06-18 22:08:13 +00002804
2805 fail: /* Jump here from prelude on failure */
2806
Tim Petersb13680b2001-11-27 23:29:29 +00002807 /* decref'ing the frame can cause __del__ methods to get invoked,
2808 which can call back into Python. While we're done with the
2809 current Python frame (f), the associated C stack is still in use,
2810 so recursion_depth must be boosted for the duration.
2811 */
2812 assert(tstate != NULL);
2813 ++tstate->recursion_depth;
Tim Peters5ca576e2001-06-18 22:08:13 +00002814 Py_DECREF(f);
Tim Petersb13680b2001-11-27 23:29:29 +00002815 --tstate->recursion_depth;
Tim Peters5ca576e2001-06-18 22:08:13 +00002816 return retval;
2817}
2818
2819
Guido van Rossumc9fbb722003-03-01 03:36:33 +00002820/* Implementation notes for set_exc_info() and reset_exc_info():
2821
2822- Below, 'exc_ZZZ' stands for 'exc_type', 'exc_value' and
2823 'exc_traceback'. These always travel together.
2824
2825- tstate->curexc_ZZZ is the "hot" exception that is set by
2826 PyErr_SetString(), cleared by PyErr_Clear(), and so on.
2827
2828- Once an exception is caught by an except clause, it is transferred
2829 from tstate->curexc_ZZZ to tstate->exc_ZZZ, from which sys.exc_info()
2830 can pick it up. This is the primary task of set_exc_info().
2831
2832- Now let me explain the complicated dance with frame->f_exc_ZZZ.
2833
2834 Long ago, when none of this existed, there were just a few globals:
2835 one set corresponding to the "hot" exception, and one set
2836 corresponding to sys.exc_ZZZ. (Actually, the latter weren't C
2837 globals; they were simply stored as sys.exc_ZZZ. For backwards
2838 compatibility, they still are!) The problem was that in code like
2839 this:
2840
2841 try:
2842 "something that may fail"
2843 except "some exception":
2844 "do something else first"
2845 "print the exception from sys.exc_ZZZ."
2846
2847 if "do something else first" invoked something that raised and caught
2848 an exception, sys.exc_ZZZ were overwritten. That was a frequent
2849 cause of subtle bugs. I fixed this by changing the semantics as
2850 follows:
2851
2852 - Within one frame, sys.exc_ZZZ will hold the last exception caught
2853 *in that frame*.
2854
2855 - But initially, and as long as no exception is caught in a given
2856 frame, sys.exc_ZZZ will hold the last exception caught in the
2857 previous frame (or the frame before that, etc.).
2858
2859 The first bullet fixed the bug in the above example. The second
2860 bullet was for backwards compatibility: it was (and is) common to
2861 have a function that is called when an exception is caught, and to
2862 have that function access the caught exception via sys.exc_ZZZ.
2863 (Example: traceback.print_exc()).
2864
2865 At the same time I fixed the problem that sys.exc_ZZZ weren't
2866 thread-safe, by introducing sys.exc_info() which gets it from tstate;
2867 but that's really a separate improvement.
2868
2869 The reset_exc_info() function in ceval.c restores the tstate->exc_ZZZ
2870 variables to what they were before the current frame was called. The
2871 set_exc_info() function saves them on the frame so that
2872 reset_exc_info() can restore them. The invariant is that
2873 frame->f_exc_ZZZ is NULL iff the current frame never caught an
2874 exception (where "catching" an exception applies only to successful
2875 except clauses); and if the current frame ever caught an exception,
2876 frame->f_exc_ZZZ is the exception that was stored in tstate->exc_ZZZ
2877 at the start of the current frame.
2878
2879*/
2880
Guido van Rossuma027efa1997-05-05 20:56:21 +00002881static void
Guido van Rossumac7be682001-01-17 15:42:30 +00002882set_exc_info(PyThreadState *tstate,
2883 PyObject *type, PyObject *value, PyObject *tb)
Guido van Rossuma027efa1997-05-05 20:56:21 +00002884{
2885 PyFrameObject *frame;
Guido van Rossumdf4c3081997-05-20 17:06:11 +00002886 PyObject *tmp_type, *tmp_value, *tmp_tb;
Barry Warsaw4249f541997-08-22 21:26:19 +00002887
Guido van Rossuma027efa1997-05-05 20:56:21 +00002888 frame = tstate->frame;
2889 if (frame->f_exc_type == NULL) {
2890 /* This frame didn't catch an exception before */
2891 /* Save previous exception of this thread in this frame */
Guido van Rossuma027efa1997-05-05 20:56:21 +00002892 if (tstate->exc_type == NULL) {
2893 Py_INCREF(Py_None);
2894 tstate->exc_type = Py_None;
2895 }
Guido van Rossumdf4c3081997-05-20 17:06:11 +00002896 tmp_type = frame->f_exc_type;
2897 tmp_value = frame->f_exc_value;
2898 tmp_tb = frame->f_exc_traceback;
Guido van Rossuma027efa1997-05-05 20:56:21 +00002899 Py_XINCREF(tstate->exc_type);
2900 Py_XINCREF(tstate->exc_value);
2901 Py_XINCREF(tstate->exc_traceback);
2902 frame->f_exc_type = tstate->exc_type;
2903 frame->f_exc_value = tstate->exc_value;
2904 frame->f_exc_traceback = tstate->exc_traceback;
Guido van Rossumdf4c3081997-05-20 17:06:11 +00002905 Py_XDECREF(tmp_type);
2906 Py_XDECREF(tmp_value);
2907 Py_XDECREF(tmp_tb);
Guido van Rossuma027efa1997-05-05 20:56:21 +00002908 }
2909 /* Set new exception for this thread */
Guido van Rossumdf4c3081997-05-20 17:06:11 +00002910 tmp_type = tstate->exc_type;
2911 tmp_value = tstate->exc_value;
2912 tmp_tb = tstate->exc_traceback;
Guido van Rossuma027efa1997-05-05 20:56:21 +00002913 Py_XINCREF(type);
2914 Py_XINCREF(value);
2915 Py_XINCREF(tb);
2916 tstate->exc_type = type;
2917 tstate->exc_value = value;
2918 tstate->exc_traceback = tb;
Guido van Rossumdf4c3081997-05-20 17:06:11 +00002919 Py_XDECREF(tmp_type);
2920 Py_XDECREF(tmp_value);
2921 Py_XDECREF(tmp_tb);
Guido van Rossuma027efa1997-05-05 20:56:21 +00002922 /* For b/w compatibility */
2923 PySys_SetObject("exc_type", type);
2924 PySys_SetObject("exc_value", value);
2925 PySys_SetObject("exc_traceback", tb);
2926}
2927
2928static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002929reset_exc_info(PyThreadState *tstate)
Guido van Rossuma027efa1997-05-05 20:56:21 +00002930{
2931 PyFrameObject *frame;
Guido van Rossumdf4c3081997-05-20 17:06:11 +00002932 PyObject *tmp_type, *tmp_value, *tmp_tb;
Guido van Rossuma027efa1997-05-05 20:56:21 +00002933 frame = tstate->frame;
2934 if (frame->f_exc_type != NULL) {
2935 /* This frame caught an exception */
Guido van Rossumdf4c3081997-05-20 17:06:11 +00002936 tmp_type = tstate->exc_type;
2937 tmp_value = tstate->exc_value;
2938 tmp_tb = tstate->exc_traceback;
Guido van Rossuma027efa1997-05-05 20:56:21 +00002939 Py_XINCREF(frame->f_exc_type);
2940 Py_XINCREF(frame->f_exc_value);
2941 Py_XINCREF(frame->f_exc_traceback);
2942 tstate->exc_type = frame->f_exc_type;
2943 tstate->exc_value = frame->f_exc_value;
2944 tstate->exc_traceback = frame->f_exc_traceback;
Guido van Rossumdf4c3081997-05-20 17:06:11 +00002945 Py_XDECREF(tmp_type);
2946 Py_XDECREF(tmp_value);
2947 Py_XDECREF(tmp_tb);
Guido van Rossuma027efa1997-05-05 20:56:21 +00002948 /* For b/w compatibility */
2949 PySys_SetObject("exc_type", frame->f_exc_type);
2950 PySys_SetObject("exc_value", frame->f_exc_value);
2951 PySys_SetObject("exc_traceback", frame->f_exc_traceback);
2952 }
Guido van Rossumdf4c3081997-05-20 17:06:11 +00002953 tmp_type = frame->f_exc_type;
2954 tmp_value = frame->f_exc_value;
2955 tmp_tb = frame->f_exc_traceback;
Guido van Rossuma027efa1997-05-05 20:56:21 +00002956 frame->f_exc_type = NULL;
2957 frame->f_exc_value = NULL;
2958 frame->f_exc_traceback = NULL;
Guido van Rossumdf4c3081997-05-20 17:06:11 +00002959 Py_XDECREF(tmp_type);
2960 Py_XDECREF(tmp_value);
2961 Py_XDECREF(tmp_tb);
Guido van Rossuma027efa1997-05-05 20:56:21 +00002962}
2963
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00002964/* Logic for the raise statement (too complicated for inlining).
2965 This *consumes* a reference count to each of its arguments. */
Raymond Hettinger7c958652004-04-06 10:11:10 +00002966static enum why_code
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002967do_raise(PyObject *type, PyObject *value, PyObject *tb)
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00002968{
Guido van Rossumd295f121998-04-09 21:39:57 +00002969 if (type == NULL) {
2970 /* Reraise */
Nicholas Bastine5662ae2004-03-24 22:22:12 +00002971 PyThreadState *tstate = PyThreadState_GET();
Guido van Rossumd295f121998-04-09 21:39:57 +00002972 type = tstate->exc_type == NULL ? Py_None : tstate->exc_type;
2973 value = tstate->exc_value;
2974 tb = tstate->exc_traceback;
2975 Py_XINCREF(type);
2976 Py_XINCREF(value);
2977 Py_XINCREF(tb);
2978 }
Guido van Rossumac7be682001-01-17 15:42:30 +00002979
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00002980 /* We support the following forms of raise:
2981 raise <class>, <classinstance>
2982 raise <class>, <argument tuple>
2983 raise <class>, None
2984 raise <class>, <argument>
2985 raise <classinstance>, None
2986 raise <string>, <object>
2987 raise <string>, None
2988
2989 An omitted second argument is the same as None.
2990
2991 In addition, raise <tuple>, <anything> is the same as
2992 raising the tuple's first item (and it better have one!);
2993 this rule is applied recursively.
2994
2995 Finally, an optional third argument can be supplied, which
2996 gives the traceback to be substituted (useful when
2997 re-raising an exception after examining it). */
2998
2999 /* First, check the traceback argument, replacing None with
3000 NULL. */
Guido van Rossumb209a111997-04-29 18:18:01 +00003001 if (tb == Py_None) {
3002 Py_DECREF(tb);
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00003003 tb = NULL;
3004 }
3005 else if (tb != NULL && !PyTraceBack_Check(tb)) {
Guido van Rossumb209a111997-04-29 18:18:01 +00003006 PyErr_SetString(PyExc_TypeError,
Fred Drake661ea262000-10-24 19:57:45 +00003007 "raise: arg 3 must be a traceback or None");
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00003008 goto raise_error;
3009 }
3010
3011 /* Next, replace a missing value with None */
3012 if (value == NULL) {
Guido van Rossumb209a111997-04-29 18:18:01 +00003013 value = Py_None;
3014 Py_INCREF(value);
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00003015 }
3016
3017 /* Next, repeatedly, replace a tuple exception with its first item */
Guido van Rossumb209a111997-04-29 18:18:01 +00003018 while (PyTuple_Check(type) && PyTuple_Size(type) > 0) {
3019 PyObject *tmp = type;
3020 type = PyTuple_GET_ITEM(type, 0);
3021 Py_INCREF(type);
3022 Py_DECREF(tmp);
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00003023 }
3024
Brett Cannona7446e32006-02-27 23:39:10 +00003025 if (PyString_CheckExact(type)) {
Tim Petersafb2c802002-04-18 18:06:20 +00003026 /* Raising builtin string is deprecated but still allowed --
3027 * do nothing. Raising an instance of a new-style str
3028 * subclass is right out. */
Brett Cannona7446e32006-02-27 23:39:10 +00003029 if (-1 == PyErr_Warn(PyExc_PendingDeprecationWarning,
3030 "raising a string exception is deprecated"))
3031 goto raise_error;
3032 }
Barry Warsaw4249f541997-08-22 21:26:19 +00003033 else if (PyClass_Check(type))
3034 PyErr_NormalizeException(&type, &value, &tb);
3035
Guido van Rossumb209a111997-04-29 18:18:01 +00003036 else if (PyInstance_Check(type)) {
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00003037 /* Raising an instance. The value should be a dummy. */
Guido van Rossumb209a111997-04-29 18:18:01 +00003038 if (value != Py_None) {
3039 PyErr_SetString(PyExc_TypeError,
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00003040 "instance exception may not have a separate value");
3041 goto raise_error;
3042 }
3043 else {
3044 /* Normalize to raise <class>, <instance> */
Guido van Rossumb209a111997-04-29 18:18:01 +00003045 Py_DECREF(value);
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00003046 value = type;
Guido van Rossumb209a111997-04-29 18:18:01 +00003047 type = (PyObject*) ((PyInstanceObject*)type)->in_class;
3048 Py_INCREF(type);
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00003049 }
3050 }
3051 else {
3052 /* Not something you can raise. You get an exception
3053 anyway, just not what you specified :-) */
Jeremy Hylton960d9482001-04-27 02:25:33 +00003054 PyErr_Format(PyExc_TypeError,
Neal Norwitz37aa0662003-01-10 15:31:15 +00003055 "exceptions must be classes, instances, or "
3056 "strings (deprecated), not %s",
3057 type->ob_type->tp_name);
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00003058 goto raise_error;
3059 }
Guido van Rossumb209a111997-04-29 18:18:01 +00003060 PyErr_Restore(type, value, tb);
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00003061 if (tb == NULL)
3062 return WHY_EXCEPTION;
3063 else
3064 return WHY_RERAISE;
3065 raise_error:
Guido van Rossumb209a111997-04-29 18:18:01 +00003066 Py_XDECREF(value);
3067 Py_XDECREF(type);
3068 Py_XDECREF(tb);
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00003069 return WHY_EXCEPTION;
3070}
3071
Tim Petersd6d010b2001-06-21 02:49:55 +00003072/* Iterate v argcnt times and store the results on the stack (via decreasing
3073 sp). Return 1 for success, 0 if error. */
3074
Barry Warsawe42b18f1997-08-25 22:13:04 +00003075static int
Tim Petersd6d010b2001-06-21 02:49:55 +00003076unpack_iterable(PyObject *v, int argcnt, PyObject **sp)
Barry Warsawe42b18f1997-08-25 22:13:04 +00003077{
Tim Petersd6d010b2001-06-21 02:49:55 +00003078 int i = 0;
3079 PyObject *it; /* iter(v) */
Barry Warsawe42b18f1997-08-25 22:13:04 +00003080 PyObject *w;
Guido van Rossumac7be682001-01-17 15:42:30 +00003081
Tim Petersd6d010b2001-06-21 02:49:55 +00003082 assert(v != NULL);
3083
3084 it = PyObject_GetIter(v);
3085 if (it == NULL)
3086 goto Error;
3087
3088 for (; i < argcnt; i++) {
3089 w = PyIter_Next(it);
3090 if (w == NULL) {
3091 /* Iterator done, via error or exhaustion. */
3092 if (!PyErr_Occurred()) {
3093 PyErr_Format(PyExc_ValueError,
3094 "need more than %d value%s to unpack",
3095 i, i == 1 ? "" : "s");
3096 }
3097 goto Error;
Barry Warsawe42b18f1997-08-25 22:13:04 +00003098 }
3099 *--sp = w;
3100 }
Tim Petersd6d010b2001-06-21 02:49:55 +00003101
3102 /* We better have exhausted the iterator now. */
3103 w = PyIter_Next(it);
3104 if (w == NULL) {
3105 if (PyErr_Occurred())
3106 goto Error;
3107 Py_DECREF(it);
3108 return 1;
Barry Warsawe42b18f1997-08-25 22:13:04 +00003109 }
Guido van Rossumbb8f59a2001-12-03 19:33:25 +00003110 Py_DECREF(w);
Tim Petersd6d010b2001-06-21 02:49:55 +00003111 PyErr_SetString(PyExc_ValueError, "too many values to unpack");
Barry Warsawe42b18f1997-08-25 22:13:04 +00003112 /* fall through */
Tim Petersd6d010b2001-06-21 02:49:55 +00003113Error:
Barry Warsaw91010551997-08-25 22:30:51 +00003114 for (; i > 0; i--, sp++)
3115 Py_DECREF(*sp);
Tim Petersd6d010b2001-06-21 02:49:55 +00003116 Py_XDECREF(it);
Barry Warsawe42b18f1997-08-25 22:13:04 +00003117 return 0;
3118}
3119
3120
Guido van Rossum96a42c81992-01-12 02:29:51 +00003121#ifdef LLTRACE
Guido van Rossum3f5da241990-12-20 15:06:42 +00003122static int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003123prtrace(PyObject *v, char *str)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003124{
Guido van Rossum3f5da241990-12-20 15:06:42 +00003125 printf("%s ", str);
Guido van Rossumb209a111997-04-29 18:18:01 +00003126 if (PyObject_Print(v, stdout, 0) != 0)
3127 PyErr_Clear(); /* Don't know what else to do */
Guido van Rossum3f5da241990-12-20 15:06:42 +00003128 printf("\n");
Guido van Rossumcc229ea2000-05-04 00:55:17 +00003129 return 1;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003130}
Guido van Rossum3f5da241990-12-20 15:06:42 +00003131#endif
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003132
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00003133static void
Fred Drake5755ce62001-06-27 19:19:46 +00003134call_exc_trace(Py_tracefunc func, PyObject *self, PyFrameObject *f)
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00003135{
Guido van Rossumb209a111997-04-29 18:18:01 +00003136 PyObject *type, *value, *traceback, *arg;
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00003137 int err;
Guido van Rossumb209a111997-04-29 18:18:01 +00003138 PyErr_Fetch(&type, &value, &traceback);
Guido van Rossumbd9ccca1992-04-09 14:58:08 +00003139 if (value == NULL) {
Guido van Rossumb209a111997-04-29 18:18:01 +00003140 value = Py_None;
3141 Py_INCREF(value);
Guido van Rossumbd9ccca1992-04-09 14:58:08 +00003142 }
Raymond Hettinger8ae46892003-10-12 19:09:37 +00003143 arg = PyTuple_Pack(3, type, value, traceback);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003144 if (arg == NULL) {
Guido van Rossumb209a111997-04-29 18:18:01 +00003145 PyErr_Restore(type, value, traceback);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003146 return;
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00003147 }
Fred Drake5755ce62001-06-27 19:19:46 +00003148 err = call_trace(func, self, f, PyTrace_EXCEPTION, arg);
Guido van Rossumb209a111997-04-29 18:18:01 +00003149 Py_DECREF(arg);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003150 if (err == 0)
Guido van Rossumb209a111997-04-29 18:18:01 +00003151 PyErr_Restore(type, value, traceback);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003152 else {
Guido van Rossumb209a111997-04-29 18:18:01 +00003153 Py_XDECREF(type);
3154 Py_XDECREF(value);
3155 Py_XDECREF(traceback);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003156 }
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00003157}
3158
Fred Drake4ec5d562001-10-04 19:26:43 +00003159static void
3160call_trace_protected(Py_tracefunc func, PyObject *obj, PyFrameObject *frame,
Armin Rigo1c2d7e52005-09-20 18:34:01 +00003161 int what, PyObject *arg)
Fred Drake4ec5d562001-10-04 19:26:43 +00003162{
3163 PyObject *type, *value, *traceback;
3164 int err;
3165 PyErr_Fetch(&type, &value, &traceback);
Armin Rigo1c2d7e52005-09-20 18:34:01 +00003166 err = call_trace(func, obj, frame, what, arg);
Fred Drake4ec5d562001-10-04 19:26:43 +00003167 if (err == 0)
3168 PyErr_Restore(type, value, traceback);
3169 else {
3170 Py_XDECREF(type);
3171 Py_XDECREF(value);
3172 Py_XDECREF(traceback);
3173 }
3174}
3175
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00003176static int
Fred Drake5755ce62001-06-27 19:19:46 +00003177call_trace(Py_tracefunc func, PyObject *obj, PyFrameObject *frame,
3178 int what, PyObject *arg)
Guido van Rossum96a42c81992-01-12 02:29:51 +00003179{
Fred Drake5755ce62001-06-27 19:19:46 +00003180 register PyThreadState *tstate = frame->f_tstate;
3181 int result;
3182 if (tstate->tracing)
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00003183 return 0;
Guido van Rossuma027efa1997-05-05 20:56:21 +00003184 tstate->tracing++;
Fred Drake9e3ad782001-07-03 23:39:52 +00003185 tstate->use_tracing = 0;
Fred Drake5755ce62001-06-27 19:19:46 +00003186 result = func(obj, frame, what, arg);
Fred Drake9e3ad782001-07-03 23:39:52 +00003187 tstate->use_tracing = ((tstate->c_tracefunc != NULL)
3188 || (tstate->c_profilefunc != NULL));
Guido van Rossuma027efa1997-05-05 20:56:21 +00003189 tstate->tracing--;
Fred Drake5755ce62001-06-27 19:19:46 +00003190 return result;
Guido van Rossum96a42c81992-01-12 02:29:51 +00003191}
3192
Guido van Rossuma12fe4e2003-04-09 19:06:21 +00003193PyObject *
3194_PyEval_CallTracing(PyObject *func, PyObject *args)
3195{
3196 PyFrameObject *frame = PyEval_GetFrame();
3197 PyThreadState *tstate = frame->f_tstate;
3198 int save_tracing = tstate->tracing;
3199 int save_use_tracing = tstate->use_tracing;
3200 PyObject *result;
3201
3202 tstate->tracing = 0;
3203 tstate->use_tracing = ((tstate->c_tracefunc != NULL)
3204 || (tstate->c_profilefunc != NULL));
3205 result = PyObject_Call(func, args, NULL);
3206 tstate->tracing = save_tracing;
3207 tstate->use_tracing = save_use_tracing;
3208 return result;
3209}
3210
Michael W. Hudson006c7522002-11-08 13:08:46 +00003211static int
Tim Peters8a5c3c72004-04-05 19:36:21 +00003212maybe_call_line_trace(Py_tracefunc func, PyObject *obj,
Armin Rigobf57a142004-03-22 19:24:58 +00003213 PyFrameObject *frame, int *instr_lb, int *instr_ub,
3214 int *instr_prev)
Michael W. Hudsondd32a912002-08-15 14:59:02 +00003215{
3216 /* The theory of SET_LINENO-less tracing.
Tim Peters8a5c3c72004-04-05 19:36:21 +00003217
Michael W. Hudsondd32a912002-08-15 14:59:02 +00003218 In a nutshell, we use the co_lnotab field of the code object
3219 to tell when execution has moved onto a different line.
3220
3221 As mentioned above, the basic idea is so set things up so
3222 that
3223
3224 *instr_lb <= frame->f_lasti < *instr_ub
3225
3226 is true so long as execution does not change lines.
3227
3228 This is all fairly simple. Digging the information out of
3229 co_lnotab takes some work, but is conceptually clear.
3230
Michael W. Hudson53d58bb2002-08-30 13:09:51 +00003231 Somewhat harder to explain is why we don't *always* call the
3232 line trace function when the above test fails.
Michael W. Hudsondd32a912002-08-15 14:59:02 +00003233
3234 Consider this code:
3235
3236 1: def f(a):
3237 2: if a:
3238 3: print 1
3239 4: else:
3240 5: print 2
3241
3242 which compiles to this:
3243
3244 2 0 LOAD_FAST 0 (a)
3245 3 JUMP_IF_FALSE 9 (to 15)
Tim Peters8a5c3c72004-04-05 19:36:21 +00003246 6 POP_TOP
Michael W. Hudsondd32a912002-08-15 14:59:02 +00003247
3248 3 7 LOAD_CONST 1 (1)
Tim Peters8a5c3c72004-04-05 19:36:21 +00003249 10 PRINT_ITEM
3250 11 PRINT_NEWLINE
Michael W. Hudsondd32a912002-08-15 14:59:02 +00003251 12 JUMP_FORWARD 6 (to 21)
Tim Peters8a5c3c72004-04-05 19:36:21 +00003252 >> 15 POP_TOP
Michael W. Hudsondd32a912002-08-15 14:59:02 +00003253
3254 5 16 LOAD_CONST 2 (2)
Tim Peters8a5c3c72004-04-05 19:36:21 +00003255 19 PRINT_ITEM
3256 20 PRINT_NEWLINE
Michael W. Hudson53d58bb2002-08-30 13:09:51 +00003257 >> 21 LOAD_CONST 0 (None)
3258 24 RETURN_VALUE
Michael W. Hudsondd32a912002-08-15 14:59:02 +00003259
Michael W. Hudson02ff6a92002-09-11 15:36:32 +00003260 If 'a' is false, execution will jump to instruction at offset
Michael W. Hudsondd32a912002-08-15 14:59:02 +00003261 15 and the co_lnotab will claim that execution has moved to
3262 line 3. This is at best misleading. In this case we could
3263 associate the POP_TOP with line 4, but that doesn't make
3264 sense in all cases (I think).
3265
Michael W. Hudson53d58bb2002-08-30 13:09:51 +00003266 What we do is only call the line trace function if the co_lnotab
3267 indicates we have jumped to the *start* of a line, i.e. if the
3268 current instruction offset matches the offset given for the
3269 start of a line by the co_lnotab.
Michael W. Hudsondd32a912002-08-15 14:59:02 +00003270
Michael W. Hudson02ff6a92002-09-11 15:36:32 +00003271 This also takes care of the situation where 'a' is true.
Michael W. Hudson53d58bb2002-08-30 13:09:51 +00003272 Execution will jump from instruction offset 12 to offset 21.
3273 Then the co_lnotab would imply that execution has moved to line
3274 5, which is again misleading.
Michael W. Hudson02ff6a92002-09-11 15:36:32 +00003275
3276 Why do we set f_lineno when tracing? Well, consider the code
3277 above when 'a' is true. If stepping through this with 'n' in
3278 pdb, you would stop at line 1 with a "call" type event, then
3279 line events on lines 2 and 3, then a "return" type event -- but
3280 you would be shown line 5 during this event. This is a change
3281 from the behaviour in 2.2 and before, and I've found it
3282 confusing in practice. By setting and using f_lineno when
3283 tracing, one can report a line number different from that
3284 suggested by f_lasti on this one occasion where it's desirable.
Michael W. Hudsondd32a912002-08-15 14:59:02 +00003285 */
3286
Michael W. Hudson006c7522002-11-08 13:08:46 +00003287 int result = 0;
3288
Michael W. Hudson53d58bb2002-08-30 13:09:51 +00003289 if ((frame->f_lasti < *instr_lb || frame->f_lasti >= *instr_ub)) {
Michael W. Hudsondd32a912002-08-15 14:59:02 +00003290 PyCodeObject* co = frame->f_code;
Michael W. Hudson02ff6a92002-09-11 15:36:32 +00003291 int size, addr, line;
Michael W. Hudsondd32a912002-08-15 14:59:02 +00003292 unsigned char* p;
3293
Michael W. Hudson53d58bb2002-08-30 13:09:51 +00003294 size = PyString_GET_SIZE(co->co_lnotab) / 2;
3295 p = (unsigned char*)PyString_AS_STRING(co->co_lnotab);
Michael W. Hudsondd32a912002-08-15 14:59:02 +00003296
Michael W. Hudson53d58bb2002-08-30 13:09:51 +00003297 addr = 0;
Michael W. Hudson02ff6a92002-09-11 15:36:32 +00003298 line = co->co_firstlineno;
Michael W. Hudsondd32a912002-08-15 14:59:02 +00003299
3300 /* possible optimization: if f->f_lasti == instr_ub
3301 (likely to be a common case) then we already know
3302 instr_lb -- if we stored the matching value of p
3303 somwhere we could skip the first while loop. */
3304
Michael W. Hudsondd32a912002-08-15 14:59:02 +00003305 /* see comments in compile.c for the description of
3306 co_lnotab. A point to remember: increments to p
3307 should come in pairs -- although we don't care about
3308 the line increments here, treating them as byte
3309 increments gets confusing, to say the least. */
3310
Michael W. Hudson53d58bb2002-08-30 13:09:51 +00003311 while (size > 0) {
Michael W. Hudsondd32a912002-08-15 14:59:02 +00003312 if (addr + *p > frame->f_lasti)
3313 break;
3314 addr += *p++;
Michael W. Hudsonca803a02002-10-03 09:53:11 +00003315 if (*p) *instr_lb = addr;
Michael W. Hudson02ff6a92002-09-11 15:36:32 +00003316 line += *p++;
Michael W. Hudsondd32a912002-08-15 14:59:02 +00003317 --size;
3318 }
Michael W. Hudsonca803a02002-10-03 09:53:11 +00003319
Michael W. Hudson02ff6a92002-09-11 15:36:32 +00003320 if (addr == frame->f_lasti) {
3321 frame->f_lineno = line;
Tim Peters8a5c3c72004-04-05 19:36:21 +00003322 result = call_trace(func, obj, frame,
Michael W. Hudson006c7522002-11-08 13:08:46 +00003323 PyTrace_LINE, Py_None);
Michael W. Hudson02ff6a92002-09-11 15:36:32 +00003324 }
Michael W. Hudsonca803a02002-10-03 09:53:11 +00003325
Michael W. Hudsondd32a912002-08-15 14:59:02 +00003326 if (size > 0) {
Raymond Hettinger5bed4562004-04-10 23:34:17 +00003327 while (--size >= 0) {
Michael W. Hudsondd32a912002-08-15 14:59:02 +00003328 addr += *p++;
3329 if (*p++)
3330 break;
3331 }
3332 *instr_ub = addr;
3333 }
3334 else {
3335 *instr_ub = INT_MAX;
3336 }
3337 }
Armin Rigobf57a142004-03-22 19:24:58 +00003338 else if (frame->f_lasti <= *instr_prev) {
3339 /* jumping back in the same line forces a trace event */
Tim Peters8a5c3c72004-04-05 19:36:21 +00003340 result = call_trace(func, obj, frame,
Armin Rigobf57a142004-03-22 19:24:58 +00003341 PyTrace_LINE, Py_None);
3342 }
3343 *instr_prev = frame->f_lasti;
Michael W. Hudson006c7522002-11-08 13:08:46 +00003344 return result;
Michael W. Hudsondd32a912002-08-15 14:59:02 +00003345}
3346
Fred Drake5755ce62001-06-27 19:19:46 +00003347void
3348PyEval_SetProfile(Py_tracefunc func, PyObject *arg)
Fred Draked0838392001-06-16 21:02:31 +00003349{
Nicholas Bastine5662ae2004-03-24 22:22:12 +00003350 PyThreadState *tstate = PyThreadState_GET();
Fred Drake5755ce62001-06-27 19:19:46 +00003351 PyObject *temp = tstate->c_profileobj;
3352 Py_XINCREF(arg);
3353 tstate->c_profilefunc = NULL;
3354 tstate->c_profileobj = NULL;
Brett Cannon55fa66d2005-06-25 07:07:35 +00003355 /* Must make sure that tracing is not ignored if 'temp' is freed */
Fred Drake9e3ad782001-07-03 23:39:52 +00003356 tstate->use_tracing = tstate->c_tracefunc != NULL;
Fred Drake5755ce62001-06-27 19:19:46 +00003357 Py_XDECREF(temp);
3358 tstate->c_profilefunc = func;
3359 tstate->c_profileobj = arg;
Brett Cannon55fa66d2005-06-25 07:07:35 +00003360 /* Flag that tracing or profiling is turned on */
Fred Drake9e3ad782001-07-03 23:39:52 +00003361 tstate->use_tracing = (func != NULL) || (tstate->c_tracefunc != NULL);
Fred Drake5755ce62001-06-27 19:19:46 +00003362}
3363
3364void
3365PyEval_SetTrace(Py_tracefunc func, PyObject *arg)
3366{
Nicholas Bastine5662ae2004-03-24 22:22:12 +00003367 PyThreadState *tstate = PyThreadState_GET();
Fred Drake5755ce62001-06-27 19:19:46 +00003368 PyObject *temp = tstate->c_traceobj;
3369 Py_XINCREF(arg);
3370 tstate->c_tracefunc = NULL;
3371 tstate->c_traceobj = NULL;
Brett Cannon55fa66d2005-06-25 07:07:35 +00003372 /* Must make sure that profiling is not ignored if 'temp' is freed */
Fred Drake9e3ad782001-07-03 23:39:52 +00003373 tstate->use_tracing = tstate->c_profilefunc != NULL;
Fred Drake5755ce62001-06-27 19:19:46 +00003374 Py_XDECREF(temp);
3375 tstate->c_tracefunc = func;
3376 tstate->c_traceobj = arg;
Brett Cannon55fa66d2005-06-25 07:07:35 +00003377 /* Flag that tracing or profiling is turned on */
Fred Drake9e3ad782001-07-03 23:39:52 +00003378 tstate->use_tracing = ((func != NULL)
3379 || (tstate->c_profilefunc != NULL));
Fred Draked0838392001-06-16 21:02:31 +00003380}
3381
Guido van Rossumb209a111997-04-29 18:18:01 +00003382PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003383PyEval_GetBuiltins(void)
Guido van Rossum6135a871995-01-09 17:53:26 +00003384{
Guido van Rossum6297a7a2003-02-19 15:53:17 +00003385 PyFrameObject *current_frame = PyEval_GetFrame();
Guido van Rossum6135a871995-01-09 17:53:26 +00003386 if (current_frame == NULL)
Nicholas Bastine5662ae2004-03-24 22:22:12 +00003387 return PyThreadState_GET()->interp->builtins;
Guido van Rossum6135a871995-01-09 17:53:26 +00003388 else
3389 return current_frame->f_builtins;
3390}
3391
Guido van Rossumb209a111997-04-29 18:18:01 +00003392PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003393PyEval_GetLocals(void)
Guido van Rossum5b722181993-03-30 17:46:03 +00003394{
Guido van Rossum6297a7a2003-02-19 15:53:17 +00003395 PyFrameObject *current_frame = PyEval_GetFrame();
Guido van Rossum5b722181993-03-30 17:46:03 +00003396 if (current_frame == NULL)
3397 return NULL;
Guido van Rossumb209a111997-04-29 18:18:01 +00003398 PyFrame_FastToLocals(current_frame);
Guido van Rossum5b722181993-03-30 17:46:03 +00003399 return current_frame->f_locals;
3400}
3401
Guido van Rossumb209a111997-04-29 18:18:01 +00003402PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003403PyEval_GetGlobals(void)
Guido van Rossum3f5da241990-12-20 15:06:42 +00003404{
Guido van Rossum6297a7a2003-02-19 15:53:17 +00003405 PyFrameObject *current_frame = PyEval_GetFrame();
Guido van Rossum3f5da241990-12-20 15:06:42 +00003406 if (current_frame == NULL)
3407 return NULL;
3408 else
3409 return current_frame->f_globals;
3410}
3411
Guido van Rossum6297a7a2003-02-19 15:53:17 +00003412PyFrameObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003413PyEval_GetFrame(void)
Guido van Rossume59214e1994-08-30 08:01:59 +00003414{
Nicholas Bastine5662ae2004-03-24 22:22:12 +00003415 PyThreadState *tstate = PyThreadState_GET();
Guido van Rossum6297a7a2003-02-19 15:53:17 +00003416 return _PyThreadState_GetFrame(tstate);
Guido van Rossume59214e1994-08-30 08:01:59 +00003417}
3418
Guido van Rossum6135a871995-01-09 17:53:26 +00003419int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003420PyEval_GetRestricted(void)
Guido van Rossum6135a871995-01-09 17:53:26 +00003421{
Guido van Rossum6297a7a2003-02-19 15:53:17 +00003422 PyFrameObject *current_frame = PyEval_GetFrame();
Guido van Rossum6135a871995-01-09 17:53:26 +00003423 return current_frame == NULL ? 0 : current_frame->f_restricted;
3424}
3425
Guido van Rossumbe270261997-05-22 22:26:18 +00003426int
Tim Peters5ba58662001-07-16 02:29:45 +00003427PyEval_MergeCompilerFlags(PyCompilerFlags *cf)
Jeremy Hylton061d1062001-03-22 02:32:48 +00003428{
Guido van Rossum6297a7a2003-02-19 15:53:17 +00003429 PyFrameObject *current_frame = PyEval_GetFrame();
Just van Rossum3aaf42c2003-02-10 08:21:10 +00003430 int result = cf->cf_flags != 0;
Tim Peters5ba58662001-07-16 02:29:45 +00003431
3432 if (current_frame != NULL) {
3433 const int codeflags = current_frame->f_code->co_flags;
Tim Peterse2c18e92001-08-17 20:47:47 +00003434 const int compilerflags = codeflags & PyCF_MASK;
3435 if (compilerflags) {
Tim Peters5ba58662001-07-16 02:29:45 +00003436 result = 1;
Tim Peterse2c18e92001-08-17 20:47:47 +00003437 cf->cf_flags |= compilerflags;
Tim Peters5ba58662001-07-16 02:29:45 +00003438 }
Neil Schemenauerc24ea082002-03-22 23:53:36 +00003439#if 0 /* future keyword */
Martin v. Löwis7198a522002-01-01 19:59:11 +00003440 if (codeflags & CO_GENERATOR_ALLOWED) {
3441 result = 1;
3442 cf->cf_flags |= CO_GENERATOR_ALLOWED;
3443 }
Neil Schemenauerc24ea082002-03-22 23:53:36 +00003444#endif
Tim Peters5ba58662001-07-16 02:29:45 +00003445 }
3446 return result;
Jeremy Hylton061d1062001-03-22 02:32:48 +00003447}
3448
3449int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003450Py_FlushLine(void)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003451{
Guido van Rossumb209a111997-04-29 18:18:01 +00003452 PyObject *f = PySys_GetObject("stdout");
Guido van Rossumbe270261997-05-22 22:26:18 +00003453 if (f == NULL)
3454 return 0;
3455 if (!PyFile_SoftSpace(f, 0))
3456 return 0;
3457 return PyFile_WriteString("\n", f);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003458}
3459
Guido van Rossum3f5da241990-12-20 15:06:42 +00003460
Guido van Rossum681d79a1995-07-18 14:51:37 +00003461/* External interface to call any callable object.
3462 The arg must be a tuple or NULL. */
Guido van Rossum83bf35c1991-07-27 21:32:34 +00003463
Guido van Rossumd7ed6831997-08-30 15:02:50 +00003464#undef PyEval_CallObject
3465/* for backward compatibility: export this interface */
3466
Guido van Rossumb209a111997-04-29 18:18:01 +00003467PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003468PyEval_CallObject(PyObject *func, PyObject *arg)
Guido van Rossum83bf35c1991-07-27 21:32:34 +00003469{
Guido van Rossumb209a111997-04-29 18:18:01 +00003470 return PyEval_CallObjectWithKeywords(func, arg, (PyObject *)NULL);
Guido van Rossum681d79a1995-07-18 14:51:37 +00003471}
Guido van Rossumd7ed6831997-08-30 15:02:50 +00003472#define PyEval_CallObject(func,arg) \
3473 PyEval_CallObjectWithKeywords(func, arg, (PyObject *)NULL)
Guido van Rossume59214e1994-08-30 08:01:59 +00003474
Guido van Rossumb209a111997-04-29 18:18:01 +00003475PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003476PyEval_CallObjectWithKeywords(PyObject *func, PyObject *arg, PyObject *kw)
Guido van Rossum681d79a1995-07-18 14:51:37 +00003477{
Jeremy Hylton52820442001-01-03 23:52:36 +00003478 PyObject *result;
Guido van Rossum681d79a1995-07-18 14:51:37 +00003479
3480 if (arg == NULL)
Guido van Rossumb209a111997-04-29 18:18:01 +00003481 arg = PyTuple_New(0);
3482 else if (!PyTuple_Check(arg)) {
Guido van Rossuma027efa1997-05-05 20:56:21 +00003483 PyErr_SetString(PyExc_TypeError,
3484 "argument list must be a tuple");
Guido van Rossum681d79a1995-07-18 14:51:37 +00003485 return NULL;
3486 }
3487 else
Guido van Rossumb209a111997-04-29 18:18:01 +00003488 Py_INCREF(arg);
Guido van Rossum681d79a1995-07-18 14:51:37 +00003489
Guido van Rossumb209a111997-04-29 18:18:01 +00003490 if (kw != NULL && !PyDict_Check(kw)) {
Guido van Rossuma027efa1997-05-05 20:56:21 +00003491 PyErr_SetString(PyExc_TypeError,
3492 "keyword list must be a dictionary");
Guido van Rossum25826c92000-04-21 21:17:39 +00003493 Py_DECREF(arg);
Guido van Rossume3e61c11995-08-04 04:14:47 +00003494 return NULL;
3495 }
3496
Tim Peters6d6c1a32001-08-02 04:15:00 +00003497 result = PyObject_Call(func, arg, kw);
Guido van Rossumb209a111997-04-29 18:18:01 +00003498 Py_DECREF(arg);
Jeremy Hylton52820442001-01-03 23:52:36 +00003499 return result;
3500}
3501
Jeremy Hyltonaf68c872005-12-10 18:50:16 +00003502const char *
Tim Peters6d6c1a32001-08-02 04:15:00 +00003503PyEval_GetFuncName(PyObject *func)
Jeremy Hylton512a2372001-04-11 13:52:29 +00003504{
3505 if (PyMethod_Check(func))
Tim Peters6d6c1a32001-08-02 04:15:00 +00003506 return PyEval_GetFuncName(PyMethod_GET_FUNCTION(func));
Jeremy Hylton512a2372001-04-11 13:52:29 +00003507 else if (PyFunction_Check(func))
3508 return PyString_AsString(((PyFunctionObject*)func)->func_name);
3509 else if (PyCFunction_Check(func))
3510 return ((PyCFunctionObject*)func)->m_ml->ml_name;
3511 else if (PyClass_Check(func))
3512 return PyString_AsString(((PyClassObject*)func)->cl_name);
3513 else if (PyInstance_Check(func)) {
3514 return PyString_AsString(
3515 ((PyInstanceObject*)func)->in_class->cl_name);
3516 } else {
3517 return func->ob_type->tp_name;
3518 }
3519}
3520
Jeremy Hyltonaf68c872005-12-10 18:50:16 +00003521const char *
Tim Peters6d6c1a32001-08-02 04:15:00 +00003522PyEval_GetFuncDesc(PyObject *func)
Jeremy Hylton512a2372001-04-11 13:52:29 +00003523{
3524 if (PyMethod_Check(func))
3525 return "()";
3526 else if (PyFunction_Check(func))
3527 return "()";
3528 else if (PyCFunction_Check(func))
3529 return "()";
3530 else if (PyClass_Check(func))
3531 return " constructor";
3532 else if (PyInstance_Check(func)) {
3533 return " instance";
3534 } else {
3535 return " object";
3536 }
3537}
3538
Neal Norwitzaddfe0c2002-11-10 14:33:26 +00003539static void
Jeremy Hylton192690e2002-08-16 18:36:11 +00003540err_args(PyObject *func, int flags, int nargs)
3541{
3542 if (flags & METH_NOARGS)
Tim Peters8a5c3c72004-04-05 19:36:21 +00003543 PyErr_Format(PyExc_TypeError,
Guido van Rossum86c659a2002-08-23 14:11:35 +00003544 "%.200s() takes no arguments (%d given)",
Tim Peters8a5c3c72004-04-05 19:36:21 +00003545 ((PyCFunctionObject *)func)->m_ml->ml_name,
Jeremy Hylton192690e2002-08-16 18:36:11 +00003546 nargs);
3547 else
Tim Peters8a5c3c72004-04-05 19:36:21 +00003548 PyErr_Format(PyExc_TypeError,
Guido van Rossum86c659a2002-08-23 14:11:35 +00003549 "%.200s() takes exactly one argument (%d given)",
Tim Peters8a5c3c72004-04-05 19:36:21 +00003550 ((PyCFunctionObject *)func)->m_ml->ml_name,
Jeremy Hylton192690e2002-08-16 18:36:11 +00003551 nargs);
3552}
3553
Armin Rigo1c2d7e52005-09-20 18:34:01 +00003554#define C_TRACE(x, call) \
Nicholas Bastind858a772004-06-25 23:31:06 +00003555if (tstate->use_tracing && tstate->c_profilefunc) { \
3556 if (call_trace(tstate->c_profilefunc, \
3557 tstate->c_profileobj, \
3558 tstate->frame, PyTrace_C_CALL, \
Armin Rigo1c2d7e52005-09-20 18:34:01 +00003559 func)) { \
3560 x = NULL; \
3561 } \
3562 else { \
3563 x = call; \
3564 if (tstate->c_profilefunc != NULL) { \
3565 if (x == NULL) { \
3566 call_trace_protected(tstate->c_profilefunc, \
3567 tstate->c_profileobj, \
3568 tstate->frame, PyTrace_C_EXCEPTION, \
3569 func); \
3570 /* XXX should pass (type, value, tb) */ \
3571 } else { \
3572 if (call_trace(tstate->c_profilefunc, \
3573 tstate->c_profileobj, \
3574 tstate->frame, PyTrace_C_RETURN, \
3575 func)) { \
3576 Py_DECREF(x); \
3577 x = NULL; \
3578 } \
3579 } \
Nicholas Bastinc69ebe82004-03-24 21:57:10 +00003580 } \
Nicholas Bastind858a772004-06-25 23:31:06 +00003581 } \
3582} else { \
Armin Rigo1c2d7e52005-09-20 18:34:01 +00003583 x = call; \
Nicholas Bastinc69ebe82004-03-24 21:57:10 +00003584 }
3585
Jeremy Hyltone8c04322002-08-16 17:47:26 +00003586static PyObject *
Martin v. Löwisf30d60e2004-06-08 08:17:44 +00003587call_function(PyObject ***pp_stack, int oparg
3588#ifdef WITH_TSC
3589 , uint64* pintr0, uint64* pintr1
3590#endif
3591 )
Jeremy Hyltone8c04322002-08-16 17:47:26 +00003592{
3593 int na = oparg & 0xff;
3594 int nk = (oparg>>8) & 0xff;
3595 int n = na + 2 * nk;
3596 PyObject **pfunc = (*pp_stack) - n - 1;
3597 PyObject *func = *pfunc;
3598 PyObject *x, *w;
3599
Jeremy Hylton985eba52003-02-05 23:13:00 +00003600 /* Always dispatch PyCFunction first, because these are
3601 presumed to be the most frequent callable object.
Jeremy Hyltone8c04322002-08-16 17:47:26 +00003602 */
3603 if (PyCFunction_Check(func) && nk == 0) {
3604 int flags = PyCFunction_GET_FLAGS(func);
Nicholas Bastind858a772004-06-25 23:31:06 +00003605 PyThreadState *tstate = PyThreadState_GET();
Raymond Hettingera7f56bc2004-06-26 04:34:33 +00003606
3607 PCALL(PCALL_CFUNCTION);
Jeremy Hylton192690e2002-08-16 18:36:11 +00003608 if (flags & (METH_NOARGS | METH_O)) {
3609 PyCFunction meth = PyCFunction_GET_FUNCTION(func);
3610 PyObject *self = PyCFunction_GET_SELF(func);
Nicholas Bastinc69ebe82004-03-24 21:57:10 +00003611 if (flags & METH_NOARGS && na == 0) {
Armin Rigo1c2d7e52005-09-20 18:34:01 +00003612 C_TRACE(x, (*meth)(self,NULL));
Nicholas Bastinc69ebe82004-03-24 21:57:10 +00003613 }
Jeremy Hylton192690e2002-08-16 18:36:11 +00003614 else if (flags & METH_O && na == 1) {
3615 PyObject *arg = EXT_POP(*pp_stack);
Armin Rigo1c2d7e52005-09-20 18:34:01 +00003616 C_TRACE(x, (*meth)(self,arg));
Jeremy Hylton192690e2002-08-16 18:36:11 +00003617 Py_DECREF(arg);
3618 }
3619 else {
3620 err_args(func, flags, na);
3621 x = NULL;
3622 }
3623 }
3624 else {
Jeremy Hyltone8c04322002-08-16 17:47:26 +00003625 PyObject *callargs;
3626 callargs = load_args(pp_stack, na);
Michael W. Hudson75eabd22005-01-18 15:56:11 +00003627 READ_TIMESTAMP(*pintr0);
Armin Rigo1c2d7e52005-09-20 18:34:01 +00003628 C_TRACE(x, PyCFunction_Call(func,callargs,NULL));
Michael W. Hudson75eabd22005-01-18 15:56:11 +00003629 READ_TIMESTAMP(*pintr1);
Tim Peters8a5c3c72004-04-05 19:36:21 +00003630 Py_XDECREF(callargs);
3631 }
Jeremy Hyltone8c04322002-08-16 17:47:26 +00003632 } else {
3633 if (PyMethod_Check(func) && PyMethod_GET_SELF(func) != NULL) {
3634 /* optimize access to bound methods */
3635 PyObject *self = PyMethod_GET_SELF(func);
Jeremy Hylton985eba52003-02-05 23:13:00 +00003636 PCALL(PCALL_METHOD);
3637 PCALL(PCALL_BOUND_METHOD);
Jeremy Hyltone8c04322002-08-16 17:47:26 +00003638 Py_INCREF(self);
3639 func = PyMethod_GET_FUNCTION(func);
3640 Py_INCREF(func);
3641 Py_DECREF(*pfunc);
3642 *pfunc = self;
3643 na++;
3644 n++;
3645 } else
3646 Py_INCREF(func);
Michael W. Hudson75eabd22005-01-18 15:56:11 +00003647 READ_TIMESTAMP(*pintr0);
Jeremy Hyltone8c04322002-08-16 17:47:26 +00003648 if (PyFunction_Check(func))
3649 x = fast_function(func, pp_stack, n, na, nk);
Tim Peters8a5c3c72004-04-05 19:36:21 +00003650 else
Jeremy Hyltone8c04322002-08-16 17:47:26 +00003651 x = do_call(func, pp_stack, na, nk);
Michael W. Hudson75eabd22005-01-18 15:56:11 +00003652 READ_TIMESTAMP(*pintr1);
Jeremy Hyltone8c04322002-08-16 17:47:26 +00003653 Py_DECREF(func);
3654 }
Tim Peters8a5c3c72004-04-05 19:36:21 +00003655
Thomas Wouters03ca23d2006-02-10 22:51:45 +00003656 /* Clear the stack of the function object and the arguments,
3657 in case they weren't consumed already */
Jeremy Hyltone8c04322002-08-16 17:47:26 +00003658 while ((*pp_stack) > pfunc) {
3659 w = EXT_POP(*pp_stack);
3660 Py_DECREF(w);
Jeremy Hylton985eba52003-02-05 23:13:00 +00003661 PCALL(PCALL_POP);
Jeremy Hyltone8c04322002-08-16 17:47:26 +00003662 }
3663 return x;
3664}
3665
Jeremy Hylton192690e2002-08-16 18:36:11 +00003666/* The fast_function() function optimize calls for which no argument
Jeremy Hylton52820442001-01-03 23:52:36 +00003667 tuple is necessary; the objects are passed directly from the stack.
Jeremy Hylton985eba52003-02-05 23:13:00 +00003668 For the simplest case -- a function that takes only positional
3669 arguments and is called with only positional arguments -- it
3670 inlines the most primitive frame setup code from
3671 PyEval_EvalCodeEx(), which vastly reduces the checks that must be
3672 done before evaluating the frame.
Jeremy Hylton52820442001-01-03 23:52:36 +00003673*/
3674
3675static PyObject *
Guido van Rossumac7be682001-01-17 15:42:30 +00003676fast_function(PyObject *func, PyObject ***pp_stack, int n, int na, int nk)
Jeremy Hylton52820442001-01-03 23:52:36 +00003677{
Jeremy Hylton985eba52003-02-05 23:13:00 +00003678 PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
Jeremy Hylton52820442001-01-03 23:52:36 +00003679 PyObject *globals = PyFunction_GET_GLOBALS(func);
3680 PyObject *argdefs = PyFunction_GET_DEFAULTS(func);
3681 PyObject **d = NULL;
3682 int nd = 0;
3683
Jeremy Hylton985eba52003-02-05 23:13:00 +00003684 PCALL(PCALL_FUNCTION);
3685 PCALL(PCALL_FAST_FUNCTION);
Raymond Hettinger40174c32003-05-31 07:04:16 +00003686 if (argdefs == NULL && co->co_argcount == n && nk==0 &&
Jeremy Hylton985eba52003-02-05 23:13:00 +00003687 co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) {
3688 PyFrameObject *f;
3689 PyObject *retval = NULL;
3690 PyThreadState *tstate = PyThreadState_GET();
3691 PyObject **fastlocals, **stack;
3692 int i;
3693
3694 PCALL(PCALL_FASTER_FUNCTION);
3695 assert(globals != NULL);
3696 /* XXX Perhaps we should create a specialized
3697 PyFrame_New() that doesn't take locals, but does
3698 take builtins without sanity checking them.
3699 */
3700 f = PyFrame_New(tstate, co, globals, NULL);
3701 if (f == NULL)
3702 return NULL;
3703
3704 fastlocals = f->f_localsplus;
3705 stack = (*pp_stack) - n;
3706
3707 for (i = 0; i < n; i++) {
3708 Py_INCREF(*stack);
3709 fastlocals[i] = *stack++;
3710 }
Phillip J. Eby0d6615f2005-08-02 00:46:46 +00003711 retval = PyEval_EvalFrameEx(f,0);
Jeremy Hylton985eba52003-02-05 23:13:00 +00003712 assert(tstate != NULL);
3713 ++tstate->recursion_depth;
3714 Py_DECREF(f);
3715 --tstate->recursion_depth;
3716 return retval;
3717 }
Jeremy Hylton52820442001-01-03 23:52:36 +00003718 if (argdefs != NULL) {
3719 d = &PyTuple_GET_ITEM(argdefs, 0);
3720 nd = ((PyTupleObject *)argdefs)->ob_size;
3721 }
Jeremy Hylton985eba52003-02-05 23:13:00 +00003722 return PyEval_EvalCodeEx(co, globals,
3723 (PyObject *)NULL, (*pp_stack)-n, na,
3724 (*pp_stack)-2*nk, nk, d, nd,
3725 PyFunction_GET_CLOSURE(func));
Jeremy Hylton52820442001-01-03 23:52:36 +00003726}
3727
3728static PyObject *
Ka-Ping Yee20579702001-01-15 22:14:16 +00003729update_keyword_args(PyObject *orig_kwdict, int nk, PyObject ***pp_stack,
3730 PyObject *func)
Jeremy Hylton52820442001-01-03 23:52:36 +00003731{
3732 PyObject *kwdict = NULL;
3733 if (orig_kwdict == NULL)
3734 kwdict = PyDict_New();
3735 else {
3736 kwdict = PyDict_Copy(orig_kwdict);
3737 Py_DECREF(orig_kwdict);
3738 }
3739 if (kwdict == NULL)
3740 return NULL;
Raymond Hettinger5bed4562004-04-10 23:34:17 +00003741 while (--nk >= 0) {
Jeremy Hylton52820442001-01-03 23:52:36 +00003742 int err;
3743 PyObject *value = EXT_POP(*pp_stack);
3744 PyObject *key = EXT_POP(*pp_stack);
3745 if (PyDict_GetItem(kwdict, key) != NULL) {
Guido van Rossumac7be682001-01-17 15:42:30 +00003746 PyErr_Format(PyExc_TypeError,
Ka-Ping Yee20579702001-01-15 22:14:16 +00003747 "%.200s%s got multiple values "
Jeremy Hylton512a2372001-04-11 13:52:29 +00003748 "for keyword argument '%.200s'",
Tim Peters6d6c1a32001-08-02 04:15:00 +00003749 PyEval_GetFuncName(func),
3750 PyEval_GetFuncDesc(func),
Jeremy Hylton512a2372001-04-11 13:52:29 +00003751 PyString_AsString(key));
Jeremy Hylton52820442001-01-03 23:52:36 +00003752 Py_DECREF(key);
3753 Py_DECREF(value);
3754 Py_DECREF(kwdict);
3755 return NULL;
3756 }
3757 err = PyDict_SetItem(kwdict, key, value);
3758 Py_DECREF(key);
3759 Py_DECREF(value);
3760 if (err) {
3761 Py_DECREF(kwdict);
3762 return NULL;
3763 }
3764 }
3765 return kwdict;
3766}
3767
3768static PyObject *
3769update_star_args(int nstack, int nstar, PyObject *stararg,
3770 PyObject ***pp_stack)
3771{
3772 PyObject *callargs, *w;
3773
3774 callargs = PyTuple_New(nstack + nstar);
3775 if (callargs == NULL) {
3776 return NULL;
3777 }
3778 if (nstar) {
3779 int i;
3780 for (i = 0; i < nstar; i++) {
3781 PyObject *a = PyTuple_GET_ITEM(stararg, i);
3782 Py_INCREF(a);
3783 PyTuple_SET_ITEM(callargs, nstack + i, a);
3784 }
3785 }
Raymond Hettinger5bed4562004-04-10 23:34:17 +00003786 while (--nstack >= 0) {
Jeremy Hylton52820442001-01-03 23:52:36 +00003787 w = EXT_POP(*pp_stack);
3788 PyTuple_SET_ITEM(callargs, nstack, w);
3789 }
3790 return callargs;
3791}
3792
3793static PyObject *
3794load_args(PyObject ***pp_stack, int na)
3795{
3796 PyObject *args = PyTuple_New(na);
3797 PyObject *w;
3798
3799 if (args == NULL)
3800 return NULL;
Raymond Hettinger5bed4562004-04-10 23:34:17 +00003801 while (--na >= 0) {
Jeremy Hylton52820442001-01-03 23:52:36 +00003802 w = EXT_POP(*pp_stack);
3803 PyTuple_SET_ITEM(args, na, w);
3804 }
3805 return args;
3806}
3807
3808static PyObject *
3809do_call(PyObject *func, PyObject ***pp_stack, int na, int nk)
3810{
3811 PyObject *callargs = NULL;
3812 PyObject *kwdict = NULL;
3813 PyObject *result = NULL;
3814
3815 if (nk > 0) {
Ka-Ping Yee20579702001-01-15 22:14:16 +00003816 kwdict = update_keyword_args(NULL, nk, pp_stack, func);
Jeremy Hylton52820442001-01-03 23:52:36 +00003817 if (kwdict == NULL)
3818 goto call_fail;
3819 }
3820 callargs = load_args(pp_stack, na);
3821 if (callargs == NULL)
3822 goto call_fail;
Jeremy Hylton985eba52003-02-05 23:13:00 +00003823#ifdef CALL_PROFILE
3824 /* At this point, we have to look at the type of func to
3825 update the call stats properly. Do it here so as to avoid
3826 exposing the call stats machinery outside ceval.c
3827 */
3828 if (PyFunction_Check(func))
3829 PCALL(PCALL_FUNCTION);
3830 else if (PyMethod_Check(func))
3831 PCALL(PCALL_METHOD);
3832 else if (PyType_Check(func))
3833 PCALL(PCALL_TYPE);
3834 else
3835 PCALL(PCALL_OTHER);
3836#endif
Tim Peters6d6c1a32001-08-02 04:15:00 +00003837 result = PyObject_Call(func, callargs, kwdict);
Jeremy Hylton52820442001-01-03 23:52:36 +00003838 call_fail:
3839 Py_XDECREF(callargs);
3840 Py_XDECREF(kwdict);
3841 return result;
3842}
3843
3844static PyObject *
3845ext_do_call(PyObject *func, PyObject ***pp_stack, int flags, int na, int nk)
3846{
3847 int nstar = 0;
3848 PyObject *callargs = NULL;
3849 PyObject *stararg = NULL;
3850 PyObject *kwdict = NULL;
3851 PyObject *result = NULL;
3852
3853 if (flags & CALL_FLAG_KW) {
3854 kwdict = EXT_POP(*pp_stack);
3855 if (!(kwdict && PyDict_Check(kwdict))) {
Ka-Ping Yee20579702001-01-15 22:14:16 +00003856 PyErr_Format(PyExc_TypeError,
Jeremy Hylton512a2372001-04-11 13:52:29 +00003857 "%s%s argument after ** "
3858 "must be a dictionary",
Tim Peters6d6c1a32001-08-02 04:15:00 +00003859 PyEval_GetFuncName(func),
3860 PyEval_GetFuncDesc(func));
Jeremy Hylton52820442001-01-03 23:52:36 +00003861 goto ext_call_fail;
3862 }
3863 }
3864 if (flags & CALL_FLAG_VAR) {
3865 stararg = EXT_POP(*pp_stack);
3866 if (!PyTuple_Check(stararg)) {
3867 PyObject *t = NULL;
3868 t = PySequence_Tuple(stararg);
3869 if (t == NULL) {
Jeremy Hylton512a2372001-04-11 13:52:29 +00003870 if (PyErr_ExceptionMatches(PyExc_TypeError)) {
3871 PyErr_Format(PyExc_TypeError,
3872 "%s%s argument after * "
3873 "must be a sequence",
Tim Peters6d6c1a32001-08-02 04:15:00 +00003874 PyEval_GetFuncName(func),
3875 PyEval_GetFuncDesc(func));
Jeremy Hylton512a2372001-04-11 13:52:29 +00003876 }
Jeremy Hylton52820442001-01-03 23:52:36 +00003877 goto ext_call_fail;
3878 }
3879 Py_DECREF(stararg);
3880 stararg = t;
3881 }
3882 nstar = PyTuple_GET_SIZE(stararg);
3883 }
3884 if (nk > 0) {
Ka-Ping Yee20579702001-01-15 22:14:16 +00003885 kwdict = update_keyword_args(kwdict, nk, pp_stack, func);
Jeremy Hylton52820442001-01-03 23:52:36 +00003886 if (kwdict == NULL)
3887 goto ext_call_fail;
3888 }
3889 callargs = update_star_args(na, nstar, stararg, pp_stack);
3890 if (callargs == NULL)
3891 goto ext_call_fail;
Jeremy Hylton985eba52003-02-05 23:13:00 +00003892#ifdef CALL_PROFILE
3893 /* At this point, we have to look at the type of func to
3894 update the call stats properly. Do it here so as to avoid
3895 exposing the call stats machinery outside ceval.c
3896 */
3897 if (PyFunction_Check(func))
3898 PCALL(PCALL_FUNCTION);
3899 else if (PyMethod_Check(func))
3900 PCALL(PCALL_METHOD);
3901 else if (PyType_Check(func))
3902 PCALL(PCALL_TYPE);
3903 else
3904 PCALL(PCALL_OTHER);
3905#endif
Tim Peters6d6c1a32001-08-02 04:15:00 +00003906 result = PyObject_Call(func, callargs, kwdict);
Jeremy Hylton52820442001-01-03 23:52:36 +00003907 ext_call_fail:
3908 Py_XDECREF(callargs);
3909 Py_XDECREF(kwdict);
3910 Py_XDECREF(stararg);
3911 return result;
3912}
3913
Tim Peterscb479e72001-12-16 19:11:44 +00003914/* Extract a slice index from a PyInt or PyLong, and store in *pi.
Martin v. Löwisdde99d22006-02-17 15:57:41 +00003915 Silently reduce values larger than PY_SSIZE_T_MAX to PY_SSIZE_T_MAX,
3916 and silently boost values less than -PY_SSIZE_T_MAX to 0.
3917 Return 0 on error, 1 on success.
Tim Peterscb479e72001-12-16 19:11:44 +00003918*/
Tim Petersb5196382001-12-16 19:44:20 +00003919/* Note: If v is NULL, return success without storing into *pi. This
3920 is because_PyEval_SliceIndex() is called by apply_slice(), which can be
3921 called by the SLICE opcode with v and/or w equal to NULL.
Tim Peterscb479e72001-12-16 19:11:44 +00003922*/
Guido van Rossum20c6add2000-05-08 14:06:50 +00003923int
Martin v. Löwis18e16552006-02-15 17:27:45 +00003924_PyEval_SliceIndex(PyObject *v, Py_ssize_t *pi)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003925{
Tim Petersb5196382001-12-16 19:44:20 +00003926 if (v != NULL) {
Martin v. Löwisdde99d22006-02-17 15:57:41 +00003927 Py_ssize_t x;
Andrew M. Kuchling2194b162000-02-23 22:18:48 +00003928 if (PyInt_Check(v)) {
3929 x = PyInt_AsLong(v);
3930 } else if (PyLong_Check(v)) {
Martin v. Löwisdde99d22006-02-17 15:57:41 +00003931 x = PyInt_AsSsize_t(v);
Andrew M. Kuchling2194b162000-02-23 22:18:48 +00003932 if (x==-1 && PyErr_Occurred()) {
3933 PyObject *long_zero;
Guido van Rossumac7be682001-01-17 15:42:30 +00003934 int cmp;
Andrew M. Kuchling2194b162000-02-23 22:18:48 +00003935
Guido van Rossumac7be682001-01-17 15:42:30 +00003936 if (!PyErr_ExceptionMatches(
3937 PyExc_OverflowError)) {
3938 /* It's not an overflow error, so just
Andrew M. Kuchling2194b162000-02-23 22:18:48 +00003939 signal an error */
Guido van Rossum20c6add2000-05-08 14:06:50 +00003940 return 0;
Andrew M. Kuchling2194b162000-02-23 22:18:48 +00003941 }
3942
Guido van Rossumac7be682001-01-17 15:42:30 +00003943 /* Clear the OverflowError */
3944 PyErr_Clear();
3945
3946 /* It's an overflow error, so we need to
3947 check the sign of the long integer,
Martin v. Löwisdde99d22006-02-17 15:57:41 +00003948 set the value to PY_SSIZE_T_MAX or
3949 -PY_SSIZE_T_MAX, and clear the error. */
Andrew M. Kuchling2194b162000-02-23 22:18:48 +00003950
3951 /* Create a long integer with a value of 0 */
Guido van Rossumac7be682001-01-17 15:42:30 +00003952 long_zero = PyLong_FromLong(0L);
Tim Peterscb479e72001-12-16 19:11:44 +00003953 if (long_zero == NULL)
3954 return 0;
Andrew M. Kuchling2194b162000-02-23 22:18:48 +00003955
3956 /* Check sign */
Guido van Rossumac7be682001-01-17 15:42:30 +00003957 cmp = PyObject_RichCompareBool(v, long_zero,
3958 Py_GT);
3959 Py_DECREF(long_zero);
3960 if (cmp < 0)
3961 return 0;
Michael W. Hudsone46d1552003-02-27 14:50:34 +00003962 else if (cmp)
Martin v. Löwisdde99d22006-02-17 15:57:41 +00003963 x = PY_SSIZE_T_MAX;
Andrew M. Kuchling2194b162000-02-23 22:18:48 +00003964 else
Martin v. Löwisdde99d22006-02-17 15:57:41 +00003965 x = -PY_SSIZE_T_MAX;
Andrew M. Kuchling2194b162000-02-23 22:18:48 +00003966 }
3967 } else {
Guido van Rossuma027efa1997-05-05 20:56:21 +00003968 PyErr_SetString(PyExc_TypeError,
Georg Brandl1dc5a842006-02-19 00:12:42 +00003969 "slice indices must be integers or None");
Guido van Rossum20c6add2000-05-08 14:06:50 +00003970 return 0;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003971 }
Guido van Rossuma027efa1997-05-05 20:56:21 +00003972 *pi = x;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003973 }
Guido van Rossum20c6add2000-05-08 14:06:50 +00003974 return 1;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003975}
3976
Guido van Rossum50d756e2001-08-18 17:43:36 +00003977#undef ISINT
3978#define ISINT(x) ((x) == NULL || PyInt_Check(x) || PyLong_Check(x))
3979
Guido van Rossumb209a111997-04-29 18:18:01 +00003980static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003981apply_slice(PyObject *u, PyObject *v, PyObject *w) /* return u[v:w] */
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003982{
Guido van Rossum50d756e2001-08-18 17:43:36 +00003983 PyTypeObject *tp = u->ob_type;
3984 PySequenceMethods *sq = tp->tp_as_sequence;
3985
3986 if (sq && sq->sq_slice && ISINT(v) && ISINT(w)) {
Martin v. Löwisdde99d22006-02-17 15:57:41 +00003987 Py_ssize_t ilow = 0, ihigh = PY_SSIZE_T_MAX;
Guido van Rossum50d756e2001-08-18 17:43:36 +00003988 if (!_PyEval_SliceIndex(v, &ilow))
3989 return NULL;
3990 if (!_PyEval_SliceIndex(w, &ihigh))
3991 return NULL;
3992 return PySequence_GetSlice(u, ilow, ihigh);
3993 }
3994 else {
3995 PyObject *slice = PySlice_New(v, w, NULL);
Guido van Rossum354797c2001-12-03 19:45:06 +00003996 if (slice != NULL) {
3997 PyObject *res = PyObject_GetItem(u, slice);
3998 Py_DECREF(slice);
3999 return res;
4000 }
Guido van Rossum50d756e2001-08-18 17:43:36 +00004001 else
4002 return NULL;
4003 }
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004004}
Guido van Rossum3f5da241990-12-20 15:06:42 +00004005
4006static int
Guido van Rossumac7be682001-01-17 15:42:30 +00004007assign_slice(PyObject *u, PyObject *v, PyObject *w, PyObject *x)
4008 /* u[v:w] = x */
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004009{
Guido van Rossum50d756e2001-08-18 17:43:36 +00004010 PyTypeObject *tp = u->ob_type;
4011 PySequenceMethods *sq = tp->tp_as_sequence;
4012
4013 if (sq && sq->sq_slice && ISINT(v) && ISINT(w)) {
Martin v. Löwisdde99d22006-02-17 15:57:41 +00004014 Py_ssize_t ilow = 0, ihigh = PY_SSIZE_T_MAX;
Guido van Rossum50d756e2001-08-18 17:43:36 +00004015 if (!_PyEval_SliceIndex(v, &ilow))
4016 return -1;
4017 if (!_PyEval_SliceIndex(w, &ihigh))
4018 return -1;
4019 if (x == NULL)
4020 return PySequence_DelSlice(u, ilow, ihigh);
4021 else
4022 return PySequence_SetSlice(u, ilow, ihigh, x);
4023 }
4024 else {
4025 PyObject *slice = PySlice_New(v, w, NULL);
4026 if (slice != NULL) {
Guido van Rossum354797c2001-12-03 19:45:06 +00004027 int res;
Guido van Rossum50d756e2001-08-18 17:43:36 +00004028 if (x != NULL)
Guido van Rossum354797c2001-12-03 19:45:06 +00004029 res = PyObject_SetItem(u, slice, x);
Guido van Rossum50d756e2001-08-18 17:43:36 +00004030 else
Guido van Rossum354797c2001-12-03 19:45:06 +00004031 res = PyObject_DelItem(u, slice);
4032 Py_DECREF(slice);
4033 return res;
Guido van Rossum50d756e2001-08-18 17:43:36 +00004034 }
4035 else
4036 return -1;
4037 }
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004038}
4039
Guido van Rossumb209a111997-04-29 18:18:01 +00004040static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00004041cmp_outcome(int op, register PyObject *v, register PyObject *w)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004042{
Guido van Rossumac7be682001-01-17 15:42:30 +00004043 int res = 0;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004044 switch (op) {
Martin v. Löwis7198a522002-01-01 19:59:11 +00004045 case PyCmp_IS:
Guido van Rossum3f5da241990-12-20 15:06:42 +00004046 res = (v == w);
Raymond Hettinger4bad9ba2003-01-19 05:08:13 +00004047 break;
4048 case PyCmp_IS_NOT:
4049 res = (v != w);
Guido van Rossum3f5da241990-12-20 15:06:42 +00004050 break;
Martin v. Löwis7198a522002-01-01 19:59:11 +00004051 case PyCmp_IN:
Raymond Hettinger4bad9ba2003-01-19 05:08:13 +00004052 res = PySequence_Contains(w, v);
4053 if (res < 0)
4054 return NULL;
4055 break;
Martin v. Löwis7198a522002-01-01 19:59:11 +00004056 case PyCmp_NOT_IN:
Guido van Rossum7e33c6e1998-05-22 00:52:29 +00004057 res = PySequence_Contains(w, v);
Guido van Rossum3f5da241990-12-20 15:06:42 +00004058 if (res < 0)
4059 return NULL;
Raymond Hettinger4bad9ba2003-01-19 05:08:13 +00004060 res = !res;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004061 break;
Martin v. Löwis7198a522002-01-01 19:59:11 +00004062 case PyCmp_EXC_MATCH:
Barry Warsaw4249f541997-08-22 21:26:19 +00004063 res = PyErr_GivenExceptionMatches(v, w);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004064 break;
4065 default:
Guido van Rossumac7be682001-01-17 15:42:30 +00004066 return PyObject_RichCompare(v, w, op);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004067 }
Guido van Rossumb209a111997-04-29 18:18:01 +00004068 v = res ? Py_True : Py_False;
4069 Py_INCREF(v);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004070 return v;
4071}
4072
Thomas Wouters52152252000-08-17 22:55:00 +00004073static PyObject *
4074import_from(PyObject *v, PyObject *name)
Guido van Rossume9736fc1990-11-18 17:33:06 +00004075{
Guido van Rossum18d4d8f2001-01-12 16:24:03 +00004076 PyObject *x;
4077
4078 x = PyObject_GetAttr(v, name);
4079 if (x == NULL && PyErr_ExceptionMatches(PyExc_AttributeError)) {
Thomas Wouters52152252000-08-17 22:55:00 +00004080 PyErr_Format(PyExc_ImportError,
4081 "cannot import name %.230s",
4082 PyString_AsString(name));
Guido van Rossum18d4d8f2001-01-12 16:24:03 +00004083 }
Thomas Wouters52152252000-08-17 22:55:00 +00004084 return x;
4085}
Guido van Rossumac7be682001-01-17 15:42:30 +00004086
Thomas Wouters52152252000-08-17 22:55:00 +00004087static int
4088import_all_from(PyObject *locals, PyObject *v)
4089{
Guido van Rossum18d4d8f2001-01-12 16:24:03 +00004090 PyObject *all = PyObject_GetAttrString(v, "__all__");
4091 PyObject *dict, *name, *value;
4092 int skip_leading_underscores = 0;
4093 int pos, err;
Thomas Wouters52152252000-08-17 22:55:00 +00004094
Guido van Rossum18d4d8f2001-01-12 16:24:03 +00004095 if (all == NULL) {
4096 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
4097 return -1; /* Unexpected error */
4098 PyErr_Clear();
4099 dict = PyObject_GetAttrString(v, "__dict__");
4100 if (dict == NULL) {
4101 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
4102 return -1;
4103 PyErr_SetString(PyExc_ImportError,
4104 "from-import-* object has no __dict__ and no __all__");
Guido van Rossum3f5da241990-12-20 15:06:42 +00004105 return -1;
Guido van Rossum18d4d8f2001-01-12 16:24:03 +00004106 }
4107 all = PyMapping_Keys(dict);
4108 Py_DECREF(dict);
4109 if (all == NULL)
4110 return -1;
4111 skip_leading_underscores = 1;
Guido van Rossume9736fc1990-11-18 17:33:06 +00004112 }
Guido van Rossum18d4d8f2001-01-12 16:24:03 +00004113
4114 for (pos = 0, err = 0; ; pos++) {
4115 name = PySequence_GetItem(all, pos);
4116 if (name == NULL) {
4117 if (!PyErr_ExceptionMatches(PyExc_IndexError))
4118 err = -1;
4119 else
4120 PyErr_Clear();
4121 break;
4122 }
4123 if (skip_leading_underscores &&
4124 PyString_Check(name) &&
4125 PyString_AS_STRING(name)[0] == '_')
4126 {
4127 Py_DECREF(name);
4128 continue;
4129 }
4130 value = PyObject_GetAttr(v, name);
4131 if (value == NULL)
4132 err = -1;
4133 else
4134 err = PyDict_SetItem(locals, name, value);
4135 Py_DECREF(name);
4136 Py_XDECREF(value);
4137 if (err != 0)
4138 break;
4139 }
4140 Py_DECREF(all);
4141 return err;
Guido van Rossume9736fc1990-11-18 17:33:06 +00004142}
4143
Guido van Rossumb209a111997-04-29 18:18:01 +00004144static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00004145build_class(PyObject *methods, PyObject *bases, PyObject *name)
Guido van Rossume9736fc1990-11-18 17:33:06 +00004146{
Guido van Rossum7851eea2001-09-12 19:19:18 +00004147 PyObject *metaclass = NULL, *result, *base;
Tim Peters6d6c1a32001-08-02 04:15:00 +00004148
4149 if (PyDict_Check(methods))
4150 metaclass = PyDict_GetItemString(methods, "__metaclass__");
Guido van Rossum7851eea2001-09-12 19:19:18 +00004151 if (metaclass != NULL)
Guido van Rossum2556f2e2001-12-06 14:09:56 +00004152 Py_INCREF(metaclass);
Guido van Rossum7851eea2001-09-12 19:19:18 +00004153 else if (PyTuple_Check(bases) && PyTuple_GET_SIZE(bases) > 0) {
4154 base = PyTuple_GET_ITEM(bases, 0);
4155 metaclass = PyObject_GetAttrString(base, "__class__");
4156 if (metaclass == NULL) {
4157 PyErr_Clear();
4158 metaclass = (PyObject *)base->ob_type;
4159 Py_INCREF(metaclass);
Guido van Rossum25831651993-05-19 14:50:45 +00004160 }
4161 }
Guido van Rossum7851eea2001-09-12 19:19:18 +00004162 else {
4163 PyObject *g = PyEval_GetGlobals();
4164 if (g != NULL && PyDict_Check(g))
4165 metaclass = PyDict_GetItemString(g, "__metaclass__");
4166 if (metaclass == NULL)
4167 metaclass = (PyObject *) &PyClass_Type;
4168 Py_INCREF(metaclass);
4169 }
4170 result = PyObject_CallFunction(metaclass, "OOO", name, bases, methods);
4171 Py_DECREF(metaclass);
Raymond Hettingerf2c08302004-06-05 06:16:22 +00004172 if (result == NULL && PyErr_ExceptionMatches(PyExc_TypeError)) {
4173 /* A type error here likely means that the user passed
4174 in a base that was not a class (such the random module
4175 instead of the random.random type). Help them out with
Raymond Hettingercfc31922004-09-16 16:41:57 +00004176 by augmenting the error message with more information.*/
4177
4178 PyObject *ptype, *pvalue, *ptraceback;
4179
4180 PyErr_Fetch(&ptype, &pvalue, &ptraceback);
4181 if (PyString_Check(pvalue)) {
4182 PyObject *newmsg;
4183 newmsg = PyString_FromFormat(
4184 "Error when calling the metaclass bases\n %s",
4185 PyString_AS_STRING(pvalue));
4186 if (newmsg != NULL) {
4187 Py_DECREF(pvalue);
4188 pvalue = newmsg;
4189 }
4190 }
4191 PyErr_Restore(ptype, pvalue, ptraceback);
Raymond Hettingerf2c08302004-06-05 06:16:22 +00004192 }
Guido van Rossum7851eea2001-09-12 19:19:18 +00004193 return result;
Guido van Rossum25831651993-05-19 14:50:45 +00004194}
4195
Guido van Rossumdb3165e1993-10-18 17:06:59 +00004196static int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00004197exec_statement(PyFrameObject *f, PyObject *prog, PyObject *globals,
4198 PyObject *locals)
Guido van Rossumdb3165e1993-10-18 17:06:59 +00004199{
Guido van Rossumdb3165e1993-10-18 17:06:59 +00004200 int n;
Guido van Rossumb209a111997-04-29 18:18:01 +00004201 PyObject *v;
Guido van Rossum681d79a1995-07-18 14:51:37 +00004202 int plain = 0;
Guido van Rossumdb3165e1993-10-18 17:06:59 +00004203
Guido van Rossumb209a111997-04-29 18:18:01 +00004204 if (PyTuple_Check(prog) && globals == Py_None && locals == Py_None &&
4205 ((n = PyTuple_Size(prog)) == 2 || n == 3)) {
Guido van Rossumdb3165e1993-10-18 17:06:59 +00004206 /* Backward compatibility hack */
Guido van Rossumb209a111997-04-29 18:18:01 +00004207 globals = PyTuple_GetItem(prog, 1);
Guido van Rossumdb3165e1993-10-18 17:06:59 +00004208 if (n == 3)
Guido van Rossumb209a111997-04-29 18:18:01 +00004209 locals = PyTuple_GetItem(prog, 2);
4210 prog = PyTuple_GetItem(prog, 0);
Guido van Rossumdb3165e1993-10-18 17:06:59 +00004211 }
Guido van Rossumb209a111997-04-29 18:18:01 +00004212 if (globals == Py_None) {
4213 globals = PyEval_GetGlobals();
4214 if (locals == Py_None) {
4215 locals = PyEval_GetLocals();
Guido van Rossum681d79a1995-07-18 14:51:37 +00004216 plain = 1;
4217 }
Guido van Rossumdb3165e1993-10-18 17:06:59 +00004218 }
Guido van Rossumb209a111997-04-29 18:18:01 +00004219 else if (locals == Py_None)
Guido van Rossumdb3165e1993-10-18 17:06:59 +00004220 locals = globals;
Guido van Rossumb209a111997-04-29 18:18:01 +00004221 if (!PyString_Check(prog) &&
Marc-André Lemburgd1ba4432000-09-19 21:04:18 +00004222 !PyUnicode_Check(prog) &&
Guido van Rossumb209a111997-04-29 18:18:01 +00004223 !PyCode_Check(prog) &&
4224 !PyFile_Check(prog)) {
4225 PyErr_SetString(PyExc_TypeError,
Guido van Rossumac7be682001-01-17 15:42:30 +00004226 "exec: arg 1 must be a string, file, or code object");
Guido van Rossumdb3165e1993-10-18 17:06:59 +00004227 return -1;
4228 }
Fred Drake661ea262000-10-24 19:57:45 +00004229 if (!PyDict_Check(globals)) {
Guido van Rossumb209a111997-04-29 18:18:01 +00004230 PyErr_SetString(PyExc_TypeError,
Fred Drake661ea262000-10-24 19:57:45 +00004231 "exec: arg 2 must be a dictionary or None");
4232 return -1;
4233 }
Raymond Hettinger66bd2332004-08-02 08:30:07 +00004234 if (!PyMapping_Check(locals)) {
Fred Drake661ea262000-10-24 19:57:45 +00004235 PyErr_SetString(PyExc_TypeError,
Raymond Hettinger66bd2332004-08-02 08:30:07 +00004236 "exec: arg 3 must be a mapping or None");
Guido van Rossumdb3165e1993-10-18 17:06:59 +00004237 return -1;
4238 }
Guido van Rossumb209a111997-04-29 18:18:01 +00004239 if (PyDict_GetItemString(globals, "__builtins__") == NULL)
Guido van Rossuma027efa1997-05-05 20:56:21 +00004240 PyDict_SetItemString(globals, "__builtins__", f->f_builtins);
Guido van Rossumb209a111997-04-29 18:18:01 +00004241 if (PyCode_Check(prog)) {
Jeremy Hylton733c8932001-12-13 19:51:56 +00004242 if (PyCode_GetNumFree((PyCodeObject *)prog) > 0) {
4243 PyErr_SetString(PyExc_TypeError,
4244 "code object passed to exec may not contain free variables");
4245 return -1;
4246 }
Guido van Rossuma400d8a2000-01-12 22:45:54 +00004247 v = PyEval_EvalCode((PyCodeObject *) prog, globals, locals);
Guido van Rossumdb3165e1993-10-18 17:06:59 +00004248 }
Guido van Rossuma400d8a2000-01-12 22:45:54 +00004249 else if (PyFile_Check(prog)) {
Guido van Rossumb209a111997-04-29 18:18:01 +00004250 FILE *fp = PyFile_AsFile(prog);
4251 char *name = PyString_AsString(PyFile_Name(prog));
Tim Peters5ba58662001-07-16 02:29:45 +00004252 PyCompilerFlags cf;
4253 cf.cf_flags = 0;
4254 if (PyEval_MergeCompilerFlags(&cf))
Jeremy Hyltonbc320242001-03-22 02:47:58 +00004255 v = PyRun_FileFlags(fp, name, Py_file_input, globals,
Tim Peters8a5c3c72004-04-05 19:36:21 +00004256 locals, &cf);
Tim Peters5ba58662001-07-16 02:29:45 +00004257 else
Jeremy Hyltonbc320242001-03-22 02:47:58 +00004258 v = PyRun_File(fp, name, Py_file_input, globals,
Tim Peters8a5c3c72004-04-05 19:36:21 +00004259 locals);
Guido van Rossuma400d8a2000-01-12 22:45:54 +00004260 }
4261 else {
Just van Rossum3aaf42c2003-02-10 08:21:10 +00004262 PyObject *tmp = NULL;
Marc-André Lemburgd1ba4432000-09-19 21:04:18 +00004263 char *str;
Tim Peters5ba58662001-07-16 02:29:45 +00004264 PyCompilerFlags cf;
Just van Rossum3aaf42c2003-02-10 08:21:10 +00004265 cf.cf_flags = 0;
4266#ifdef Py_USING_UNICODE
4267 if (PyUnicode_Check(prog)) {
4268 tmp = PyUnicode_AsUTF8String(prog);
4269 if (tmp == NULL)
4270 return -1;
4271 prog = tmp;
4272 cf.cf_flags |= PyCF_SOURCE_IS_UTF8;
4273 }
4274#endif
Marc-André Lemburgd1ba4432000-09-19 21:04:18 +00004275 if (PyString_AsStringAndSize(prog, &str, NULL))
Guido van Rossumdb3165e1993-10-18 17:06:59 +00004276 return -1;
Tim Peters5ba58662001-07-16 02:29:45 +00004277 if (PyEval_MergeCompilerFlags(&cf))
Tim Peters8a5c3c72004-04-05 19:36:21 +00004278 v = PyRun_StringFlags(str, Py_file_input, globals,
Jeremy Hyltonbc320242001-03-22 02:47:58 +00004279 locals, &cf);
Tim Peters5ba58662001-07-16 02:29:45 +00004280 else
Jeremy Hyltonbc320242001-03-22 02:47:58 +00004281 v = PyRun_String(str, Py_file_input, globals, locals);
Just van Rossum3aaf42c2003-02-10 08:21:10 +00004282 Py_XDECREF(tmp);
Guido van Rossumdb3165e1993-10-18 17:06:59 +00004283 }
Guido van Rossuma400d8a2000-01-12 22:45:54 +00004284 if (plain)
4285 PyFrame_LocalsToFast(f, 0);
Guido van Rossum681d79a1995-07-18 14:51:37 +00004286 if (v == NULL)
Guido van Rossumdb3165e1993-10-18 17:06:59 +00004287 return -1;
Guido van Rossumb209a111997-04-29 18:18:01 +00004288 Py_DECREF(v);
Guido van Rossumdb3165e1993-10-18 17:06:59 +00004289 return 0;
4290}
Guido van Rossum24c13741995-02-14 09:42:43 +00004291
Guido van Rossumac7be682001-01-17 15:42:30 +00004292static void
Paul Prescode68140d2000-08-30 20:25:01 +00004293format_exc_check_arg(PyObject *exc, char *format_str, PyObject *obj)
4294{
4295 char *obj_str;
4296
4297 if (!obj)
4298 return;
4299
4300 obj_str = PyString_AsString(obj);
4301 if (!obj_str)
4302 return;
4303
4304 PyErr_Format(exc, format_str, obj_str);
4305}
Guido van Rossum950361c1997-01-24 13:49:28 +00004306
Raymond Hettinger52a21b82004-08-06 18:43:09 +00004307static PyObject *
4308string_concatenate(PyObject *v, PyObject *w,
4309 PyFrameObject *f, unsigned char *next_instr)
4310{
4311 /* This function implements 'variable += expr' when both arguments
4312 are strings. */
4313
4314 if (v->ob_refcnt == 2) {
4315 /* In the common case, there are 2 references to the value
4316 * stored in 'variable' when the += is performed: one on the
4317 * value stack (in 'v') and one still stored in the 'variable'.
4318 * We try to delete the variable now to reduce the refcnt to 1.
4319 */
4320 switch (*next_instr) {
4321 case STORE_FAST:
4322 {
4323 int oparg = PEEKARG();
4324 PyObject **fastlocals = f->f_localsplus;
4325 if (GETLOCAL(oparg) == v)
4326 SETLOCAL(oparg, NULL);
4327 break;
4328 }
4329 case STORE_DEREF:
4330 {
4331 PyObject **freevars = f->f_localsplus + f->f_nlocals;
4332 PyObject *c = freevars[PEEKARG()];
4333 if (PyCell_GET(c) == v)
4334 PyCell_Set(c, NULL);
4335 break;
4336 }
4337 case STORE_NAME:
4338 {
4339 PyObject *names = f->f_code->co_names;
4340 PyObject *name = GETITEM(names, PEEKARG());
4341 PyObject *locals = f->f_locals;
4342 if (PyDict_CheckExact(locals) &&
4343 PyDict_GetItem(locals, name) == v) {
4344 if (PyDict_DelItem(locals, name) != 0) {
4345 PyErr_Clear();
4346 }
4347 }
4348 break;
4349 }
4350 }
4351 }
4352
Armin Rigo618fbf52004-08-07 20:58:32 +00004353 if (v->ob_refcnt == 1 && !PyString_CHECK_INTERNED(v)) {
Raymond Hettinger52a21b82004-08-06 18:43:09 +00004354 /* Now we own the last reference to 'v', so we can resize it
4355 * in-place.
4356 */
4357 int v_len = PyString_GET_SIZE(v);
4358 int w_len = PyString_GET_SIZE(w);
4359 if (_PyString_Resize(&v, v_len + w_len) != 0) {
4360 /* XXX if _PyString_Resize() fails, 'v' has been
4361 * deallocated so it cannot be put back into 'variable'.
4362 * The MemoryError is raised when there is no value in
4363 * 'variable', which might (very remotely) be a cause
4364 * of incompatibilities.
4365 */
4366 return NULL;
4367 }
4368 /* copy 'w' into the newly allocated area of 'v' */
4369 memcpy(PyString_AS_STRING(v) + v_len,
4370 PyString_AS_STRING(w), w_len);
4371 return v;
4372 }
4373 else {
4374 /* When in-place resizing is not an option. */
4375 PyString_Concat(&v, w);
4376 return v;
4377 }
4378}
4379
Guido van Rossum950361c1997-01-24 13:49:28 +00004380#ifdef DYNAMIC_EXECUTION_PROFILE
4381
Skip Montanarof118cb12001-10-15 20:51:38 +00004382static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00004383getarray(long a[256])
Guido van Rossum950361c1997-01-24 13:49:28 +00004384{
4385 int i;
4386 PyObject *l = PyList_New(256);
4387 if (l == NULL) return NULL;
4388 for (i = 0; i < 256; i++) {
4389 PyObject *x = PyInt_FromLong(a[i]);
4390 if (x == NULL) {
4391 Py_DECREF(l);
4392 return NULL;
4393 }
4394 PyList_SetItem(l, i, x);
4395 }
4396 for (i = 0; i < 256; i++)
4397 a[i] = 0;
4398 return l;
4399}
4400
4401PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00004402_Py_GetDXProfile(PyObject *self, PyObject *args)
Guido van Rossum950361c1997-01-24 13:49:28 +00004403{
4404#ifndef DXPAIRS
4405 return getarray(dxp);
4406#else
4407 int i;
4408 PyObject *l = PyList_New(257);
4409 if (l == NULL) return NULL;
4410 for (i = 0; i < 257; i++) {
4411 PyObject *x = getarray(dxpairs[i]);
4412 if (x == NULL) {
4413 Py_DECREF(l);
4414 return NULL;
4415 }
4416 PyList_SetItem(l, i, x);
4417 }
4418 return l;
4419#endif
4420}
4421
4422#endif