blob: 8012b8357f2eacae7e9e1561bcdc6970221b79b0 [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:
5 XXX how to pass arguments to call_trace?
Guido van Rossum681d79a1995-07-18 14:51:37 +00006 XXX speed up searching for keywords by using a dictionary
Guido van Rossum681d79a1995-07-18 14:51:37 +00007 XXX document it!
8 */
9
Guido van Rossumb209a111997-04-29 18:18:01 +000010#include "Python.h"
Guido van Rossum10dc2e81990-11-18 17:27:39 +000011
Guido van Rossum10dc2e81990-11-18 17:27:39 +000012#include "compile.h"
Guido van Rossum3f5da241990-12-20 15:06:42 +000013#include "frameobject.h"
Guido van Rossumff4949e1992-08-05 19:58:53 +000014#include "eval.h"
Guido van Rossum10dc2e81990-11-18 17:27:39 +000015#include "opcode.h"
16
Jack Jansencbf630f2000-07-11 21:59:16 +000017#ifdef macintosh
18#include "macglue.h"
19#endif
20
Guido van Rossumc6004111993-11-05 10:22:19 +000021#include <ctype.h>
22
Guido van Rossum04691fc1992-08-12 15:35:34 +000023/* Turn this on if your compiler chokes on the big switch: */
Guido van Rossum1ae940a1995-01-02 19:04:15 +000024/* #define CASE_TOO_BIG 1 */
Guido van Rossum04691fc1992-08-12 15:35:34 +000025
Guido van Rossum408027e1996-12-30 16:17:54 +000026#ifdef Py_DEBUG
Guido van Rossum96a42c81992-01-12 02:29:51 +000027/* For debugging the interpreter: */
28#define LLTRACE 1 /* Low-level trace feature */
29#define CHECKEXC 1 /* Double-check exception checking */
Guido van Rossum10dc2e81990-11-18 17:27:39 +000030#endif
31
Jeremy Hylton52820442001-01-03 23:52:36 +000032typedef PyObject *(*callproc)(PyObject *, PyObject *, PyObject *);
Guido van Rossum5b722181993-03-30 17:46:03 +000033
Guido van Rossum374a9221991-04-04 10:40:29 +000034/* Forward declarations */
Guido van Rossum374a9221991-04-04 10:40:29 +000035
Tim Petersdbd9ba62000-07-09 03:09:57 +000036static PyObject *eval_code2(PyCodeObject *,
37 PyObject *, PyObject *,
38 PyObject **, int,
39 PyObject **, int,
Jeremy Hylton52820442001-01-03 23:52:36 +000040 PyObject **, int);
41
42static PyObject *call_object(PyObject *, PyObject *, PyObject *);
43static PyObject *call_cfunction(PyObject *, PyObject *, PyObject *);
44static PyObject *call_instance(PyObject *, PyObject *, PyObject *);
45static PyObject *call_method(PyObject *, PyObject *, PyObject *);
46static PyObject *call_eval_code2(PyObject *, PyObject *, PyObject *);
47static PyObject *fast_function(PyObject *, PyObject ***, int, int, int);
48static PyObject *fast_cfunction(PyObject *, PyObject ***, int);
49static PyObject *do_call(PyObject *, PyObject ***, int, int);
50static PyObject *ext_do_call(PyObject *, PyObject ***, int, int, int);
51static PyObject *update_keyword_args(PyObject *, int, PyObject ***);
52static PyObject *update_star_args(int, int, PyObject *, PyObject ***);
53static PyObject *load_args(PyObject ***, int);
54#define CALL_FLAG_VAR 1
55#define CALL_FLAG_KW 2
56
Guido van Rossum0a066c01992-03-27 17:29:15 +000057#ifdef LLTRACE
Tim Petersdbd9ba62000-07-09 03:09:57 +000058static int prtrace(PyObject *, char *);
Guido van Rossum0a066c01992-03-27 17:29:15 +000059#endif
Tim Petersdbd9ba62000-07-09 03:09:57 +000060static void call_exc_trace(PyObject **, PyObject**, PyFrameObject *);
61static int call_trace(PyObject **, PyObject **,
62 PyFrameObject *, char *, PyObject *);
Tim Petersdbd9ba62000-07-09 03:09:57 +000063static PyObject *loop_subscript(PyObject *, PyObject *);
64static PyObject *apply_slice(PyObject *, PyObject *, PyObject *);
65static int assign_slice(PyObject *, PyObject *,
66 PyObject *, PyObject *);
67static PyObject *cmp_outcome(int, PyObject *, PyObject *);
Thomas Wouters52152252000-08-17 22:55:00 +000068static PyObject *import_from(PyObject *, PyObject *);
69static int import_all_from(PyObject *, PyObject *);
Tim Petersdbd9ba62000-07-09 03:09:57 +000070static PyObject *build_class(PyObject *, PyObject *, PyObject *);
71static int exec_statement(PyFrameObject *,
72 PyObject *, PyObject *, PyObject *);
Tim Petersdbd9ba62000-07-09 03:09:57 +000073static void set_exc_info(PyThreadState *, PyObject *, PyObject *, PyObject *);
74static void reset_exc_info(PyThreadState *);
Paul Prescode68140d2000-08-30 20:25:01 +000075static void format_exc_check_arg(PyObject *, char *, PyObject *);
Guido van Rossum374a9221991-04-04 10:40:29 +000076
Paul Prescode68140d2000-08-30 20:25:01 +000077#define NAME_ERROR_MSG \
Fred Drake661ea262000-10-24 19:57:45 +000078 "name '%.200s' is not defined"
Paul Prescode68140d2000-08-30 20:25:01 +000079#define UNBOUNDLOCAL_ERROR_MSG \
Fred Drake661ea262000-10-24 19:57:45 +000080 "local variable '%.200s' referenced before assignment"
Guido van Rossum374a9221991-04-04 10:40:29 +000081
Guido van Rossum950361c1997-01-24 13:49:28 +000082/* Dynamic execution profile */
83#ifdef DYNAMIC_EXECUTION_PROFILE
84#ifdef DXPAIRS
85static long dxpairs[257][256];
86#define dxp dxpairs[256]
87#else
88static long dxp[256];
89#endif
90#endif
91
Guido van Rossume59214e1994-08-30 08:01:59 +000092#ifdef WITH_THREAD
Guido van Rossumff4949e1992-08-05 19:58:53 +000093
Guido van Rossum2571cc81999-04-07 16:07:23 +000094#ifndef DONT_HAVE_ERRNO_H
Guido van Rossum1984f1e1992-08-04 12:41:02 +000095#include <errno.h>
Guido van Rossum2571cc81999-04-07 16:07:23 +000096#endif
Guido van Rossum49b56061998-10-01 20:42:43 +000097#include "pythread.h"
Guido van Rossumff4949e1992-08-05 19:58:53 +000098
Guido van Rossuma027efa1997-05-05 20:56:21 +000099extern int _PyThread_Started; /* Flag for Py_Exit */
100
Guido van Rossum65d5b571998-12-21 19:32:43 +0000101static PyThread_type_lock interpreter_lock = 0;
Guido van Rossuma9672091994-09-14 13:31:22 +0000102static long main_thread = 0;
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000103
104void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000105PyEval_InitThreads(void)
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000106{
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000107 if (interpreter_lock)
Sjoerd Mullendered59d201993-01-06 13:36:38 +0000108 return;
Guido van Rossuma027efa1997-05-05 20:56:21 +0000109 _PyThread_Started = 1;
Guido van Rossum65d5b571998-12-21 19:32:43 +0000110 interpreter_lock = PyThread_allocate_lock();
111 PyThread_acquire_lock(interpreter_lock, 1);
112 main_thread = PyThread_get_thread_ident();
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000113}
Guido van Rossumff4949e1992-08-05 19:58:53 +0000114
Guido van Rossum9cc8a201997-07-19 19:55:50 +0000115void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000116PyEval_AcquireLock(void)
Guido van Rossum25ce5661997-08-02 03:10:38 +0000117{
Guido van Rossum65d5b571998-12-21 19:32:43 +0000118 PyThread_acquire_lock(interpreter_lock, 1);
Guido van Rossum25ce5661997-08-02 03:10:38 +0000119}
120
121void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000122PyEval_ReleaseLock(void)
Guido van Rossum25ce5661997-08-02 03:10:38 +0000123{
Guido van Rossum65d5b571998-12-21 19:32:43 +0000124 PyThread_release_lock(interpreter_lock);
Guido van Rossum25ce5661997-08-02 03:10:38 +0000125}
126
127void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000128PyEval_AcquireThread(PyThreadState *tstate)
Guido van Rossum9cc8a201997-07-19 19:55:50 +0000129{
130 if (tstate == NULL)
131 Py_FatalError("PyEval_AcquireThread: NULL new thread state");
Guido van Rossum65d5b571998-12-21 19:32:43 +0000132 PyThread_acquire_lock(interpreter_lock, 1);
Guido van Rossum9cc8a201997-07-19 19:55:50 +0000133 if (PyThreadState_Swap(tstate) != NULL)
134 Py_FatalError(
135 "PyEval_AcquireThread: non-NULL old thread state");
136}
137
138void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000139PyEval_ReleaseThread(PyThreadState *tstate)
Guido van Rossum9cc8a201997-07-19 19:55:50 +0000140{
141 if (tstate == NULL)
142 Py_FatalError("PyEval_ReleaseThread: NULL thread state");
143 if (PyThreadState_Swap(NULL) != tstate)
144 Py_FatalError("PyEval_ReleaseThread: wrong thread state");
Guido van Rossum65d5b571998-12-21 19:32:43 +0000145 PyThread_release_lock(interpreter_lock);
Guido van Rossum9cc8a201997-07-19 19:55:50 +0000146}
Guido van Rossumfee3a2d2000-08-27 17:34:07 +0000147
148/* This function is called from PyOS_AfterFork to ensure that newly
149 created child processes don't hold locks referring to threads which
150 are not running in the child process. (This could also be done using
151 pthread_atfork mechanism, at least for the pthreads implementation.) */
152
153void
154PyEval_ReInitThreads(void)
155{
156 if (!interpreter_lock)
157 return;
158 /*XXX Can't use PyThread_free_lock here because it does too
159 much error-checking. Doing this cleanly would require
160 adding a new function to each thread_*.h. Instead, just
161 create a new lock and waste a little bit of memory */
162 interpreter_lock = PyThread_allocate_lock();
163 PyThread_acquire_lock(interpreter_lock, 1);
164 main_thread = PyThread_get_thread_ident();
165}
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000166#endif
167
Guido van Rossumff4949e1992-08-05 19:58:53 +0000168/* Functions save_thread and restore_thread are always defined so
169 dynamically loaded modules needn't be compiled separately for use
170 with and without threads: */
171
Guido van Rossum2fca21f71997-07-18 23:56:58 +0000172PyThreadState *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000173PyEval_SaveThread(void)
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000174{
Guido van Rossumb74eca91997-09-30 22:03:16 +0000175 PyThreadState *tstate = PyThreadState_Swap(NULL);
176 if (tstate == NULL)
177 Py_FatalError("PyEval_SaveThread: NULL tstate");
Guido van Rossume59214e1994-08-30 08:01:59 +0000178#ifdef WITH_THREAD
Guido van Rossumb74eca91997-09-30 22:03:16 +0000179 if (interpreter_lock)
Guido van Rossum65d5b571998-12-21 19:32:43 +0000180 PyThread_release_lock(interpreter_lock);
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000181#endif
Guido van Rossumb74eca91997-09-30 22:03:16 +0000182 return tstate;
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000183}
184
185void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000186PyEval_RestoreThread(PyThreadState *tstate)
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000187{
Guido van Rossumb74eca91997-09-30 22:03:16 +0000188 if (tstate == NULL)
189 Py_FatalError("PyEval_RestoreThread: NULL tstate");
Guido van Rossume59214e1994-08-30 08:01:59 +0000190#ifdef WITH_THREAD
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000191 if (interpreter_lock) {
Guido van Rossumb74eca91997-09-30 22:03:16 +0000192 int err = errno;
Guido van Rossum65d5b571998-12-21 19:32:43 +0000193 PyThread_acquire_lock(interpreter_lock, 1);
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000194 errno = err;
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000195 }
196#endif
Guido van Rossumb74eca91997-09-30 22:03:16 +0000197 PyThreadState_Swap(tstate);
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000198}
199
200
Guido van Rossuma9672091994-09-14 13:31:22 +0000201/* Mechanism whereby asynchronously executing callbacks (e.g. UNIX
202 signal handlers or Mac I/O completion routines) can schedule calls
203 to a function to be called synchronously.
204 The synchronous function is called with one void* argument.
205 It should return 0 for success or -1 for failure -- failure should
206 be accompanied by an exception.
207
208 If registry succeeds, the registry function returns 0; if it fails
209 (e.g. due to too many pending calls) it returns -1 (without setting
210 an exception condition).
211
212 Note that because registry may occur from within signal handlers,
213 or other asynchronous events, calling malloc() is unsafe!
214
215#ifdef WITH_THREAD
216 Any thread can schedule pending calls, but only the main thread
217 will execute them.
218#endif
219
220 XXX WARNING! ASYNCHRONOUSLY EXECUTING CODE!
221 There are two possible race conditions:
222 (1) nested asynchronous registry calls;
223 (2) registry calls made while pending calls are being processed.
224 While (1) is very unlikely, (2) is a real possibility.
225 The current code is safe against (2), but not against (1).
226 The safety against (2) is derived from the fact that only one
227 thread (the main thread) ever takes things out of the queue.
Guido van Rossuma9672091994-09-14 13:31:22 +0000228
Guido van Rossuma027efa1997-05-05 20:56:21 +0000229 XXX Darn! With the advent of thread state, we should have an array
230 of pending calls per thread in the thread state! Later...
231*/
Guido van Rossum8861b741996-07-30 16:49:37 +0000232
Guido van Rossuma9672091994-09-14 13:31:22 +0000233#define NPENDINGCALLS 32
234static struct {
Thomas Wouters334fb892000-07-25 12:56:38 +0000235 int (*func)(void *);
236 void *arg;
Guido van Rossuma9672091994-09-14 13:31:22 +0000237} pendingcalls[NPENDINGCALLS];
238static volatile int pendingfirst = 0;
239static volatile int pendinglast = 0;
Guido van Rossuma027efa1997-05-05 20:56:21 +0000240static volatile int things_to_do = 0;
Guido van Rossuma9672091994-09-14 13:31:22 +0000241
242int
Thomas Wouters334fb892000-07-25 12:56:38 +0000243Py_AddPendingCall(int (*func)(void *), void *arg)
Guido van Rossuma9672091994-09-14 13:31:22 +0000244{
Guido van Rossum180d7b41994-09-29 09:45:57 +0000245 static int busy = 0;
Guido van Rossuma9672091994-09-14 13:31:22 +0000246 int i, j;
247 /* XXX Begin critical section */
248 /* XXX If you want this to be safe against nested
249 XXX asynchronous calls, you'll have to work harder! */
Guido van Rossum180d7b41994-09-29 09:45:57 +0000250 if (busy)
251 return -1;
252 busy = 1;
Guido van Rossuma9672091994-09-14 13:31:22 +0000253 i = pendinglast;
254 j = (i + 1) % NPENDINGCALLS;
255 if (j == pendingfirst)
256 return -1; /* Queue full */
257 pendingcalls[i].func = func;
258 pendingcalls[i].arg = arg;
259 pendinglast = j;
Guido van Rossuma027efa1997-05-05 20:56:21 +0000260 things_to_do = 1; /* Signal main loop */
Guido van Rossum180d7b41994-09-29 09:45:57 +0000261 busy = 0;
Guido van Rossuma9672091994-09-14 13:31:22 +0000262 /* XXX End critical section */
263 return 0;
264}
265
Guido van Rossum180d7b41994-09-29 09:45:57 +0000266int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000267Py_MakePendingCalls(void)
Guido van Rossuma9672091994-09-14 13:31:22 +0000268{
Guido van Rossum180d7b41994-09-29 09:45:57 +0000269 static int busy = 0;
Guido van Rossuma9672091994-09-14 13:31:22 +0000270#ifdef WITH_THREAD
Guido van Rossum65d5b571998-12-21 19:32:43 +0000271 if (main_thread && PyThread_get_thread_ident() != main_thread)
Guido van Rossuma9672091994-09-14 13:31:22 +0000272 return 0;
273#endif
Guido van Rossuma027efa1997-05-05 20:56:21 +0000274 if (busy)
Guido van Rossum180d7b41994-09-29 09:45:57 +0000275 return 0;
276 busy = 1;
Guido van Rossuma027efa1997-05-05 20:56:21 +0000277 things_to_do = 0;
Guido van Rossuma9672091994-09-14 13:31:22 +0000278 for (;;) {
279 int i;
Thomas Wouters334fb892000-07-25 12:56:38 +0000280 int (*func)(void *);
281 void *arg;
Guido van Rossuma9672091994-09-14 13:31:22 +0000282 i = pendingfirst;
283 if (i == pendinglast)
284 break; /* Queue empty */
285 func = pendingcalls[i].func;
286 arg = pendingcalls[i].arg;
287 pendingfirst = (i + 1) % NPENDINGCALLS;
Guido van Rossum180d7b41994-09-29 09:45:57 +0000288 if (func(arg) < 0) {
289 busy = 0;
Guido van Rossuma027efa1997-05-05 20:56:21 +0000290 things_to_do = 1; /* We're not done yet */
Guido van Rossuma9672091994-09-14 13:31:22 +0000291 return -1;
Guido van Rossum180d7b41994-09-29 09:45:57 +0000292 }
Guido van Rossuma9672091994-09-14 13:31:22 +0000293 }
Guido van Rossum180d7b41994-09-29 09:45:57 +0000294 busy = 0;
Guido van Rossuma9672091994-09-14 13:31:22 +0000295 return 0;
296}
297
298
Jeremy Hyltonee5adfb2000-08-31 19:23:01 +0000299/* The interpreter's recursion limit */
300
Guido van Rossum349ff6f2000-09-01 01:52:08 +0000301static int recursion_limit = 1000;
Jeremy Hyltonee5adfb2000-08-31 19:23:01 +0000302
Vladimir Marangozov7bd25be2000-09-01 11:07:19 +0000303int
304Py_GetRecursionLimit(void)
Jeremy Hyltonee5adfb2000-08-31 19:23:01 +0000305{
306 return recursion_limit;
307}
308
Vladimir Marangozov7bd25be2000-09-01 11:07:19 +0000309void
310Py_SetRecursionLimit(int new_limit)
Jeremy Hyltonee5adfb2000-08-31 19:23:01 +0000311{
312 recursion_limit = new_limit;
313}
314
Guido van Rossum374a9221991-04-04 10:40:29 +0000315/* Status code for main loop (reason for stack unwind) */
316
317enum why_code {
318 WHY_NOT, /* No error */
319 WHY_EXCEPTION, /* Exception occurred */
320 WHY_RERAISE, /* Exception re-raised by 'finally' */
321 WHY_RETURN, /* 'return' statement */
322 WHY_BREAK /* 'break' statement */
323};
324
Tim Petersdbd9ba62000-07-09 03:09:57 +0000325static enum why_code do_raise(PyObject *, PyObject *, PyObject *);
326static int unpack_sequence(PyObject *, int, PyObject **);
Guido van Rossum1aa14831997-01-21 05:34:20 +0000327
Guido van Rossum374a9221991-04-04 10:40:29 +0000328
Guido van Rossumb209a111997-04-29 18:18:01 +0000329PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000330PyEval_EvalCode(PyCodeObject *co, PyObject *globals, PyObject *locals)
Guido van Rossum681d79a1995-07-18 14:51:37 +0000331{
332 return eval_code2(co,
333 globals, locals,
Guido van Rossumb209a111997-04-29 18:18:01 +0000334 (PyObject **)NULL, 0,
335 (PyObject **)NULL, 0,
Jeremy Hylton52820442001-01-03 23:52:36 +0000336 (PyObject **)NULL, 0);
Guido van Rossum681d79a1995-07-18 14:51:37 +0000337}
338
339
340/* Interpreter main loop */
341
Guido van Rossumb209a111997-04-29 18:18:01 +0000342static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000343eval_code2(PyCodeObject *co, PyObject *globals, PyObject *locals,
344 PyObject **args, int argcount, PyObject **kws, int kwcount,
Jeremy Hylton52820442001-01-03 23:52:36 +0000345 PyObject **defs, int defcount)
Guido van Rossum374a9221991-04-04 10:40:29 +0000346{
Guido van Rossum950361c1997-01-24 13:49:28 +0000347#ifdef DXPAIRS
348 int lastopcode = 0;
349#endif
Jeremy Hylton52820442001-01-03 23:52:36 +0000350 PyObject **stack_pointer;
Guido van Rossum374a9221991-04-04 10:40:29 +0000351 register unsigned char *next_instr;
Moshe Zadkaaa39a7e2000-08-07 06:34:45 +0000352 register int opcode=0; /* Current opcode */
353 register int oparg=0; /* Current opcode argument, if any */
Guido van Rossum374a9221991-04-04 10:40:29 +0000354 register enum why_code why; /* Reason for block stack unwind */
355 register int err; /* Error status -- nonzero if error */
Guido van Rossumb209a111997-04-29 18:18:01 +0000356 register PyObject *x; /* Result object -- NULL if error */
357 register PyObject *v; /* Temporary objects popped off stack */
358 register PyObject *w;
359 register PyObject *u;
360 register PyObject *t;
Barry Warsaw23c9ec82000-08-21 15:44:01 +0000361 register PyObject *stream = NULL; /* for PRINT opcodes */
Guido van Rossumb209a111997-04-29 18:18:01 +0000362 register PyFrameObject *f; /* Current frame */
Guido van Rossum50cd3481998-11-17 17:02:51 +0000363 register PyObject **fastlocals;
Guido van Rossum014518f1998-11-23 21:09:51 +0000364 PyObject *retval = NULL; /* Return value */
Guido van Rossum885553e1998-12-21 18:33:30 +0000365 PyThreadState *tstate = PyThreadState_GET();
Guido van Rossumd076c731998-10-07 19:42:25 +0000366 unsigned char *first_instr;
Guido van Rossum96a42c81992-01-12 02:29:51 +0000367#ifdef LLTRACE
Guido van Rossumacbe8da1993-04-15 15:33:52 +0000368 int lltrace;
Guido van Rossum374a9221991-04-04 10:40:29 +0000369#endif
Guido van Rossum408027e1996-12-30 16:17:54 +0000370#if defined(Py_DEBUG) || defined(LLTRACE)
Guido van Rossum681d79a1995-07-18 14:51:37 +0000371 /* Make it easier to find out where we are with a debugger */
Guido van Rossumb209a111997-04-29 18:18:01 +0000372 char *filename = PyString_AsString(co->co_filename);
Guido van Rossum99bec951992-09-03 20:29:45 +0000373#endif
Guido van Rossum374a9221991-04-04 10:40:29 +0000374
375/* Code access macros */
376
377#define GETCONST(i) Getconst(f, i)
378#define GETNAME(i) Getname(f, i)
379#define GETNAMEV(i) Getnamev(f, i)
Guido van Rossumd076c731998-10-07 19:42:25 +0000380#define INSTR_OFFSET() (next_instr - first_instr)
Guido van Rossum374a9221991-04-04 10:40:29 +0000381#define NEXTOP() (*next_instr++)
382#define NEXTARG() (next_instr += 2, (next_instr[-1]<<8) + next_instr[-2])
Guido van Rossumd076c731998-10-07 19:42:25 +0000383#define JUMPTO(x) (next_instr = first_instr + (x))
Guido van Rossum374a9221991-04-04 10:40:29 +0000384#define JUMPBY(x) (next_instr += (x))
385
386/* Stack manipulation macros */
387
388#define STACK_LEVEL() (stack_pointer - f->f_valuestack)
389#define EMPTY() (STACK_LEVEL() == 0)
390#define TOP() (stack_pointer[-1])
391#define BASIC_PUSH(v) (*stack_pointer++ = (v))
392#define BASIC_POP() (*--stack_pointer)
393
Guido van Rossum96a42c81992-01-12 02:29:51 +0000394#ifdef LLTRACE
395#define PUSH(v) (BASIC_PUSH(v), lltrace && prtrace(TOP(), "push"))
396#define POP() (lltrace && prtrace(TOP(), "pop"), BASIC_POP())
Guido van Rossum374a9221991-04-04 10:40:29 +0000397#else
398#define PUSH(v) BASIC_PUSH(v)
399#define POP() BASIC_POP()
400#endif
401
Guido van Rossum681d79a1995-07-18 14:51:37 +0000402/* Local variable macros */
403
404#define GETLOCAL(i) (fastlocals[i])
Guido van Rossumb209a111997-04-29 18:18:01 +0000405#define SETLOCAL(i, value) do { Py_XDECREF(GETLOCAL(i)); \
Guido van Rossum681d79a1995-07-18 14:51:37 +0000406 GETLOCAL(i) = value; } while (0)
407
Guido van Rossuma027efa1997-05-05 20:56:21 +0000408/* Start of code */
409
Guido van Rossum8861b741996-07-30 16:49:37 +0000410#ifdef USE_STACKCHECK
Guido van Rossuma027efa1997-05-05 20:56:21 +0000411 if (tstate->recursion_depth%10 == 0 && PyOS_CheckStack()) {
Guido van Rossumb209a111997-04-29 18:18:01 +0000412 PyErr_SetString(PyExc_MemoryError, "Stack overflow");
Guido van Rossum8861b741996-07-30 16:49:37 +0000413 return NULL;
414 }
415#endif
416
Guido van Rossum681d79a1995-07-18 14:51:37 +0000417 if (globals == NULL) {
Guido van Rossumb209a111997-04-29 18:18:01 +0000418 PyErr_SetString(PyExc_SystemError, "eval_code2: NULL globals");
Guido van Rossum6135a871995-01-09 17:53:26 +0000419 return NULL;
Guido van Rossum5b722181993-03-30 17:46:03 +0000420 }
421
Guido van Rossumacbe8da1993-04-15 15:33:52 +0000422#ifdef LLTRACE
Guido van Rossumb209a111997-04-29 18:18:01 +0000423 lltrace = PyDict_GetItemString(globals, "__lltrace__") != NULL;
Guido van Rossumacbe8da1993-04-15 15:33:52 +0000424#endif
425
Guido van Rossumb209a111997-04-29 18:18:01 +0000426 f = PyFrame_New(
Guido van Rossuma027efa1997-05-05 20:56:21 +0000427 tstate, /*back*/
Guido van Rossum374a9221991-04-04 10:40:29 +0000428 co, /*code*/
429 globals, /*globals*/
Guido van Rossum76836021997-01-20 04:26:20 +0000430 locals); /*locals*/
Guido van Rossum374a9221991-04-04 10:40:29 +0000431 if (f == NULL)
432 return NULL;
Guido van Rossum681d79a1995-07-18 14:51:37 +0000433
Guido van Rossuma027efa1997-05-05 20:56:21 +0000434 tstate->frame = f;
Guido van Rossumdeb0c5e1997-01-27 23:42:36 +0000435 fastlocals = f->f_localsplus;
Guido van Rossum681d79a1995-07-18 14:51:37 +0000436
437 if (co->co_argcount > 0 ||
438 co->co_flags & (CO_VARARGS | CO_VARKEYWORDS)) {
439 int i;
440 int n = argcount;
Guido van Rossumb209a111997-04-29 18:18:01 +0000441 PyObject *kwdict = NULL;
Guido van Rossum681d79a1995-07-18 14:51:37 +0000442 if (co->co_flags & CO_VARKEYWORDS) {
Guido van Rossumb209a111997-04-29 18:18:01 +0000443 kwdict = PyDict_New();
Guido van Rossum681d79a1995-07-18 14:51:37 +0000444 if (kwdict == NULL)
445 goto fail;
Guido van Rossum8c5df061997-01-24 04:19:24 +0000446 i = co->co_argcount;
447 if (co->co_flags & CO_VARARGS)
448 i++;
449 SETLOCAL(i, kwdict);
Guido van Rossum681d79a1995-07-18 14:51:37 +0000450 }
451 if (argcount > co->co_argcount) {
452 if (!(co->co_flags & CO_VARARGS)) {
Guido van Rossumdf9db1e1997-11-19 16:05:40 +0000453 PyErr_Format(PyExc_TypeError,
Fred Drake661ea262000-10-24 19:57:45 +0000454 "too many arguments to %s(); "
455 "expected %d, got %d",
456 PyString_AsString(co->co_name),
457 co->co_argcount, argcount);
Guido van Rossum681d79a1995-07-18 14:51:37 +0000458 goto fail;
459 }
460 n = co->co_argcount;
461 }
462 for (i = 0; i < n; i++) {
463 x = args[i];
Guido van Rossumb209a111997-04-29 18:18:01 +0000464 Py_INCREF(x);
Guido van Rossum681d79a1995-07-18 14:51:37 +0000465 SETLOCAL(i, x);
466 }
467 if (co->co_flags & CO_VARARGS) {
Guido van Rossumb209a111997-04-29 18:18:01 +0000468 u = PyTuple_New(argcount - n);
Guido van Rossum8c5df061997-01-24 04:19:24 +0000469 if (u == NULL)
470 goto fail;
471 SETLOCAL(co->co_argcount, u);
Guido van Rossum681d79a1995-07-18 14:51:37 +0000472 for (i = n; i < argcount; i++) {
473 x = args[i];
Guido van Rossumb209a111997-04-29 18:18:01 +0000474 Py_INCREF(x);
475 PyTuple_SET_ITEM(u, i-n, x);
Guido van Rossum681d79a1995-07-18 14:51:37 +0000476 }
Guido van Rossum681d79a1995-07-18 14:51:37 +0000477 }
478 for (i = 0; i < kwcount; i++) {
Guido van Rossumb209a111997-04-29 18:18:01 +0000479 PyObject *keyword = kws[2*i];
480 PyObject *value = kws[2*i + 1];
Guido van Rossum681d79a1995-07-18 14:51:37 +0000481 int j;
Guido van Rossum25da5be1999-10-26 00:12:20 +0000482 if (keyword == NULL || !PyString_Check(keyword)) {
483 PyErr_SetString(PyExc_TypeError,
484 "keywords must be strings");
485 goto fail;
486 }
Guido van Rossum681d79a1995-07-18 14:51:37 +0000487 /* XXX slow -- speed up using dictionary? */
488 for (j = 0; j < co->co_argcount; j++) {
Guido van Rossuma027efa1997-05-05 20:56:21 +0000489 PyObject *nm = PyTuple_GET_ITEM(
490 co->co_varnames, j);
Guido van Rossumb209a111997-04-29 18:18:01 +0000491 if (PyObject_Compare(keyword, nm) == 0)
Guido van Rossum681d79a1995-07-18 14:51:37 +0000492 break;
493 }
Guido van Rossumc8b6df91997-05-23 00:06:51 +0000494 /* Check errors from Compare */
495 if (PyErr_Occurred())
496 goto fail;
Guido van Rossum681d79a1995-07-18 14:51:37 +0000497 if (j >= co->co_argcount) {
498 if (kwdict == NULL) {
Guido van Rossumb209a111997-04-29 18:18:01 +0000499 PyErr_Format(PyExc_TypeError,
Fred Drake661ea262000-10-24 19:57:45 +0000500 "%.200s() got an unexpected "
501 "keyword argument '%.400s'",
502 PyString_AsString(co->co_name),
Jeremy Hylton76901512000-03-28 23:49:17 +0000503 PyString_AsString(keyword));
Guido van Rossum681d79a1995-07-18 14:51:37 +0000504 goto fail;
505 }
Guido van Rossumb209a111997-04-29 18:18:01 +0000506 PyDict_SetItem(kwdict, keyword, value);
Guido van Rossum681d79a1995-07-18 14:51:37 +0000507 }
508 else {
509 if (GETLOCAL(j) != NULL) {
Jeremy Hylton76901512000-03-28 23:49:17 +0000510 PyErr_Format(PyExc_TypeError,
Fred Drake661ea262000-10-24 19:57:45 +0000511 "keyword parameter '%.400s' "
512 "redefined in call to %.200s()",
513 PyString_AsString(keyword),
514 PyString_AsString(co->co_name));
Guido van Rossum681d79a1995-07-18 14:51:37 +0000515 goto fail;
516 }
Guido van Rossumb209a111997-04-29 18:18:01 +0000517 Py_INCREF(value);
Guido van Rossum681d79a1995-07-18 14:51:37 +0000518 SETLOCAL(j, value);
519 }
520 }
521 if (argcount < co->co_argcount) {
522 int m = co->co_argcount - defcount;
523 for (i = argcount; i < m; i++) {
524 if (GETLOCAL(i) == NULL) {
Guido van Rossumdf9db1e1997-11-19 16:05:40 +0000525 PyErr_Format(PyExc_TypeError,
Fred Drake661ea262000-10-24 19:57:45 +0000526 "not enough arguments to "
527 "%.200s(); expected %d, got %d",
528 PyString_AsString(co->co_name),
529 m, i);
Guido van Rossum681d79a1995-07-18 14:51:37 +0000530 goto fail;
531 }
532 }
533 if (n > m)
534 i = n - m;
535 else
536 i = 0;
537 for (; i < defcount; i++) {
538 if (GETLOCAL(m+i) == NULL) {
Guido van Rossumb209a111997-04-29 18:18:01 +0000539 PyObject *def = defs[i];
540 Py_INCREF(def);
Guido van Rossum681d79a1995-07-18 14:51:37 +0000541 SETLOCAL(m+i, def);
542 }
543 }
544 }
Guido van Rossum681d79a1995-07-18 14:51:37 +0000545 }
546 else {
547 if (argcount > 0 || kwcount > 0) {
Fred Drake661ea262000-10-24 19:57:45 +0000548 PyErr_Format(PyExc_TypeError,
549 "%.200s() expected no arguments",
550 PyString_AsString(co->co_name));
Guido van Rossum8c5df061997-01-24 04:19:24 +0000551 goto fail;
Guido van Rossum681d79a1995-07-18 14:51:37 +0000552 }
553 }
554
Guido van Rossuma027efa1997-05-05 20:56:21 +0000555 if (tstate->sys_tracefunc != NULL) {
556 /* tstate->sys_tracefunc, if defined, is a function that
557 will be called on *every* entry to a code block.
Guido van Rossum96a42c81992-01-12 02:29:51 +0000558 Its return value, if not None, is a function that
559 will be called at the start of each executed line
560 of code. (Actually, the function must return
561 itself in order to continue tracing.)
562 The trace functions are called with three arguments:
563 a pointer to the current frame, a string indicating
564 why the function is called, and an argument which
565 depends on the situation. The global trace function
566 (sys.trace) is also called whenever an exception
567 is detected. */
Guido van Rossuma027efa1997-05-05 20:56:21 +0000568 if (call_trace(&tstate->sys_tracefunc,
569 &f->f_trace, f, "call",
Guido van Rossumb209a111997-04-29 18:18:01 +0000570 Py_None/*XXX how to compute arguments now?*/)) {
Guido van Rossum96a42c81992-01-12 02:29:51 +0000571 /* Trace function raised an error */
Guido van Rossum8c5df061997-01-24 04:19:24 +0000572 goto fail;
Guido van Rossum96a42c81992-01-12 02:29:51 +0000573 }
Guido van Rossum9c8d70d1992-03-23 18:19:28 +0000574 }
575
Guido van Rossuma027efa1997-05-05 20:56:21 +0000576 if (tstate->sys_profilefunc != NULL) {
577 /* Similar for sys_profilefunc, except it needn't return
Guido van Rossum9c8d70d1992-03-23 18:19:28 +0000578 itself and isn't called for "line" events */
Guido van Rossuma027efa1997-05-05 20:56:21 +0000579 if (call_trace(&tstate->sys_profilefunc,
580 (PyObject**)0, f, "call",
Guido van Rossumb209a111997-04-29 18:18:01 +0000581 Py_None/*XXX*/)) {
Guido van Rossum8c5df061997-01-24 04:19:24 +0000582 goto fail;
Guido van Rossum96a42c81992-01-12 02:29:51 +0000583 }
584 }
Guido van Rossume59214e1994-08-30 08:01:59 +0000585
Jeremy Hyltonee5adfb2000-08-31 19:23:01 +0000586 if (++tstate->recursion_depth > recursion_limit) {
Guido van Rossuma027efa1997-05-05 20:56:21 +0000587 --tstate->recursion_depth;
588 PyErr_SetString(PyExc_RuntimeError,
Fred Drake661ea262000-10-24 19:57:45 +0000589 "maximum recursion depth exceeded");
Guido van Rossuma027efa1997-05-05 20:56:21 +0000590 tstate->frame = f->f_back;
Guido van Rossumb209a111997-04-29 18:18:01 +0000591 Py_DECREF(f);
Guido van Rossum8861b741996-07-30 16:49:37 +0000592 return NULL;
593 }
594
Guido van Rossumd076c731998-10-07 19:42:25 +0000595 _PyCode_GETCODEPTR(co, &first_instr);
596 next_instr = first_instr;
Guido van Rossum374a9221991-04-04 10:40:29 +0000597 stack_pointer = f->f_valuestack;
598
Guido van Rossum374a9221991-04-04 10:40:29 +0000599 why = WHY_NOT;
600 err = 0;
Guido van Rossumb209a111997-04-29 18:18:01 +0000601 x = Py_None; /* Not a reference, just anything non-NULL */
Fred Drake48fba732000-10-11 13:54:07 +0000602 w = NULL;
Guido van Rossum374a9221991-04-04 10:40:29 +0000603
604 for (;;) {
Guido van Rossuma027efa1997-05-05 20:56:21 +0000605 /* Do periodic things. Doing this every time through
606 the loop would add too much overhead, so we do it
607 only every Nth instruction. We also do it if
608 ``things_to_do'' is set, i.e. when an asynchronous
609 event needs attention (e.g. a signal handler or
610 async I/O handler); see Py_AddPendingCall() and
611 Py_MakePendingCalls() above. */
Guido van Rossuma9672091994-09-14 13:31:22 +0000612
Guido van Rossuma027efa1997-05-05 20:56:21 +0000613 if (things_to_do || --tstate->ticker < 0) {
Guido van Rossum25ce5661997-08-02 03:10:38 +0000614 tstate->ticker = tstate->interp->checkinterval;
Guido van Rossuma027efa1997-05-05 20:56:21 +0000615 if (things_to_do) {
Guido van Rossum8861b741996-07-30 16:49:37 +0000616 if (Py_MakePendingCalls() < 0) {
617 why = WHY_EXCEPTION;
618 goto on_error;
619 }
620 }
Guido van Rossumdf0d00e1997-05-20 15:57:49 +0000621#if !defined(HAVE_SIGNAL_H) || defined(macintosh)
Guido van Rossuma027efa1997-05-05 20:56:21 +0000622 /* If we have true signals, the signal handler
623 will call Py_AddPendingCall() so we don't
624 have to call sigcheck(). On the Mac and
625 DOS, alas, we have to call it. */
Guido van Rossumb209a111997-04-29 18:18:01 +0000626 if (PyErr_CheckSignals()) {
Guido van Rossum374a9221991-04-04 10:40:29 +0000627 why = WHY_EXCEPTION;
Guido van Rossum374a9221991-04-04 10:40:29 +0000628 goto on_error;
629 }
Guido van Rossum70d44781997-01-21 06:15:24 +0000630#endif
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000631
Guido van Rossume59214e1994-08-30 08:01:59 +0000632#ifdef WITH_THREAD
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000633 if (interpreter_lock) {
634 /* Give another thread a chance */
635
Guido van Rossum25ce5661997-08-02 03:10:38 +0000636 if (PyThreadState_Swap(NULL) != tstate)
637 Py_FatalError("ceval: tstate mix-up");
Guido van Rossum65d5b571998-12-21 19:32:43 +0000638 PyThread_release_lock(interpreter_lock);
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000639
640 /* Other threads may run now */
641
Guido van Rossum65d5b571998-12-21 19:32:43 +0000642 PyThread_acquire_lock(interpreter_lock, 1);
Guido van Rossum25ce5661997-08-02 03:10:38 +0000643 if (PyThreadState_Swap(tstate) != NULL)
644 Py_FatalError("ceval: orphan tstate");
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000645 }
646#endif
Guido van Rossum374a9221991-04-04 10:40:29 +0000647 }
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000648
Guido van Rossum374a9221991-04-04 10:40:29 +0000649 /* Extract opcode and argument */
Guido van Rossum99bec951992-09-03 20:29:45 +0000650
Guido van Rossum408027e1996-12-30 16:17:54 +0000651#if defined(Py_DEBUG) || defined(LLTRACE)
Guido van Rossum99bec951992-09-03 20:29:45 +0000652 f->f_lasti = INSTR_OFFSET();
653#endif
Guido van Rossum374a9221991-04-04 10:40:29 +0000654
655 opcode = NEXTOP();
656 if (HAS_ARG(opcode))
657 oparg = NEXTARG();
Fred Drakeef8ace32000-08-24 00:32:09 +0000658 dispatch_opcode:
Guido van Rossum950361c1997-01-24 13:49:28 +0000659#ifdef DYNAMIC_EXECUTION_PROFILE
660#ifdef DXPAIRS
661 dxpairs[lastopcode][opcode]++;
662 lastopcode = opcode;
663#endif
664 dxp[opcode]++;
665#endif
Guido van Rossum374a9221991-04-04 10:40:29 +0000666
Guido van Rossum96a42c81992-01-12 02:29:51 +0000667#ifdef LLTRACE
Guido van Rossum374a9221991-04-04 10:40:29 +0000668 /* Instruction tracing */
669
Guido van Rossum96a42c81992-01-12 02:29:51 +0000670 if (lltrace) {
Guido van Rossum374a9221991-04-04 10:40:29 +0000671 if (HAS_ARG(opcode)) {
672 printf("%d: %d, %d\n",
673 (int) (INSTR_OFFSET() - 3),
674 opcode, oparg);
675 }
676 else {
677 printf("%d: %d\n",
678 (int) (INSTR_OFFSET() - 1), opcode);
679 }
680 }
681#endif
Guido van Rossum374a9221991-04-04 10:40:29 +0000682 /* Main switch on opcode */
Jeremy Hylton52820442001-01-03 23:52:36 +0000683
Guido van Rossum374a9221991-04-04 10:40:29 +0000684 switch (opcode) {
685
686 /* BEWARE!
687 It is essential that any operation that fails sets either
688 x to NULL, err to nonzero, or why to anything but WHY_NOT,
689 and that no operation that succeeds does this! */
690
691 /* case STOP_CODE: this is an error! */
692
693 case POP_TOP:
694 v = POP();
Guido van Rossumb209a111997-04-29 18:18:01 +0000695 Py_DECREF(v);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +0000696 continue;
Guido van Rossum374a9221991-04-04 10:40:29 +0000697
698 case ROT_TWO:
699 v = POP();
700 w = POP();
701 PUSH(v);
702 PUSH(w);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +0000703 continue;
Guido van Rossum374a9221991-04-04 10:40:29 +0000704
705 case ROT_THREE:
706 v = POP();
707 w = POP();
708 x = POP();
709 PUSH(v);
710 PUSH(x);
711 PUSH(w);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +0000712 continue;
Guido van Rossum374a9221991-04-04 10:40:29 +0000713
Thomas Wouters434d0822000-08-24 20:11:32 +0000714 case ROT_FOUR:
715 u = POP();
716 v = POP();
717 w = POP();
718 x = POP();
719 PUSH(u);
720 PUSH(x);
721 PUSH(w);
722 PUSH(v);
723 continue;
724
Guido van Rossum374a9221991-04-04 10:40:29 +0000725 case DUP_TOP:
726 v = TOP();
Guido van Rossumb209a111997-04-29 18:18:01 +0000727 Py_INCREF(v);
Guido van Rossum374a9221991-04-04 10:40:29 +0000728 PUSH(v);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +0000729 continue;
Guido van Rossum374a9221991-04-04 10:40:29 +0000730
Thomas Wouters434d0822000-08-24 20:11:32 +0000731 case DUP_TOPX:
732 switch (oparg) {
Thomas Wouters434d0822000-08-24 20:11:32 +0000733 case 1:
Tim Peters35ba6892000-10-11 07:04:49 +0000734 x = TOP();
735 Py_INCREF(x);
736 PUSH(x);
737 continue;
738 case 2:
Thomas Wouters434d0822000-08-24 20:11:32 +0000739 x = POP();
Tim Peters35ba6892000-10-11 07:04:49 +0000740 Py_INCREF(x);
741 w = TOP();
742 Py_INCREF(w);
743 PUSH(x);
744 PUSH(w);
745 PUSH(x);
746 continue;
747 case 3:
748 x = POP();
749 Py_INCREF(x);
Thomas Wouters434d0822000-08-24 20:11:32 +0000750 w = POP();
Tim Peters35ba6892000-10-11 07:04:49 +0000751 Py_INCREF(w);
752 v = TOP();
753 Py_INCREF(v);
754 PUSH(w);
755 PUSH(x);
756 PUSH(v);
757 PUSH(w);
758 PUSH(x);
759 continue;
760 case 4:
761 x = POP();
762 Py_INCREF(x);
763 w = POP();
764 Py_INCREF(w);
Thomas Wouters434d0822000-08-24 20:11:32 +0000765 v = POP();
Tim Peters35ba6892000-10-11 07:04:49 +0000766 Py_INCREF(v);
767 u = TOP();
768 Py_INCREF(u);
769 PUSH(v);
770 PUSH(w);
771 PUSH(x);
772 PUSH(u);
773 PUSH(v);
774 PUSH(w);
775 PUSH(x);
776 continue;
777 case 5:
778 x = POP();
779 Py_INCREF(x);
780 w = POP();
781 Py_INCREF(w);
782 v = POP();
783 Py_INCREF(v);
Thomas Wouters434d0822000-08-24 20:11:32 +0000784 u = POP();
Tim Peters35ba6892000-10-11 07:04:49 +0000785 Py_INCREF(u);
786 t = TOP();
787 Py_INCREF(t);
788 PUSH(u);
789 PUSH(v);
790 PUSH(w);
791 PUSH(x);
792 PUSH(t);
793 PUSH(u);
794 PUSH(v);
795 PUSH(w);
796 PUSH(x);
797 continue;
Thomas Wouters434d0822000-08-24 20:11:32 +0000798 default:
Thomas Wouters0be483f2000-10-11 23:26:11 +0000799 Py_FatalError("invalid argument to DUP_TOPX"
800 " (bytecode corruption?)");
Thomas Wouters434d0822000-08-24 20:11:32 +0000801 }
Tim Peters35ba6892000-10-11 07:04:49 +0000802 break;
Thomas Wouters434d0822000-08-24 20:11:32 +0000803
Guido van Rossum374a9221991-04-04 10:40:29 +0000804 case UNARY_POSITIVE:
805 v = POP();
Guido van Rossumfc490731997-05-06 15:06:49 +0000806 x = PyNumber_Positive(v);
Guido van Rossumb209a111997-04-29 18:18:01 +0000807 Py_DECREF(v);
Guido van Rossum374a9221991-04-04 10:40:29 +0000808 PUSH(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +0000809 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +0000810 break;
811
812 case UNARY_NEGATIVE:
813 v = POP();
Guido van Rossumfc490731997-05-06 15:06:49 +0000814 x = PyNumber_Negative(v);
Guido van Rossumb209a111997-04-29 18:18:01 +0000815 Py_DECREF(v);
Guido van Rossum374a9221991-04-04 10:40:29 +0000816 PUSH(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +0000817 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +0000818 break;
819
820 case UNARY_NOT:
821 v = POP();
Guido van Rossumfc490731997-05-06 15:06:49 +0000822 err = PyObject_IsTrue(v);
Guido van Rossumb209a111997-04-29 18:18:01 +0000823 Py_DECREF(v);
Guido van Rossumfc490731997-05-06 15:06:49 +0000824 if (err == 0) {
825 Py_INCREF(Py_True);
826 PUSH(Py_True);
827 continue;
828 }
829 else if (err > 0) {
830 Py_INCREF(Py_False);
831 PUSH(Py_False);
832 err = 0;
833 continue;
834 }
Guido van Rossum374a9221991-04-04 10:40:29 +0000835 break;
836
837 case UNARY_CONVERT:
838 v = POP();
Guido van Rossumb209a111997-04-29 18:18:01 +0000839 x = PyObject_Repr(v);
840 Py_DECREF(v);
Guido van Rossum374a9221991-04-04 10:40:29 +0000841 PUSH(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +0000842 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +0000843 break;
Guido van Rossum7928cd71991-10-24 14:59:31 +0000844
845 case UNARY_INVERT:
846 v = POP();
Guido van Rossumfc490731997-05-06 15:06:49 +0000847 x = PyNumber_Invert(v);
Guido van Rossumb209a111997-04-29 18:18:01 +0000848 Py_DECREF(v);
Guido van Rossum7928cd71991-10-24 14:59:31 +0000849 PUSH(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +0000850 if (x != NULL) continue;
Guido van Rossum7928cd71991-10-24 14:59:31 +0000851 break;
Guido van Rossum374a9221991-04-04 10:40:29 +0000852
Guido van Rossum50564e81996-01-12 01:13:16 +0000853 case BINARY_POWER:
854 w = POP();
855 v = POP();
Guido van Rossumfc490731997-05-06 15:06:49 +0000856 x = PyNumber_Power(v, w, Py_None);
Guido van Rossumb209a111997-04-29 18:18:01 +0000857 Py_DECREF(v);
858 Py_DECREF(w);
Guido van Rossum50564e81996-01-12 01:13:16 +0000859 PUSH(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +0000860 if (x != NULL) continue;
Guido van Rossum50564e81996-01-12 01:13:16 +0000861 break;
862
Guido van Rossum374a9221991-04-04 10:40:29 +0000863 case BINARY_MULTIPLY:
864 w = POP();
865 v = POP();
Guido van Rossumfc490731997-05-06 15:06:49 +0000866 x = PyNumber_Multiply(v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +0000867 Py_DECREF(v);
868 Py_DECREF(w);
Guido van Rossum374a9221991-04-04 10:40:29 +0000869 PUSH(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +0000870 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +0000871 break;
872
873 case BINARY_DIVIDE:
874 w = POP();
875 v = POP();
Guido van Rossumfc490731997-05-06 15:06:49 +0000876 x = PyNumber_Divide(v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +0000877 Py_DECREF(v);
878 Py_DECREF(w);
Guido van Rossum374a9221991-04-04 10:40:29 +0000879 PUSH(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +0000880 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +0000881 break;
882
883 case BINARY_MODULO:
884 w = POP();
885 v = POP();
Guido van Rossumfc490731997-05-06 15:06:49 +0000886 x = PyNumber_Remainder(v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +0000887 Py_DECREF(v);
888 Py_DECREF(w);
Guido van Rossum374a9221991-04-04 10:40:29 +0000889 PUSH(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +0000890 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +0000891 break;
892
893 case BINARY_ADD:
894 w = POP();
895 v = POP();
Guido van Rossumc12da691997-07-17 23:12:42 +0000896 if (PyInt_Check(v) && PyInt_Check(w)) {
897 /* INLINE: int + int */
898 register long a, b, i;
Guido van Rossumcf183ac1998-12-04 18:51:36 +0000899 a = PyInt_AS_LONG(v);
900 b = PyInt_AS_LONG(w);
Guido van Rossumc12da691997-07-17 23:12:42 +0000901 i = a + b;
902 if ((i^a) < 0 && (i^b) < 0) {
903 PyErr_SetString(PyExc_OverflowError,
904 "integer addition");
905 x = NULL;
906 }
907 else
908 x = PyInt_FromLong(i);
909 }
910 else
911 x = PyNumber_Add(v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +0000912 Py_DECREF(v);
913 Py_DECREF(w);
Guido van Rossum374a9221991-04-04 10:40:29 +0000914 PUSH(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +0000915 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +0000916 break;
917
918 case BINARY_SUBTRACT:
919 w = POP();
920 v = POP();
Guido van Rossumc12da691997-07-17 23:12:42 +0000921 if (PyInt_Check(v) && PyInt_Check(w)) {
922 /* INLINE: int - int */
923 register long a, b, i;
Guido van Rossumcf183ac1998-12-04 18:51:36 +0000924 a = PyInt_AS_LONG(v);
925 b = PyInt_AS_LONG(w);
Guido van Rossumc12da691997-07-17 23:12:42 +0000926 i = a - b;
927 if ((i^a) < 0 && (i^~b) < 0) {
928 PyErr_SetString(PyExc_OverflowError,
929 "integer subtraction");
930 x = NULL;
931 }
932 else
933 x = PyInt_FromLong(i);
934 }
935 else
936 x = PyNumber_Subtract(v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +0000937 Py_DECREF(v);
938 Py_DECREF(w);
Guido van Rossum374a9221991-04-04 10:40:29 +0000939 PUSH(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +0000940 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +0000941 break;
942
943 case BINARY_SUBSCR:
944 w = POP();
945 v = POP();
Guido van Rossumc12da691997-07-17 23:12:42 +0000946 if (PyList_Check(v) && PyInt_Check(w)) {
947 /* INLINE: list[int] */
948 long i = PyInt_AsLong(w);
949 if (i < 0)
Guido van Rossumfa00e951998-07-08 15:02:37 +0000950 i += PyList_GET_SIZE(v);
Guido van Rossumc12da691997-07-17 23:12:42 +0000951 if (i < 0 ||
Guido van Rossumfa00e951998-07-08 15:02:37 +0000952 i >= PyList_GET_SIZE(v)) {
Guido van Rossumc12da691997-07-17 23:12:42 +0000953 PyErr_SetString(PyExc_IndexError,
954 "list index out of range");
955 x = NULL;
956 }
957 else {
Guido van Rossumfa00e951998-07-08 15:02:37 +0000958 x = PyList_GET_ITEM(v, i);
Guido van Rossumc12da691997-07-17 23:12:42 +0000959 Py_INCREF(x);
960 }
961 }
962 else
963 x = PyObject_GetItem(v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +0000964 Py_DECREF(v);
965 Py_DECREF(w);
Guido van Rossum374a9221991-04-04 10:40:29 +0000966 PUSH(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +0000967 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +0000968 break;
969
Guido van Rossum7928cd71991-10-24 14:59:31 +0000970 case BINARY_LSHIFT:
971 w = POP();
972 v = POP();
Guido van Rossumfc490731997-05-06 15:06:49 +0000973 x = PyNumber_Lshift(v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +0000974 Py_DECREF(v);
975 Py_DECREF(w);
Guido van Rossum7928cd71991-10-24 14:59:31 +0000976 PUSH(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +0000977 if (x != NULL) continue;
Guido van Rossum7928cd71991-10-24 14:59:31 +0000978 break;
979
980 case BINARY_RSHIFT:
981 w = POP();
982 v = POP();
Guido van Rossumfc490731997-05-06 15:06:49 +0000983 x = PyNumber_Rshift(v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +0000984 Py_DECREF(v);
985 Py_DECREF(w);
Guido van Rossum7928cd71991-10-24 14:59:31 +0000986 PUSH(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +0000987 if (x != NULL) continue;
Guido van Rossum7928cd71991-10-24 14:59:31 +0000988 break;
989
990 case BINARY_AND:
991 w = POP();
992 v = POP();
Guido van Rossumfc490731997-05-06 15:06:49 +0000993 x = PyNumber_And(v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +0000994 Py_DECREF(v);
995 Py_DECREF(w);
Guido van Rossum7928cd71991-10-24 14:59:31 +0000996 PUSH(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +0000997 if (x != NULL) continue;
Guido van Rossum7928cd71991-10-24 14:59:31 +0000998 break;
999
1000 case BINARY_XOR:
1001 w = POP();
1002 v = POP();
Guido van Rossumfc490731997-05-06 15:06:49 +00001003 x = PyNumber_Xor(v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +00001004 Py_DECREF(v);
1005 Py_DECREF(w);
Guido van Rossum7928cd71991-10-24 14:59:31 +00001006 PUSH(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001007 if (x != NULL) continue;
Guido van Rossum7928cd71991-10-24 14:59:31 +00001008 break;
1009
1010 case BINARY_OR:
1011 w = POP();
1012 v = POP();
Guido van Rossumfc490731997-05-06 15:06:49 +00001013 x = PyNumber_Or(v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +00001014 Py_DECREF(v);
1015 Py_DECREF(w);
Guido van Rossum7928cd71991-10-24 14:59:31 +00001016 PUSH(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001017 if (x != NULL) continue;
Guido van Rossum7928cd71991-10-24 14:59:31 +00001018 break;
Thomas Wouters434d0822000-08-24 20:11:32 +00001019
1020 case INPLACE_POWER:
1021 w = POP();
1022 v = POP();
1023 x = PyNumber_InPlacePower(v, w, Py_None);
1024 Py_DECREF(v);
1025 Py_DECREF(w);
1026 PUSH(x);
1027 if (x != NULL) continue;
1028 break;
Guido van Rossum7928cd71991-10-24 14:59:31 +00001029
Thomas Wouters434d0822000-08-24 20:11:32 +00001030 case INPLACE_MULTIPLY:
1031 w = POP();
1032 v = POP();
1033 x = PyNumber_InPlaceMultiply(v, w);
1034 Py_DECREF(v);
1035 Py_DECREF(w);
1036 PUSH(x);
1037 if (x != NULL) continue;
1038 break;
1039
1040 case INPLACE_DIVIDE:
1041 w = POP();
1042 v = POP();
1043 x = PyNumber_InPlaceDivide(v, w);
1044 Py_DECREF(v);
1045 Py_DECREF(w);
1046 PUSH(x);
1047 if (x != NULL) continue;
1048 break;
1049
1050 case INPLACE_MODULO:
1051 w = POP();
1052 v = POP();
1053 x = PyNumber_InPlaceRemainder(v, w);
1054 Py_DECREF(v);
1055 Py_DECREF(w);
1056 PUSH(x);
1057 if (x != NULL) continue;
1058 break;
1059
1060 case INPLACE_ADD:
1061 w = POP();
1062 v = POP();
1063 if (PyInt_Check(v) && PyInt_Check(w)) {
1064 /* INLINE: int + int */
1065 register long a, b, i;
1066 a = PyInt_AS_LONG(v);
1067 b = PyInt_AS_LONG(w);
1068 i = a + b;
1069 if ((i^a) < 0 && (i^b) < 0) {
1070 PyErr_SetString(PyExc_OverflowError,
1071 "integer addition");
1072 x = NULL;
1073 }
1074 else
1075 x = PyInt_FromLong(i);
1076 }
1077 else
1078 x = PyNumber_InPlaceAdd(v, w);
1079 Py_DECREF(v);
1080 Py_DECREF(w);
1081 PUSH(x);
1082 if (x != NULL) continue;
1083 break;
1084
1085 case INPLACE_SUBTRACT:
1086 w = POP();
1087 v = POP();
1088 if (PyInt_Check(v) && PyInt_Check(w)) {
1089 /* INLINE: int - int */
1090 register long a, b, i;
1091 a = PyInt_AS_LONG(v);
1092 b = PyInt_AS_LONG(w);
1093 i = a - b;
1094 if ((i^a) < 0 && (i^~b) < 0) {
1095 PyErr_SetString(PyExc_OverflowError,
1096 "integer subtraction");
1097 x = NULL;
1098 }
1099 else
1100 x = PyInt_FromLong(i);
1101 }
1102 else
1103 x = PyNumber_InPlaceSubtract(v, w);
1104 Py_DECREF(v);
1105 Py_DECREF(w);
1106 PUSH(x);
1107 if (x != NULL) continue;
1108 break;
1109
1110 case INPLACE_LSHIFT:
1111 w = POP();
1112 v = POP();
1113 x = PyNumber_InPlaceLshift(v, w);
1114 Py_DECREF(v);
1115 Py_DECREF(w);
1116 PUSH(x);
1117 if (x != NULL) continue;
1118 break;
1119
1120 case INPLACE_RSHIFT:
1121 w = POP();
1122 v = POP();
1123 x = PyNumber_InPlaceRshift(v, w);
1124 Py_DECREF(v);
1125 Py_DECREF(w);
1126 PUSH(x);
1127 if (x != NULL) continue;
1128 break;
1129
1130 case INPLACE_AND:
1131 w = POP();
1132 v = POP();
1133 x = PyNumber_InPlaceAnd(v, w);
1134 Py_DECREF(v);
1135 Py_DECREF(w);
1136 PUSH(x);
1137 if (x != NULL) continue;
1138 break;
1139
1140 case INPLACE_XOR:
1141 w = POP();
1142 v = POP();
1143 x = PyNumber_InPlaceXor(v, w);
1144 Py_DECREF(v);
1145 Py_DECREF(w);
1146 PUSH(x);
1147 if (x != NULL) continue;
1148 break;
1149
1150 case INPLACE_OR:
1151 w = POP();
1152 v = POP();
1153 x = PyNumber_InPlaceOr(v, w);
1154 Py_DECREF(v);
1155 Py_DECREF(w);
1156 PUSH(x);
1157 if (x != NULL) continue;
1158 break;
1159
Guido van Rossum374a9221991-04-04 10:40:29 +00001160 case SLICE+0:
1161 case SLICE+1:
1162 case SLICE+2:
1163 case SLICE+3:
1164 if ((opcode-SLICE) & 2)
1165 w = POP();
1166 else
1167 w = NULL;
1168 if ((opcode-SLICE) & 1)
1169 v = POP();
1170 else
1171 v = NULL;
1172 u = POP();
1173 x = apply_slice(u, v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +00001174 Py_DECREF(u);
1175 Py_XDECREF(v);
1176 Py_XDECREF(w);
Guido van Rossum374a9221991-04-04 10:40:29 +00001177 PUSH(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001178 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001179 break;
1180
1181 case STORE_SLICE+0:
1182 case STORE_SLICE+1:
1183 case STORE_SLICE+2:
1184 case STORE_SLICE+3:
1185 if ((opcode-STORE_SLICE) & 2)
1186 w = POP();
1187 else
1188 w = NULL;
1189 if ((opcode-STORE_SLICE) & 1)
1190 v = POP();
1191 else
1192 v = NULL;
1193 u = POP();
1194 t = POP();
1195 err = assign_slice(u, v, w, t); /* u[v:w] = t */
Guido van Rossumb209a111997-04-29 18:18:01 +00001196 Py_DECREF(t);
1197 Py_DECREF(u);
1198 Py_XDECREF(v);
1199 Py_XDECREF(w);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001200 if (err == 0) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001201 break;
1202
1203 case DELETE_SLICE+0:
1204 case DELETE_SLICE+1:
1205 case DELETE_SLICE+2:
1206 case DELETE_SLICE+3:
1207 if ((opcode-DELETE_SLICE) & 2)
1208 w = POP();
1209 else
1210 w = NULL;
1211 if ((opcode-DELETE_SLICE) & 1)
1212 v = POP();
1213 else
1214 v = NULL;
1215 u = POP();
Guido van Rossumb209a111997-04-29 18:18:01 +00001216 err = assign_slice(u, v, w, (PyObject *)NULL);
Guido van Rossum374a9221991-04-04 10:40:29 +00001217 /* del u[v:w] */
Guido van Rossumb209a111997-04-29 18:18:01 +00001218 Py_DECREF(u);
1219 Py_XDECREF(v);
1220 Py_XDECREF(w);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001221 if (err == 0) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001222 break;
1223
1224 case STORE_SUBSCR:
1225 w = POP();
1226 v = POP();
1227 u = POP();
1228 /* v[w] = u */
Guido van Rossumfc490731997-05-06 15:06:49 +00001229 err = PyObject_SetItem(v, w, u);
Guido van Rossumb209a111997-04-29 18:18:01 +00001230 Py_DECREF(u);
1231 Py_DECREF(v);
1232 Py_DECREF(w);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001233 if (err == 0) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001234 break;
1235
1236 case DELETE_SUBSCR:
1237 w = POP();
1238 v = POP();
1239 /* del v[w] */
Guido van Rossumfc490731997-05-06 15:06:49 +00001240 err = PyObject_DelItem(v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +00001241 Py_DECREF(v);
1242 Py_DECREF(w);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001243 if (err == 0) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001244 break;
Barry Warsaw23c9ec82000-08-21 15:44:01 +00001245
Guido van Rossum374a9221991-04-04 10:40:29 +00001246 case PRINT_EXPR:
1247 v = POP();
Moshe Zadkaf68f2fe2001-01-11 05:41:27 +00001248 w = PySys_GetObject("displayhook");
1249 if (w == NULL) {
1250 PyErr_SetString(PyExc_RuntimeError,
1251 "lost sys.displayhook");
1252 err = -1;
1253 }
1254 if (err == 0) {
1255 x = Py_BuildValue("(O)", v);
1256 if (x == NULL)
1257 err = -1;
1258 }
1259 if (err == 0) {
1260 w = PyEval_CallObject(w, x);
1261 if (w == NULL)
1262 err = -1;
Guido van Rossum374a9221991-04-04 10:40:29 +00001263 }
Guido van Rossumb209a111997-04-29 18:18:01 +00001264 Py_DECREF(v);
Moshe Zadkaf68f2fe2001-01-11 05:41:27 +00001265 Py_XDECREF(x);
Guido van Rossum374a9221991-04-04 10:40:29 +00001266 break;
Moshe Zadkaf68f2fe2001-01-11 05:41:27 +00001267
Barry Warsaw23c9ec82000-08-21 15:44:01 +00001268 case PRINT_ITEM_TO:
1269 w = stream = POP();
1270 /* fall through to PRINT_ITEM */
1271
Guido van Rossum374a9221991-04-04 10:40:29 +00001272 case PRINT_ITEM:
1273 v = POP();
Barry Warsaw093abe02000-08-29 04:56:13 +00001274 if (stream == NULL || stream == Py_None) {
Barry Warsaw23c9ec82000-08-21 15:44:01 +00001275 w = PySys_GetObject("stdout");
1276 if (w == NULL) {
1277 PyErr_SetString(PyExc_RuntimeError,
1278 "lost sys.stdout");
1279 err = -1;
1280 }
Guido van Rossum8f183201997-12-31 05:53:15 +00001281 }
Barry Warsaw23c9ec82000-08-21 15:44:01 +00001282 if (w != NULL && PyFile_SoftSpace(w, 1))
Guido van Rossumbe270261997-05-22 22:26:18 +00001283 err = PyFile_WriteString(" ", w);
1284 if (err == 0)
1285 err = PyFile_WriteObject(v, w, Py_PRINT_RAW);
Guido van Rossumb209a111997-04-29 18:18:01 +00001286 if (err == 0 && PyString_Check(v)) {
Guido van Rossumc6004111993-11-05 10:22:19 +00001287 /* XXX move into writeobject() ? */
Guido van Rossumb209a111997-04-29 18:18:01 +00001288 char *s = PyString_AsString(v);
1289 int len = PyString_Size(v);
Guido van Rossum7f7f2741995-02-10 17:01:56 +00001290 if (len > 0 &&
1291 isspace(Py_CHARMASK(s[len-1])) &&
Guido van Rossumc6004111993-11-05 10:22:19 +00001292 s[len-1] != ' ')
Guido van Rossumb209a111997-04-29 18:18:01 +00001293 PyFile_SoftSpace(w, 0);
Guido van Rossum374a9221991-04-04 10:40:29 +00001294 }
Guido van Rossumb209a111997-04-29 18:18:01 +00001295 Py_DECREF(v);
Barry Warsaw23c9ec82000-08-21 15:44:01 +00001296 Py_XDECREF(stream);
1297 stream = NULL;
1298 if (err == 0)
1299 continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001300 break;
1301
Barry Warsaw23c9ec82000-08-21 15:44:01 +00001302 case PRINT_NEWLINE_TO:
1303 w = stream = POP();
1304 /* fall through to PRINT_NEWLINE */
1305
Guido van Rossum374a9221991-04-04 10:40:29 +00001306 case PRINT_NEWLINE:
Barry Warsaw093abe02000-08-29 04:56:13 +00001307 if (stream == NULL || stream == Py_None) {
Barry Warsaw23c9ec82000-08-21 15:44:01 +00001308 w = PySys_GetObject("stdout");
1309 if (w == NULL)
1310 PyErr_SetString(PyExc_RuntimeError,
1311 "lost sys.stdout");
Guido van Rossum3165fe61992-09-25 21:59:05 +00001312 }
Barry Warsaw23c9ec82000-08-21 15:44:01 +00001313 if (w != NULL) {
1314 err = PyFile_WriteString("\n", w);
1315 if (err == 0)
1316 PyFile_SoftSpace(w, 0);
1317 }
1318 Py_XDECREF(stream);
1319 stream = NULL;
Guido van Rossum374a9221991-04-04 10:40:29 +00001320 break;
1321
Thomas Wouters434d0822000-08-24 20:11:32 +00001322
1323#ifdef CASE_TOO_BIG
1324 default: switch (opcode) {
1325#endif
Guido van Rossum374a9221991-04-04 10:40:29 +00001326 case BREAK_LOOP:
1327 why = WHY_BREAK;
1328 break;
Guido van Rossumf10570b1995-07-07 22:53:21 +00001329
Guido van Rossumf10570b1995-07-07 22:53:21 +00001330 case RAISE_VARARGS:
1331 u = v = w = NULL;
1332 switch (oparg) {
1333 case 3:
1334 u = POP(); /* traceback */
Guido van Rossumf10570b1995-07-07 22:53:21 +00001335 /* Fallthrough */
1336 case 2:
1337 v = POP(); /* value */
1338 /* Fallthrough */
1339 case 1:
1340 w = POP(); /* exc */
Guido van Rossumd295f121998-04-09 21:39:57 +00001341 case 0: /* Fallthrough */
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00001342 why = do_raise(w, v, u);
Guido van Rossumf10570b1995-07-07 22:53:21 +00001343 break;
1344 default:
Guido van Rossumb209a111997-04-29 18:18:01 +00001345 PyErr_SetString(PyExc_SystemError,
Guido van Rossumf10570b1995-07-07 22:53:21 +00001346 "bad RAISE_VARARGS oparg");
Guido van Rossumf10570b1995-07-07 22:53:21 +00001347 why = WHY_EXCEPTION;
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00001348 break;
1349 }
Guido van Rossum374a9221991-04-04 10:40:29 +00001350 break;
1351
1352 case LOAD_LOCALS:
Guido van Rossum681d79a1995-07-18 14:51:37 +00001353 if ((x = f->f_locals) == NULL) {
Guido van Rossuma027efa1997-05-05 20:56:21 +00001354 PyErr_SetString(PyExc_SystemError,
1355 "no locals");
Guido van Rossum681d79a1995-07-18 14:51:37 +00001356 break;
1357 }
Guido van Rossumb209a111997-04-29 18:18:01 +00001358 Py_INCREF(x);
Guido van Rossum681d79a1995-07-18 14:51:37 +00001359 PUSH(x);
Guido van Rossum374a9221991-04-04 10:40:29 +00001360 break;
1361
1362 case RETURN_VALUE:
1363 retval = POP();
1364 why = WHY_RETURN;
1365 break;
Guido van Rossumdb3165e1993-10-18 17:06:59 +00001366
Guido van Rossumdb3165e1993-10-18 17:06:59 +00001367 case EXEC_STMT:
1368 w = POP();
1369 v = POP();
1370 u = POP();
Guido van Rossuma027efa1997-05-05 20:56:21 +00001371 err = exec_statement(f, u, v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +00001372 Py_DECREF(u);
1373 Py_DECREF(v);
1374 Py_DECREF(w);
Guido van Rossumdb3165e1993-10-18 17:06:59 +00001375 break;
Guido van Rossum374a9221991-04-04 10:40:29 +00001376
Guido van Rossum374a9221991-04-04 10:40:29 +00001377 case POP_BLOCK:
1378 {
Guido van Rossumb209a111997-04-29 18:18:01 +00001379 PyTryBlock *b = PyFrame_BlockPop(f);
Guido van Rossum374a9221991-04-04 10:40:29 +00001380 while (STACK_LEVEL() > b->b_level) {
1381 v = POP();
Guido van Rossumb209a111997-04-29 18:18:01 +00001382 Py_DECREF(v);
Guido van Rossum374a9221991-04-04 10:40:29 +00001383 }
1384 }
1385 break;
1386
1387 case END_FINALLY:
1388 v = POP();
Guido van Rossumb209a111997-04-29 18:18:01 +00001389 if (PyInt_Check(v)) {
1390 why = (enum why_code) PyInt_AsLong(v);
Guido van Rossum374a9221991-04-04 10:40:29 +00001391 if (why == WHY_RETURN)
1392 retval = POP();
1393 }
Guido van Rossumb209a111997-04-29 18:18:01 +00001394 else if (PyString_Check(v) || PyClass_Check(v)) {
Guido van Rossum374a9221991-04-04 10:40:29 +00001395 w = POP();
Guido van Rossumf10570b1995-07-07 22:53:21 +00001396 u = POP();
Guido van Rossumb209a111997-04-29 18:18:01 +00001397 PyErr_Restore(v, w, u);
Guido van Rossum374a9221991-04-04 10:40:29 +00001398 why = WHY_RERAISE;
Guido van Rossum0db1ef91995-07-28 23:06:00 +00001399 break;
Guido van Rossum374a9221991-04-04 10:40:29 +00001400 }
Guido van Rossumb209a111997-04-29 18:18:01 +00001401 else if (v != Py_None) {
1402 PyErr_SetString(PyExc_SystemError,
Guido van Rossum374a9221991-04-04 10:40:29 +00001403 "'finally' pops bad exception");
1404 why = WHY_EXCEPTION;
1405 }
Guido van Rossumb209a111997-04-29 18:18:01 +00001406 Py_DECREF(v);
Guido van Rossum374a9221991-04-04 10:40:29 +00001407 break;
1408
1409 case BUILD_CLASS:
Guido van Rossum25831651993-05-19 14:50:45 +00001410 u = POP();
Guido van Rossum374a9221991-04-04 10:40:29 +00001411 v = POP();
Guido van Rossum25831651993-05-19 14:50:45 +00001412 w = POP();
1413 x = build_class(u, v, w);
Guido van Rossum374a9221991-04-04 10:40:29 +00001414 PUSH(x);
Guido van Rossumb209a111997-04-29 18:18:01 +00001415 Py_DECREF(u);
1416 Py_DECREF(v);
1417 Py_DECREF(w);
Guido van Rossum374a9221991-04-04 10:40:29 +00001418 break;
1419
1420 case STORE_NAME:
1421 w = GETNAMEV(oparg);
1422 v = POP();
Guido van Rossum681d79a1995-07-18 14:51:37 +00001423 if ((x = f->f_locals) == NULL) {
Guido van Rossuma027efa1997-05-05 20:56:21 +00001424 PyErr_SetString(PyExc_SystemError,
1425 "no locals");
Guido van Rossum681d79a1995-07-18 14:51:37 +00001426 break;
1427 }
Guido van Rossumb209a111997-04-29 18:18:01 +00001428 err = PyDict_SetItem(x, w, v);
1429 Py_DECREF(v);
Guido van Rossum374a9221991-04-04 10:40:29 +00001430 break;
1431
1432 case DELETE_NAME:
Guido van Rossumdf62e441991-08-16 08:56:04 +00001433 w = GETNAMEV(oparg);
Guido van Rossum681d79a1995-07-18 14:51:37 +00001434 if ((x = f->f_locals) == NULL) {
Guido van Rossuma027efa1997-05-05 20:56:21 +00001435 PyErr_SetString(PyExc_SystemError,
1436 "no locals");
Guido van Rossum681d79a1995-07-18 14:51:37 +00001437 break;
1438 }
Guido van Rossumb209a111997-04-29 18:18:01 +00001439 if ((err = PyDict_DelItem(x, w)) != 0)
Paul Prescode68140d2000-08-30 20:25:01 +00001440 format_exc_check_arg(PyExc_NameError,
1441 NAME_ERROR_MSG ,w);
Guido van Rossum374a9221991-04-04 10:40:29 +00001442 break;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001443
Thomas Wouters0be5aab2000-08-11 22:15:52 +00001444 case UNPACK_SEQUENCE:
Guido van Rossum374a9221991-04-04 10:40:29 +00001445 v = POP();
Barry Warsawe42b18f1997-08-25 22:13:04 +00001446 if (PyTuple_Check(v)) {
1447 if (PyTuple_Size(v) != oparg) {
1448 PyErr_SetString(PyExc_ValueError,
1449 "unpack tuple of wrong size");
1450 why = WHY_EXCEPTION;
1451 }
1452 else {
1453 for (; --oparg >= 0; ) {
1454 w = PyTuple_GET_ITEM(v, oparg);
1455 Py_INCREF(w);
1456 PUSH(w);
1457 }
1458 }
Guido van Rossum374a9221991-04-04 10:40:29 +00001459 }
Barry Warsawe42b18f1997-08-25 22:13:04 +00001460 else if (PyList_Check(v)) {
1461 if (PyList_Size(v) != oparg) {
1462 PyErr_SetString(PyExc_ValueError,
1463 "unpack list of wrong size");
1464 why = WHY_EXCEPTION;
1465 }
1466 else {
1467 for (; --oparg >= 0; ) {
1468 w = PyList_GET_ITEM(v, oparg);
1469 Py_INCREF(w);
1470 PUSH(w);
1471 }
1472 }
1473 }
1474 else if (PySequence_Check(v)) {
1475 if (unpack_sequence(v, oparg,
1476 stack_pointer + oparg))
1477 stack_pointer += oparg;
1478 else
1479 why = WHY_EXCEPTION;
Guido van Rossum374a9221991-04-04 10:40:29 +00001480 }
1481 else {
Barry Warsawe42b18f1997-08-25 22:13:04 +00001482 PyErr_SetString(PyExc_TypeError,
1483 "unpack non-sequence");
1484 why = WHY_EXCEPTION;
Guido van Rossum374a9221991-04-04 10:40:29 +00001485 }
Guido van Rossumb209a111997-04-29 18:18:01 +00001486 Py_DECREF(v);
Guido van Rossum374a9221991-04-04 10:40:29 +00001487 break;
1488
1489 case STORE_ATTR:
Guido van Rossum9bfef441993-03-29 10:43:31 +00001490 w = GETNAMEV(oparg);
Guido van Rossum374a9221991-04-04 10:40:29 +00001491 v = POP();
1492 u = POP();
Guido van Rossumb209a111997-04-29 18:18:01 +00001493 err = PyObject_SetAttr(v, w, u); /* v.w = u */
1494 Py_DECREF(v);
1495 Py_DECREF(u);
Guido van Rossum374a9221991-04-04 10:40:29 +00001496 break;
1497
1498 case DELETE_ATTR:
Guido van Rossum9bfef441993-03-29 10:43:31 +00001499 w = GETNAMEV(oparg);
Guido van Rossum374a9221991-04-04 10:40:29 +00001500 v = POP();
Guido van Rossuma027efa1997-05-05 20:56:21 +00001501 err = PyObject_SetAttr(v, w, (PyObject *)NULL);
1502 /* del v.w */
Guido van Rossumb209a111997-04-29 18:18:01 +00001503 Py_DECREF(v);
Guido van Rossum374a9221991-04-04 10:40:29 +00001504 break;
1505
Guido van Rossum32c6cdf1991-12-10 13:52:46 +00001506 case STORE_GLOBAL:
1507 w = GETNAMEV(oparg);
1508 v = POP();
Guido van Rossumb209a111997-04-29 18:18:01 +00001509 err = PyDict_SetItem(f->f_globals, w, v);
1510 Py_DECREF(v);
Guido van Rossum32c6cdf1991-12-10 13:52:46 +00001511 break;
1512
1513 case DELETE_GLOBAL:
1514 w = GETNAMEV(oparg);
Guido van Rossumb209a111997-04-29 18:18:01 +00001515 if ((err = PyDict_DelItem(f->f_globals, w)) != 0)
Paul Prescode68140d2000-08-30 20:25:01 +00001516 format_exc_check_arg(
1517 PyExc_NameError, NAME_ERROR_MSG ,w);
Guido van Rossum32c6cdf1991-12-10 13:52:46 +00001518 break;
1519
Guido van Rossum374a9221991-04-04 10:40:29 +00001520 case LOAD_CONST:
1521 x = GETCONST(oparg);
Guido van Rossumb209a111997-04-29 18:18:01 +00001522 Py_INCREF(x);
Guido van Rossum374a9221991-04-04 10:40:29 +00001523 PUSH(x);
1524 break;
1525
1526 case LOAD_NAME:
Guido van Rossumdf62e441991-08-16 08:56:04 +00001527 w = GETNAMEV(oparg);
Guido van Rossum681d79a1995-07-18 14:51:37 +00001528 if ((x = f->f_locals) == NULL) {
Guido van Rossuma027efa1997-05-05 20:56:21 +00001529 PyErr_SetString(PyExc_SystemError,
1530 "no locals");
Guido van Rossum681d79a1995-07-18 14:51:37 +00001531 break;
1532 }
Guido van Rossumb209a111997-04-29 18:18:01 +00001533 x = PyDict_GetItem(x, w);
Guido van Rossum374a9221991-04-04 10:40:29 +00001534 if (x == NULL) {
Guido van Rossumb209a111997-04-29 18:18:01 +00001535 x = PyDict_GetItem(f->f_globals, w);
Guido van Rossum374a9221991-04-04 10:40:29 +00001536 if (x == NULL) {
Guido van Rossumb209a111997-04-29 18:18:01 +00001537 x = PyDict_GetItem(f->f_builtins, w);
Guido van Rossum374a9221991-04-04 10:40:29 +00001538 if (x == NULL) {
Paul Prescode68140d2000-08-30 20:25:01 +00001539 format_exc_check_arg(
1540 PyExc_NameError,
1541 NAME_ERROR_MSG ,w);
Guido van Rossum374a9221991-04-04 10:40:29 +00001542 break;
1543 }
1544 }
1545 }
Guido van Rossumb209a111997-04-29 18:18:01 +00001546 Py_INCREF(x);
Guido van Rossum374a9221991-04-04 10:40:29 +00001547 PUSH(x);
1548 break;
1549
1550 case LOAD_GLOBAL:
Guido van Rossumdf62e441991-08-16 08:56:04 +00001551 w = GETNAMEV(oparg);
Guido van Rossumb209a111997-04-29 18:18:01 +00001552 x = PyDict_GetItem(f->f_globals, w);
Guido van Rossum374a9221991-04-04 10:40:29 +00001553 if (x == NULL) {
Guido van Rossumb209a111997-04-29 18:18:01 +00001554 x = PyDict_GetItem(f->f_builtins, w);
Guido van Rossum374a9221991-04-04 10:40:29 +00001555 if (x == NULL) {
Paul Prescode68140d2000-08-30 20:25:01 +00001556 format_exc_check_arg(
1557 PyExc_NameError,
1558 NAME_ERROR_MSG ,w);
Guido van Rossum374a9221991-04-04 10:40:29 +00001559 break;
1560 }
1561 }
Guido van Rossumb209a111997-04-29 18:18:01 +00001562 Py_INCREF(x);
Guido van Rossum374a9221991-04-04 10:40:29 +00001563 PUSH(x);
1564 break;
Guido van Rossum681d79a1995-07-18 14:51:37 +00001565
Guido van Rossum9bfef441993-03-29 10:43:31 +00001566 case LOAD_FAST:
Guido van Rossum681d79a1995-07-18 14:51:37 +00001567 x = GETLOCAL(oparg);
Guido van Rossum8b17d6b1993-03-30 13:18:41 +00001568 if (x == NULL) {
Paul Prescode68140d2000-08-30 20:25:01 +00001569 format_exc_check_arg(
1570 PyExc_UnboundLocalError,
1571 UNBOUNDLOCAL_ERROR_MSG,
1572 PyTuple_GetItem(co->co_varnames, oparg)
1573 );
Guido van Rossum8b17d6b1993-03-30 13:18:41 +00001574 break;
1575 }
Guido van Rossumb209a111997-04-29 18:18:01 +00001576 Py_INCREF(x);
Guido van Rossum8b17d6b1993-03-30 13:18:41 +00001577 PUSH(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001578 if (x != NULL) continue;
Guido van Rossum9bfef441993-03-29 10:43:31 +00001579 break;
1580
1581 case STORE_FAST:
Guido van Rossum25831651993-05-19 14:50:45 +00001582 v = POP();
Guido van Rossum681d79a1995-07-18 14:51:37 +00001583 SETLOCAL(oparg, v);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001584 continue;
Guido van Rossum8b17d6b1993-03-30 13:18:41 +00001585
1586 case DELETE_FAST:
Guido van Rossum2e4c8991998-05-12 20:27:36 +00001587 x = GETLOCAL(oparg);
1588 if (x == NULL) {
Paul Prescode68140d2000-08-30 20:25:01 +00001589 format_exc_check_arg(
1590 PyExc_UnboundLocalError,
1591 UNBOUNDLOCAL_ERROR_MSG,
1592 PyTuple_GetItem(co->co_varnames, oparg)
1593 );
Guido van Rossum2e4c8991998-05-12 20:27:36 +00001594 break;
1595 }
Guido van Rossum681d79a1995-07-18 14:51:37 +00001596 SETLOCAL(oparg, NULL);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001597 continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001598
1599 case BUILD_TUPLE:
Guido van Rossumb209a111997-04-29 18:18:01 +00001600 x = PyTuple_New(oparg);
Guido van Rossum374a9221991-04-04 10:40:29 +00001601 if (x != NULL) {
1602 for (; --oparg >= 0;) {
1603 w = POP();
Guido van Rossumb209a111997-04-29 18:18:01 +00001604 PyTuple_SET_ITEM(x, oparg, w);
Guido van Rossum374a9221991-04-04 10:40:29 +00001605 }
1606 PUSH(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001607 continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001608 }
1609 break;
1610
1611 case BUILD_LIST:
Guido van Rossumb209a111997-04-29 18:18:01 +00001612 x = PyList_New(oparg);
Guido van Rossum374a9221991-04-04 10:40:29 +00001613 if (x != NULL) {
1614 for (; --oparg >= 0;) {
1615 w = POP();
Guido van Rossum5053efc1998-08-04 15:27:50 +00001616 PyList_SET_ITEM(x, oparg, w);
Guido van Rossum374a9221991-04-04 10:40:29 +00001617 }
1618 PUSH(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001619 continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001620 }
1621 break;
1622
1623 case BUILD_MAP:
Guido van Rossumb209a111997-04-29 18:18:01 +00001624 x = PyDict_New();
Guido van Rossum374a9221991-04-04 10:40:29 +00001625 PUSH(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001626 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001627 break;
1628
1629 case LOAD_ATTR:
Guido van Rossum9bfef441993-03-29 10:43:31 +00001630 w = GETNAMEV(oparg);
Guido van Rossum374a9221991-04-04 10:40:29 +00001631 v = POP();
Guido van Rossumb209a111997-04-29 18:18:01 +00001632 x = PyObject_GetAttr(v, w);
1633 Py_DECREF(v);
Guido van Rossum374a9221991-04-04 10:40:29 +00001634 PUSH(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001635 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001636 break;
1637
1638 case COMPARE_OP:
1639 w = POP();
1640 v = POP();
Guido van Rossumc12da691997-07-17 23:12:42 +00001641 if (PyInt_Check(v) && PyInt_Check(w)) {
1642 /* INLINE: cmp(int, int) */
1643 register long a, b;
1644 register int res;
Guido van Rossumcf183ac1998-12-04 18:51:36 +00001645 a = PyInt_AS_LONG(v);
1646 b = PyInt_AS_LONG(w);
Guido van Rossumc12da691997-07-17 23:12:42 +00001647 switch (oparg) {
1648 case LT: res = a < b; break;
1649 case LE: res = a <= b; break;
1650 case EQ: res = a == b; break;
1651 case NE: res = a != b; break;
1652 case GT: res = a > b; break;
1653 case GE: res = a >= b; break;
1654 case IS: res = v == w; break;
1655 case IS_NOT: res = v != w; break;
1656 default: goto slow_compare;
1657 }
1658 x = res ? Py_True : Py_False;
1659 Py_INCREF(x);
1660 }
1661 else {
1662 slow_compare:
1663 x = cmp_outcome(oparg, v, w);
1664 }
Guido van Rossumb209a111997-04-29 18:18:01 +00001665 Py_DECREF(v);
1666 Py_DECREF(w);
Guido van Rossum374a9221991-04-04 10:40:29 +00001667 PUSH(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001668 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001669 break;
1670
1671 case IMPORT_NAME:
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001672 w = GETNAMEV(oparg);
Guido van Rossumb209a111997-04-29 18:18:01 +00001673 x = PyDict_GetItemString(f->f_builtins, "__import__");
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001674 if (x == NULL) {
Guido van Rossumb209a111997-04-29 18:18:01 +00001675 PyErr_SetString(PyExc_ImportError,
Guido van Rossumfc490731997-05-06 15:06:49 +00001676 "__import__ not found");
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001677 break;
1678 }
Thomas Woutersdd13e4f2000-08-27 20:31:27 +00001679 u = POP();
Guido van Rossumb209a111997-04-29 18:18:01 +00001680 w = Py_BuildValue("(OOOO)",
Guido van Rossum681d79a1995-07-18 14:51:37 +00001681 w,
1682 f->f_globals,
Guido van Rossuma027efa1997-05-05 20:56:21 +00001683 f->f_locals == NULL ?
1684 Py_None : f->f_locals,
Guido van Rossum681d79a1995-07-18 14:51:37 +00001685 u);
Guido van Rossumb209a111997-04-29 18:18:01 +00001686 Py_DECREF(u);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001687 if (w == NULL) {
1688 x = NULL;
1689 break;
1690 }
Guido van Rossumb209a111997-04-29 18:18:01 +00001691 x = PyEval_CallObject(x, w);
1692 Py_DECREF(w);
Guido van Rossumf10570b1995-07-07 22:53:21 +00001693 PUSH(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001694 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001695 break;
1696
Thomas Wouters52152252000-08-17 22:55:00 +00001697 case IMPORT_STAR:
1698 v = POP();
Guido van Rossumb209a111997-04-29 18:18:01 +00001699 PyFrame_FastToLocals(f);
Guido van Rossum681d79a1995-07-18 14:51:37 +00001700 if ((x = f->f_locals) == NULL) {
Guido van Rossuma027efa1997-05-05 20:56:21 +00001701 PyErr_SetString(PyExc_SystemError,
1702 "no locals");
Guido van Rossum681d79a1995-07-18 14:51:37 +00001703 break;
1704 }
Thomas Wouters52152252000-08-17 22:55:00 +00001705 err = import_all_from(x, v);
Guido van Rossumb209a111997-04-29 18:18:01 +00001706 PyFrame_LocalsToFast(f, 0);
Thomas Wouters52152252000-08-17 22:55:00 +00001707 Py_DECREF(v);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001708 if (err == 0) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001709 break;
Guido van Rossum25831651993-05-19 14:50:45 +00001710
Thomas Wouters52152252000-08-17 22:55:00 +00001711 case IMPORT_FROM:
1712 w = GETNAMEV(oparg);
1713 v = TOP();
1714 x = import_from(v, w);
1715 PUSH(x);
1716 if (x != NULL) continue;
1717 break;
1718
Guido van Rossum374a9221991-04-04 10:40:29 +00001719 case JUMP_FORWARD:
1720 JUMPBY(oparg);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001721 continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001722
1723 case JUMP_IF_FALSE:
Guido van Rossumb209a111997-04-29 18:18:01 +00001724 err = PyObject_IsTrue(TOP());
Guido van Rossum04691fc1992-08-12 15:35:34 +00001725 if (err > 0)
1726 err = 0;
1727 else if (err == 0)
Guido van Rossum374a9221991-04-04 10:40:29 +00001728 JUMPBY(oparg);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001729 else
1730 break;
1731 continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001732
1733 case JUMP_IF_TRUE:
Guido van Rossumb209a111997-04-29 18:18:01 +00001734 err = PyObject_IsTrue(TOP());
Guido van Rossum04691fc1992-08-12 15:35:34 +00001735 if (err > 0) {
1736 err = 0;
Guido van Rossum374a9221991-04-04 10:40:29 +00001737 JUMPBY(oparg);
Guido van Rossum04691fc1992-08-12 15:35:34 +00001738 }
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001739 else if (err == 0)
1740 ;
1741 else
1742 break;
1743 continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001744
1745 case JUMP_ABSOLUTE:
1746 JUMPTO(oparg);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001747 continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001748
1749 case FOR_LOOP:
1750 /* for v in s: ...
1751 On entry: stack contains s, i.
1752 On exit: stack contains s, i+1, s[i];
1753 but if loop exhausted:
1754 s, i are popped, and we jump */
1755 w = POP(); /* Loop index */
1756 v = POP(); /* Sequence object */
1757 u = loop_subscript(v, w);
1758 if (u != NULL) {
1759 PUSH(v);
Guido van Rossumb209a111997-04-29 18:18:01 +00001760 x = PyInt_FromLong(PyInt_AsLong(w)+1);
Guido van Rossum374a9221991-04-04 10:40:29 +00001761 PUSH(x);
Guido van Rossumb209a111997-04-29 18:18:01 +00001762 Py_DECREF(w);
Guido van Rossum374a9221991-04-04 10:40:29 +00001763 PUSH(u);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001764 if (x != NULL) continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001765 }
1766 else {
Guido van Rossumb209a111997-04-29 18:18:01 +00001767 Py_DECREF(v);
1768 Py_DECREF(w);
Guido van Rossum374a9221991-04-04 10:40:29 +00001769 /* A NULL can mean "s exhausted"
1770 but also an error: */
Guido van Rossumb209a111997-04-29 18:18:01 +00001771 if (PyErr_Occurred())
Guido van Rossum374a9221991-04-04 10:40:29 +00001772 why = WHY_EXCEPTION;
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001773 else {
Guido van Rossum374a9221991-04-04 10:40:29 +00001774 JUMPBY(oparg);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001775 continue;
1776 }
Guido van Rossum374a9221991-04-04 10:40:29 +00001777 }
1778 break;
1779
1780 case SETUP_LOOP:
1781 case SETUP_EXCEPT:
1782 case SETUP_FINALLY:
Guido van Rossumb209a111997-04-29 18:18:01 +00001783 PyFrame_BlockSetup(f, opcode, INSTR_OFFSET() + oparg,
Guido van Rossum374a9221991-04-04 10:40:29 +00001784 STACK_LEVEL());
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001785 continue;
Guido van Rossum374a9221991-04-04 10:40:29 +00001786
1787 case SET_LINENO:
Guido van Rossum96a42c81992-01-12 02:29:51 +00001788#ifdef LLTRACE
1789 if (lltrace)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001790 printf("--- %s:%d \n", filename, oparg);
Guido van Rossum374a9221991-04-04 10:40:29 +00001791#endif
Guido van Rossum96a42c81992-01-12 02:29:51 +00001792 f->f_lineno = oparg;
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001793 if (f->f_trace == NULL)
1794 continue;
1795 /* Trace each line of code reached */
1796 f->f_lasti = INSTR_OFFSET();
1797 err = call_trace(&f->f_trace, &f->f_trace,
Guido van Rossumb209a111997-04-29 18:18:01 +00001798 f, "line", Py_None);
Guido van Rossum374a9221991-04-04 10:40:29 +00001799 break;
Guido van Rossumf10570b1995-07-07 22:53:21 +00001800
1801 case CALL_FUNCTION:
Jeremy Hylton52820442001-01-03 23:52:36 +00001802 {
1803 int na = oparg & 0xff;
1804 int nk = (oparg>>8) & 0xff;
1805 int n = na + 2 * nk;
1806 PyObject **pfunc = stack_pointer - n - 1;
1807 PyObject *func = *pfunc;
1808 f->f_lasti = INSTR_OFFSET() - 3; /* For tracing */
1809
1810 /* Always dispatch PyCFunction first, because
1811 these are presumed to be the most frequent
1812 callable object.
1813 */
1814 if (PyCFunction_Check(func)) {
1815 if (PyCFunction_GET_FLAGS(func) == 0) {
1816 x = fast_cfunction(func,
1817 &stack_pointer, na);
1818 } else {
1819 x = do_call(func, &stack_pointer,
1820 na, nk);
1821 }
1822 } else {
1823 if (PyMethod_Check(func)
1824 && PyMethod_GET_SELF(func) != NULL) {
1825 /* optimize access to bound methods */
1826 PyObject *self = PyMethod_GET_SELF(func);
1827 Py_INCREF(self);
1828 func = PyMethod_GET_FUNCTION(func);
1829 Py_INCREF(func);
1830 Py_DECREF(*pfunc);
1831 *pfunc = self;
1832 na++;
1833 n++;
1834 } else
1835 Py_INCREF(func);
1836 if (PyFunction_Check(func)) {
1837 x = fast_function(func, &stack_pointer,
1838 n, na, nk);
1839 } else {
1840 x = do_call(func, &stack_pointer,
1841 na, nk);
1842 }
1843 Py_DECREF(func);
1844 }
1845
1846 while (stack_pointer > pfunc) {
1847 w = POP();
1848 Py_DECREF(w);
1849 }
1850 PUSH(x);
1851 if (x != NULL)
1852 continue;
1853 break;
1854 }
1855
Jeremy Hylton76901512000-03-28 23:49:17 +00001856 case CALL_FUNCTION_VAR:
1857 case CALL_FUNCTION_KW:
1858 case CALL_FUNCTION_VAR_KW:
Guido van Rossumf10570b1995-07-07 22:53:21 +00001859 {
Jeremy Hylton76901512000-03-28 23:49:17 +00001860 int na = oparg & 0xff;
1861 int nk = (oparg>>8) & 0xff;
1862 int flags = (opcode - CALL_FUNCTION) & 3;
Jeremy Hylton52820442001-01-03 23:52:36 +00001863 int n = na + 2 * nk;
1864 PyObject **pfunc, *func;
1865 if (flags & CALL_FLAG_VAR)
1866 n++;
1867 if (flags & CALL_FLAG_KW)
1868 n++;
1869 pfunc = stack_pointer - n - 1;
1870 func = *pfunc;
Jeremy Hylton76901512000-03-28 23:49:17 +00001871 f->f_lasti = INSTR_OFFSET() - 3; /* For tracing */
Jeremy Hylton52820442001-01-03 23:52:36 +00001872
1873 if (PyMethod_Check(func)
1874 && PyMethod_GET_SELF(func) != NULL) {
1875 PyObject *self = PyMethod_GET_SELF(func);
Jeremy Hylton76901512000-03-28 23:49:17 +00001876 Py_INCREF(self);
Jeremy Hylton52820442001-01-03 23:52:36 +00001877 func = PyMethod_GET_FUNCTION(func);
1878 Py_INCREF(func);
Jeremy Hylton76901512000-03-28 23:49:17 +00001879 Py_DECREF(*pfunc);
1880 *pfunc = self;
1881 na++;
1882 n++;
Jeremy Hylton52820442001-01-03 23:52:36 +00001883 } else
1884 Py_INCREF(func);
1885 x = ext_do_call(func, &stack_pointer, flags, na, nk);
Jeremy Hylton76901512000-03-28 23:49:17 +00001886 Py_DECREF(func);
Jeremy Hylton52820442001-01-03 23:52:36 +00001887
Jeremy Hylton76901512000-03-28 23:49:17 +00001888 while (stack_pointer > pfunc) {
Jeremy Hylton52820442001-01-03 23:52:36 +00001889 w = POP();
1890 Py_DECREF(w);
Jeremy Hylton76901512000-03-28 23:49:17 +00001891 }
1892 PUSH(x);
Jeremy Hylton52820442001-01-03 23:52:36 +00001893 if (x != NULL)
1894 continue;
Jeremy Hylton76901512000-03-28 23:49:17 +00001895 break;
Guido van Rossumf10570b1995-07-07 22:53:21 +00001896 }
Guido van Rossum374a9221991-04-04 10:40:29 +00001897
Guido van Rossum681d79a1995-07-18 14:51:37 +00001898 case MAKE_FUNCTION:
1899 v = POP(); /* code object */
Guido van Rossumb209a111997-04-29 18:18:01 +00001900 x = PyFunction_New(v, f->f_globals);
1901 Py_DECREF(v);
Guido van Rossum681d79a1995-07-18 14:51:37 +00001902 /* XXX Maybe this should be a separate opcode? */
1903 if (x != NULL && oparg > 0) {
Guido van Rossumb209a111997-04-29 18:18:01 +00001904 v = PyTuple_New(oparg);
Guido van Rossum681d79a1995-07-18 14:51:37 +00001905 if (v == NULL) {
Guido van Rossumb209a111997-04-29 18:18:01 +00001906 Py_DECREF(x);
Guido van Rossum681d79a1995-07-18 14:51:37 +00001907 x = NULL;
1908 break;
1909 }
1910 while (--oparg >= 0) {
1911 w = POP();
Guido van Rossumb209a111997-04-29 18:18:01 +00001912 PyTuple_SET_ITEM(v, oparg, w);
Guido van Rossum681d79a1995-07-18 14:51:37 +00001913 }
1914 err = PyFunction_SetDefaults(x, v);
Guido van Rossumb209a111997-04-29 18:18:01 +00001915 Py_DECREF(v);
Guido van Rossum681d79a1995-07-18 14:51:37 +00001916 }
1917 PUSH(x);
1918 break;
Guido van Rossum8861b741996-07-30 16:49:37 +00001919
1920 case BUILD_SLICE:
1921 if (oparg == 3)
1922 w = POP();
1923 else
1924 w = NULL;
1925 v = POP();
1926 u = POP();
Guido van Rossum1aa14831997-01-21 05:34:20 +00001927 x = PySlice_New(u, v, w);
Guido van Rossumb209a111997-04-29 18:18:01 +00001928 Py_DECREF(u);
1929 Py_DECREF(v);
1930 Py_XDECREF(w);
Guido van Rossum8861b741996-07-30 16:49:37 +00001931 PUSH(x);
Guido van Rossum3dfd53b1997-01-18 02:46:13 +00001932 if (x != NULL) continue;
Guido van Rossum8861b741996-07-30 16:49:37 +00001933 break;
1934
Fred Drakeef8ace32000-08-24 00:32:09 +00001935 case EXTENDED_ARG:
1936 opcode = NEXTOP();
1937 oparg = oparg<<16 | NEXTARG();
1938 goto dispatch_opcode;
1939 break;
Guido van Rossum8861b741996-07-30 16:49:37 +00001940
Guido van Rossum374a9221991-04-04 10:40:29 +00001941 default:
1942 fprintf(stderr,
1943 "XXX lineno: %d, opcode: %d\n",
Guido van Rossum96a42c81992-01-12 02:29:51 +00001944 f->f_lineno, opcode);
Guido van Rossumb209a111997-04-29 18:18:01 +00001945 PyErr_SetString(PyExc_SystemError, "unknown opcode");
Guido van Rossum374a9221991-04-04 10:40:29 +00001946 why = WHY_EXCEPTION;
1947 break;
Guido van Rossum04691fc1992-08-12 15:35:34 +00001948
1949#ifdef CASE_TOO_BIG
1950 }
1951#endif
1952
Guido van Rossum374a9221991-04-04 10:40:29 +00001953 } /* switch */
1954
1955 on_error:
1956
1957 /* Quickly continue if no error occurred */
1958
1959 if (why == WHY_NOT) {
Guido van Rossum681d79a1995-07-18 14:51:37 +00001960 if (err == 0 && x != NULL) {
1961#ifdef CHECKEXC
Guido van Rossumeb894eb1999-03-09 16:16:45 +00001962 /* This check is expensive! */
Guido van Rossumb209a111997-04-29 18:18:01 +00001963 if (PyErr_Occurred())
Guido van Rossum681d79a1995-07-18 14:51:37 +00001964 fprintf(stderr,
1965 "XXX undetected error\n");
1966 else
1967#endif
1968 continue; /* Normal, fast path */
1969 }
Guido van Rossum374a9221991-04-04 10:40:29 +00001970 why = WHY_EXCEPTION;
Guido van Rossumb209a111997-04-29 18:18:01 +00001971 x = Py_None;
Guido van Rossum374a9221991-04-04 10:40:29 +00001972 err = 0;
1973 }
1974
Guido van Rossum374a9221991-04-04 10:40:29 +00001975 /* Double-check exception status */
1976
1977 if (why == WHY_EXCEPTION || why == WHY_RERAISE) {
Guido van Rossumb209a111997-04-29 18:18:01 +00001978 if (!PyErr_Occurred()) {
Guido van Rossuma027efa1997-05-05 20:56:21 +00001979 PyErr_SetString(PyExc_SystemError,
Guido van Rossumeb894eb1999-03-09 16:16:45 +00001980 "error return without exception set");
Guido van Rossum374a9221991-04-04 10:40:29 +00001981 why = WHY_EXCEPTION;
1982 }
1983 }
Guido van Rossumeb894eb1999-03-09 16:16:45 +00001984#ifdef CHECKEXC
Guido van Rossum374a9221991-04-04 10:40:29 +00001985 else {
Guido van Rossumeb894eb1999-03-09 16:16:45 +00001986 /* This check is expensive! */
Guido van Rossumb209a111997-04-29 18:18:01 +00001987 if (PyErr_Occurred()) {
Guido van Rossum681d79a1995-07-18 14:51:37 +00001988 fprintf(stderr,
1989 "XXX undetected error (why=%d)\n",
1990 why);
1991 why = WHY_EXCEPTION;
1992 }
Guido van Rossum374a9221991-04-04 10:40:29 +00001993 }
1994#endif
1995
1996 /* Log traceback info if this is a real exception */
1997
1998 if (why == WHY_EXCEPTION) {
Guido van Rossum96a42c81992-01-12 02:29:51 +00001999 f->f_lasti = INSTR_OFFSET() - 1;
Guido van Rossum374a9221991-04-04 10:40:29 +00002000 if (HAS_ARG(opcode))
Guido van Rossum96a42c81992-01-12 02:29:51 +00002001 f->f_lasti -= 2;
Guido van Rossumb209a111997-04-29 18:18:01 +00002002 PyTraceBack_Here(f);
Guido van Rossum96a42c81992-01-12 02:29:51 +00002003
Guido van Rossume59214e1994-08-30 08:01:59 +00002004 if (f->f_trace)
2005 call_exc_trace(&f->f_trace, &f->f_trace, f);
Guido van Rossuma027efa1997-05-05 20:56:21 +00002006 if (tstate->sys_profilefunc)
2007 call_exc_trace(&tstate->sys_profilefunc,
2008 (PyObject**)0, f);
Guido van Rossum014518f1998-11-23 21:09:51 +00002009 }
Guido van Rossum374a9221991-04-04 10:40:29 +00002010
2011 /* For the rest, treat WHY_RERAISE as WHY_EXCEPTION */
2012
2013 if (why == WHY_RERAISE)
2014 why = WHY_EXCEPTION;
2015
2016 /* Unwind stacks if a (pseudo) exception occurred */
2017
2018 while (why != WHY_NOT && f->f_iblock > 0) {
Guido van Rossumb209a111997-04-29 18:18:01 +00002019 PyTryBlock *b = PyFrame_BlockPop(f);
Guido van Rossum374a9221991-04-04 10:40:29 +00002020 while (STACK_LEVEL() > b->b_level) {
2021 v = POP();
Guido van Rossumb209a111997-04-29 18:18:01 +00002022 Py_XDECREF(v);
Guido van Rossum374a9221991-04-04 10:40:29 +00002023 }
2024 if (b->b_type == SETUP_LOOP && why == WHY_BREAK) {
2025 why = WHY_NOT;
2026 JUMPTO(b->b_handler);
2027 break;
2028 }
2029 if (b->b_type == SETUP_FINALLY ||
Guido van Rossum150b2df1996-12-05 23:17:11 +00002030 (b->b_type == SETUP_EXCEPT &&
2031 why == WHY_EXCEPTION)) {
Guido van Rossum374a9221991-04-04 10:40:29 +00002032 if (why == WHY_EXCEPTION) {
Guido van Rossumb209a111997-04-29 18:18:01 +00002033 PyObject *exc, *val, *tb;
2034 PyErr_Fetch(&exc, &val, &tb);
Guido van Rossum374a9221991-04-04 10:40:29 +00002035 if (val == NULL) {
Guido van Rossumb209a111997-04-29 18:18:01 +00002036 val = Py_None;
2037 Py_INCREF(val);
Guido van Rossum374a9221991-04-04 10:40:29 +00002038 }
Guido van Rossum374a9221991-04-04 10:40:29 +00002039 /* Make the raw exception data
2040 available to the handler,
2041 so a program can emulate the
2042 Python main loop. Don't do
2043 this for 'finally'. */
2044 if (b->b_type == SETUP_EXCEPT) {
Barry Warsaweaedc7c1997-08-28 22:36:40 +00002045 PyErr_NormalizeException(
2046 &exc, &val, &tb);
Guido van Rossuma027efa1997-05-05 20:56:21 +00002047 set_exc_info(tstate,
2048 exc, val, tb);
Guido van Rossum374a9221991-04-04 10:40:29 +00002049 }
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002050 PUSH(tb);
Guido van Rossum374a9221991-04-04 10:40:29 +00002051 PUSH(val);
2052 PUSH(exc);
2053 }
2054 else {
2055 if (why == WHY_RETURN)
2056 PUSH(retval);
Guido van Rossumb209a111997-04-29 18:18:01 +00002057 v = PyInt_FromLong((long)why);
Guido van Rossum374a9221991-04-04 10:40:29 +00002058 PUSH(v);
2059 }
2060 why = WHY_NOT;
2061 JUMPTO(b->b_handler);
2062 break;
2063 }
2064 } /* unwind stack */
2065
2066 /* End the loop if we still have an error (or return) */
2067
2068 if (why != WHY_NOT)
2069 break;
2070
2071 } /* main loop */
2072
2073 /* Pop remaining stack entries */
2074
2075 while (!EMPTY()) {
2076 v = POP();
Guido van Rossumb209a111997-04-29 18:18:01 +00002077 Py_XDECREF(v);
Guido van Rossum374a9221991-04-04 10:40:29 +00002078 }
2079
Guido van Rossum96a42c81992-01-12 02:29:51 +00002080 if (why != WHY_RETURN)
2081 retval = NULL;
2082
Guido van Rossume59214e1994-08-30 08:01:59 +00002083 if (f->f_trace) {
Guido van Rossum96a42c81992-01-12 02:29:51 +00002084 if (why == WHY_RETURN) {
Guido van Rossume59214e1994-08-30 08:01:59 +00002085 if (call_trace(&f->f_trace, &f->f_trace, f,
2086 "return", retval)) {
Guido van Rossumb209a111997-04-29 18:18:01 +00002087 Py_XDECREF(retval);
Guido van Rossum96a42c81992-01-12 02:29:51 +00002088 retval = NULL;
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00002089 why = WHY_EXCEPTION;
Guido van Rossum96a42c81992-01-12 02:29:51 +00002090 }
Guido van Rossum96a42c81992-01-12 02:29:51 +00002091 }
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00002092 }
2093
Guido van Rossuma027efa1997-05-05 20:56:21 +00002094 if (tstate->sys_profilefunc && why == WHY_RETURN) {
2095 if (call_trace(&tstate->sys_profilefunc, (PyObject**)0,
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00002096 f, "return", retval)) {
Guido van Rossumb209a111997-04-29 18:18:01 +00002097 Py_XDECREF(retval);
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00002098 retval = NULL;
2099 why = WHY_EXCEPTION;
2100 }
Guido van Rossum96a42c81992-01-12 02:29:51 +00002101 }
Guido van Rossuma4240131997-01-21 21:18:36 +00002102
Guido van Rossuma027efa1997-05-05 20:56:21 +00002103 reset_exc_info(tstate);
2104
2105 --tstate->recursion_depth;
Guido van Rossum8c5df061997-01-24 04:19:24 +00002106
2107 fail: /* Jump here from prelude on failure */
Guido van Rossum96a42c81992-01-12 02:29:51 +00002108
Guido van Rossum374a9221991-04-04 10:40:29 +00002109 /* Restore previous frame and release the current one */
Guido van Rossum681d79a1995-07-18 14:51:37 +00002110
Guido van Rossuma027efa1997-05-05 20:56:21 +00002111 tstate->frame = f->f_back;
Guido van Rossumb209a111997-04-29 18:18:01 +00002112 Py_DECREF(f);
Guido van Rossum374a9221991-04-04 10:40:29 +00002113
Guido van Rossum96a42c81992-01-12 02:29:51 +00002114 return retval;
Guido van Rossum374a9221991-04-04 10:40:29 +00002115}
2116
Guido van Rossuma027efa1997-05-05 20:56:21 +00002117static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002118set_exc_info(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb)
Guido van Rossuma027efa1997-05-05 20:56:21 +00002119{
2120 PyFrameObject *frame;
Guido van Rossumdf4c3081997-05-20 17:06:11 +00002121 PyObject *tmp_type, *tmp_value, *tmp_tb;
Barry Warsaw4249f541997-08-22 21:26:19 +00002122
Guido van Rossuma027efa1997-05-05 20:56:21 +00002123 frame = tstate->frame;
2124 if (frame->f_exc_type == NULL) {
2125 /* This frame didn't catch an exception before */
2126 /* Save previous exception of this thread in this frame */
Guido van Rossuma027efa1997-05-05 20:56:21 +00002127 if (tstate->exc_type == NULL) {
2128 Py_INCREF(Py_None);
2129 tstate->exc_type = Py_None;
2130 }
Guido van Rossumdf4c3081997-05-20 17:06:11 +00002131 tmp_type = frame->f_exc_type;
2132 tmp_value = frame->f_exc_value;
2133 tmp_tb = frame->f_exc_traceback;
Guido van Rossuma027efa1997-05-05 20:56:21 +00002134 Py_XINCREF(tstate->exc_type);
2135 Py_XINCREF(tstate->exc_value);
2136 Py_XINCREF(tstate->exc_traceback);
2137 frame->f_exc_type = tstate->exc_type;
2138 frame->f_exc_value = tstate->exc_value;
2139 frame->f_exc_traceback = tstate->exc_traceback;
Guido van Rossumdf4c3081997-05-20 17:06:11 +00002140 Py_XDECREF(tmp_type);
2141 Py_XDECREF(tmp_value);
2142 Py_XDECREF(tmp_tb);
Guido van Rossuma027efa1997-05-05 20:56:21 +00002143 }
2144 /* Set new exception for this thread */
Guido van Rossumdf4c3081997-05-20 17:06:11 +00002145 tmp_type = tstate->exc_type;
2146 tmp_value = tstate->exc_value;
2147 tmp_tb = tstate->exc_traceback;
Guido van Rossuma027efa1997-05-05 20:56:21 +00002148 Py_XINCREF(type);
2149 Py_XINCREF(value);
2150 Py_XINCREF(tb);
2151 tstate->exc_type = type;
2152 tstate->exc_value = value;
2153 tstate->exc_traceback = tb;
Guido van Rossumdf4c3081997-05-20 17:06:11 +00002154 Py_XDECREF(tmp_type);
2155 Py_XDECREF(tmp_value);
2156 Py_XDECREF(tmp_tb);
Guido van Rossuma027efa1997-05-05 20:56:21 +00002157 /* For b/w compatibility */
2158 PySys_SetObject("exc_type", type);
2159 PySys_SetObject("exc_value", value);
2160 PySys_SetObject("exc_traceback", tb);
2161}
2162
2163static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002164reset_exc_info(PyThreadState *tstate)
Guido van Rossuma027efa1997-05-05 20:56:21 +00002165{
2166 PyFrameObject *frame;
Guido van Rossumdf4c3081997-05-20 17:06:11 +00002167 PyObject *tmp_type, *tmp_value, *tmp_tb;
Guido van Rossuma027efa1997-05-05 20:56:21 +00002168 frame = tstate->frame;
2169 if (frame->f_exc_type != NULL) {
2170 /* This frame caught an exception */
Guido van Rossumdf4c3081997-05-20 17:06:11 +00002171 tmp_type = tstate->exc_type;
2172 tmp_value = tstate->exc_value;
2173 tmp_tb = tstate->exc_traceback;
Guido van Rossuma027efa1997-05-05 20:56:21 +00002174 Py_XINCREF(frame->f_exc_type);
2175 Py_XINCREF(frame->f_exc_value);
2176 Py_XINCREF(frame->f_exc_traceback);
2177 tstate->exc_type = frame->f_exc_type;
2178 tstate->exc_value = frame->f_exc_value;
2179 tstate->exc_traceback = frame->f_exc_traceback;
Guido van Rossumdf4c3081997-05-20 17:06:11 +00002180 Py_XDECREF(tmp_type);
2181 Py_XDECREF(tmp_value);
2182 Py_XDECREF(tmp_tb);
Guido van Rossuma027efa1997-05-05 20:56:21 +00002183 /* For b/w compatibility */
2184 PySys_SetObject("exc_type", frame->f_exc_type);
2185 PySys_SetObject("exc_value", frame->f_exc_value);
2186 PySys_SetObject("exc_traceback", frame->f_exc_traceback);
2187 }
Guido van Rossumdf4c3081997-05-20 17:06:11 +00002188 tmp_type = frame->f_exc_type;
2189 tmp_value = frame->f_exc_value;
2190 tmp_tb = frame->f_exc_traceback;
Guido van Rossuma027efa1997-05-05 20:56:21 +00002191 frame->f_exc_type = NULL;
2192 frame->f_exc_value = NULL;
2193 frame->f_exc_traceback = NULL;
Guido van Rossumdf4c3081997-05-20 17:06:11 +00002194 Py_XDECREF(tmp_type);
2195 Py_XDECREF(tmp_value);
2196 Py_XDECREF(tmp_tb);
Guido van Rossuma027efa1997-05-05 20:56:21 +00002197}
2198
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00002199/* Logic for the raise statement (too complicated for inlining).
2200 This *consumes* a reference count to each of its arguments. */
Guido van Rossum1aa14831997-01-21 05:34:20 +00002201static enum why_code
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002202do_raise(PyObject *type, PyObject *value, PyObject *tb)
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00002203{
Guido van Rossumd295f121998-04-09 21:39:57 +00002204 if (type == NULL) {
2205 /* Reraise */
2206 PyThreadState *tstate = PyThreadState_Get();
2207 type = tstate->exc_type == NULL ? Py_None : tstate->exc_type;
2208 value = tstate->exc_value;
2209 tb = tstate->exc_traceback;
2210 Py_XINCREF(type);
2211 Py_XINCREF(value);
2212 Py_XINCREF(tb);
2213 }
2214
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00002215 /* We support the following forms of raise:
2216 raise <class>, <classinstance>
2217 raise <class>, <argument tuple>
2218 raise <class>, None
2219 raise <class>, <argument>
2220 raise <classinstance>, None
2221 raise <string>, <object>
2222 raise <string>, None
2223
2224 An omitted second argument is the same as None.
2225
2226 In addition, raise <tuple>, <anything> is the same as
2227 raising the tuple's first item (and it better have one!);
2228 this rule is applied recursively.
2229
2230 Finally, an optional third argument can be supplied, which
2231 gives the traceback to be substituted (useful when
2232 re-raising an exception after examining it). */
2233
2234 /* First, check the traceback argument, replacing None with
2235 NULL. */
Guido van Rossumb209a111997-04-29 18:18:01 +00002236 if (tb == Py_None) {
2237 Py_DECREF(tb);
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00002238 tb = NULL;
2239 }
2240 else if (tb != NULL && !PyTraceBack_Check(tb)) {
Guido van Rossumb209a111997-04-29 18:18:01 +00002241 PyErr_SetString(PyExc_TypeError,
Fred Drake661ea262000-10-24 19:57:45 +00002242 "raise: arg 3 must be a traceback or None");
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00002243 goto raise_error;
2244 }
2245
2246 /* Next, replace a missing value with None */
2247 if (value == NULL) {
Guido van Rossumb209a111997-04-29 18:18:01 +00002248 value = Py_None;
2249 Py_INCREF(value);
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00002250 }
2251
2252 /* Next, repeatedly, replace a tuple exception with its first item */
Guido van Rossumb209a111997-04-29 18:18:01 +00002253 while (PyTuple_Check(type) && PyTuple_Size(type) > 0) {
2254 PyObject *tmp = type;
2255 type = PyTuple_GET_ITEM(type, 0);
2256 Py_INCREF(type);
2257 Py_DECREF(tmp);
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00002258 }
2259
Barry Warsaw4249f541997-08-22 21:26:19 +00002260 if (PyString_Check(type))
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00002261 ;
Barry Warsaw4249f541997-08-22 21:26:19 +00002262
2263 else if (PyClass_Check(type))
2264 PyErr_NormalizeException(&type, &value, &tb);
2265
Guido van Rossumb209a111997-04-29 18:18:01 +00002266 else if (PyInstance_Check(type)) {
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00002267 /* Raising an instance. The value should be a dummy. */
Guido van Rossumb209a111997-04-29 18:18:01 +00002268 if (value != Py_None) {
2269 PyErr_SetString(PyExc_TypeError,
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00002270 "instance exception may not have a separate value");
2271 goto raise_error;
2272 }
2273 else {
2274 /* Normalize to raise <class>, <instance> */
Guido van Rossumb209a111997-04-29 18:18:01 +00002275 Py_DECREF(value);
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00002276 value = type;
Guido van Rossumb209a111997-04-29 18:18:01 +00002277 type = (PyObject*) ((PyInstanceObject*)type)->in_class;
2278 Py_INCREF(type);
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00002279 }
2280 }
2281 else {
2282 /* Not something you can raise. You get an exception
2283 anyway, just not what you specified :-) */
Guido van Rossumb209a111997-04-29 18:18:01 +00002284 PyErr_SetString(PyExc_TypeError,
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00002285 "exceptions must be strings, classes, or instances");
2286 goto raise_error;
2287 }
Guido van Rossumb209a111997-04-29 18:18:01 +00002288 PyErr_Restore(type, value, tb);
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00002289 if (tb == NULL)
2290 return WHY_EXCEPTION;
2291 else
2292 return WHY_RERAISE;
2293 raise_error:
Guido van Rossumb209a111997-04-29 18:18:01 +00002294 Py_XDECREF(value);
2295 Py_XDECREF(type);
2296 Py_XDECREF(tb);
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00002297 return WHY_EXCEPTION;
2298}
2299
Barry Warsawe42b18f1997-08-25 22:13:04 +00002300static int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002301unpack_sequence(PyObject *v, int argcnt, PyObject **sp)
Barry Warsawe42b18f1997-08-25 22:13:04 +00002302{
2303 int i;
2304 PyObject *w;
2305
2306 for (i = 0; i < argcnt; i++) {
2307 if (! (w = PySequence_GetItem(v, i))) {
2308 if (PyErr_ExceptionMatches(PyExc_IndexError))
2309 PyErr_SetString(PyExc_ValueError,
2310 "unpack sequence of wrong size");
2311 goto finally;
2312 }
2313 *--sp = w;
2314 }
2315 /* we better get an IndexError now */
2316 if (PySequence_GetItem(v, i) == NULL) {
2317 if (PyErr_ExceptionMatches(PyExc_IndexError)) {
2318 PyErr_Clear();
2319 return 1;
2320 }
2321 /* some other exception occurred. fall through to finally */
2322 }
2323 else
2324 PyErr_SetString(PyExc_ValueError,
2325 "unpack sequence of wrong size");
2326 /* fall through */
2327finally:
Barry Warsaw91010551997-08-25 22:30:51 +00002328 for (; i > 0; i--, sp++)
2329 Py_DECREF(*sp);
Barry Warsawe42b18f1997-08-25 22:13:04 +00002330
2331 return 0;
2332}
2333
2334
Guido van Rossum96a42c81992-01-12 02:29:51 +00002335#ifdef LLTRACE
Guido van Rossum3f5da241990-12-20 15:06:42 +00002336static int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002337prtrace(PyObject *v, char *str)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002338{
Guido van Rossum3f5da241990-12-20 15:06:42 +00002339 printf("%s ", str);
Guido van Rossumb209a111997-04-29 18:18:01 +00002340 if (PyObject_Print(v, stdout, 0) != 0)
2341 PyErr_Clear(); /* Don't know what else to do */
Guido van Rossum3f5da241990-12-20 15:06:42 +00002342 printf("\n");
Guido van Rossumcc229ea2000-05-04 00:55:17 +00002343 return 1;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002344}
Guido van Rossum3f5da241990-12-20 15:06:42 +00002345#endif
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002346
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00002347static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002348call_exc_trace(PyObject **p_trace, PyObject **p_newtrace, PyFrameObject *f)
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00002349{
Guido van Rossumb209a111997-04-29 18:18:01 +00002350 PyObject *type, *value, *traceback, *arg;
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00002351 int err;
Guido van Rossumb209a111997-04-29 18:18:01 +00002352 PyErr_Fetch(&type, &value, &traceback);
Guido van Rossumbd9ccca1992-04-09 14:58:08 +00002353 if (value == NULL) {
Guido van Rossumb209a111997-04-29 18:18:01 +00002354 value = Py_None;
2355 Py_INCREF(value);
Guido van Rossumbd9ccca1992-04-09 14:58:08 +00002356 }
Guido van Rossumb209a111997-04-29 18:18:01 +00002357 arg = Py_BuildValue("(OOO)", type, value, traceback);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002358 if (arg == NULL) {
Guido van Rossumb209a111997-04-29 18:18:01 +00002359 PyErr_Restore(type, value, traceback);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002360 return;
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00002361 }
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002362 err = call_trace(p_trace, p_newtrace, f, "exception", arg);
Guido van Rossumb209a111997-04-29 18:18:01 +00002363 Py_DECREF(arg);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002364 if (err == 0)
Guido van Rossumb209a111997-04-29 18:18:01 +00002365 PyErr_Restore(type, value, traceback);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002366 else {
Guido van Rossumb209a111997-04-29 18:18:01 +00002367 Py_XDECREF(type);
2368 Py_XDECREF(value);
2369 Py_XDECREF(traceback);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002370 }
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00002371}
2372
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002373/* PyObject **p_trace: in/out; may not be NULL;
2374 may not point to NULL variable initially
2375 PyObject **p_newtrace: in/out; may be NULL;
2376 may point to NULL variable;
2377 may be same variable as p_newtrace */
2378
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00002379static int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002380call_trace(PyObject **p_trace, PyObject **p_newtrace, PyFrameObject *f,
2381 char *msg, PyObject *arg)
Guido van Rossum96a42c81992-01-12 02:29:51 +00002382{
Guido van Rossuma027efa1997-05-05 20:56:21 +00002383 PyThreadState *tstate = f->f_tstate;
Guido van Rossumb209a111997-04-29 18:18:01 +00002384 PyObject *args, *what;
2385 PyObject *res = NULL;
Guido van Rossum96a42c81992-01-12 02:29:51 +00002386
Guido van Rossuma027efa1997-05-05 20:56:21 +00002387 if (tstate->tracing) {
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00002388 /* Don't do recursive traces */
2389 if (p_newtrace) {
Guido van Rossumb209a111997-04-29 18:18:01 +00002390 Py_XDECREF(*p_newtrace);
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00002391 *p_newtrace = NULL;
2392 }
2393 return 0;
Guido van Rossum96a42c81992-01-12 02:29:51 +00002394 }
2395
Guido van Rossumb209a111997-04-29 18:18:01 +00002396 args = PyTuple_New(3);
Guido van Rossumf10570b1995-07-07 22:53:21 +00002397 if (args == NULL)
Guido van Rossumf9c90c51997-08-05 02:18:01 +00002398 goto cleanup;
Guido van Rossumb209a111997-04-29 18:18:01 +00002399 what = PyString_FromString(msg);
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00002400 if (what == NULL)
Guido van Rossumf9c90c51997-08-05 02:18:01 +00002401 goto cleanup;
Guido van Rossumb209a111997-04-29 18:18:01 +00002402 Py_INCREF(f);
2403 PyTuple_SET_ITEM(args, 0, (PyObject *)f);
2404 PyTuple_SET_ITEM(args, 1, what);
Guido van Rossum96a42c81992-01-12 02:29:51 +00002405 if (arg == NULL)
Guido van Rossumb209a111997-04-29 18:18:01 +00002406 arg = Py_None;
2407 Py_INCREF(arg);
2408 PyTuple_SET_ITEM(args, 2, arg);
Guido van Rossuma027efa1997-05-05 20:56:21 +00002409 tstate->tracing++;
Guido van Rossumb209a111997-04-29 18:18:01 +00002410 PyFrame_FastToLocals(f);
2411 res = PyEval_CallObject(*p_trace, args); /* May clear *p_trace! */
2412 PyFrame_LocalsToFast(f, 1);
Guido van Rossuma027efa1997-05-05 20:56:21 +00002413 tstate->tracing--;
Guido van Rossumf9c90c51997-08-05 02:18:01 +00002414 cleanup:
Guido van Rossumb209a111997-04-29 18:18:01 +00002415 Py_XDECREF(args);
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00002416 if (res == NULL) {
2417 /* The trace proc raised an exception */
Guido van Rossumb209a111997-04-29 18:18:01 +00002418 PyTraceBack_Here(f);
2419 Py_XDECREF(*p_trace);
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00002420 *p_trace = NULL;
2421 if (p_newtrace) {
Guido van Rossumb209a111997-04-29 18:18:01 +00002422 Py_XDECREF(*p_newtrace);
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00002423 *p_newtrace = NULL;
2424 }
Barry Warsawf6202631999-09-08 16:26:33 +00002425 /* to be extra double plus sure we don't get recursive
2426 * calls inf either tracefunc or profilefunc gets an
2427 * exception, zap the global variables.
2428 */
2429 Py_XDECREF(tstate->sys_tracefunc);
2430 tstate->sys_tracefunc = NULL;
2431 Py_XDECREF(tstate->sys_profilefunc);
2432 tstate->sys_profilefunc = NULL;
Guido van Rossumeee3fd41992-04-05 14:18:13 +00002433 return -1;
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00002434 }
2435 else {
2436 if (p_newtrace) {
Guido van Rossumb209a111997-04-29 18:18:01 +00002437 Py_XDECREF(*p_newtrace);
2438 if (res == Py_None)
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00002439 *p_newtrace = NULL;
2440 else {
Guido van Rossumb209a111997-04-29 18:18:01 +00002441 Py_INCREF(res);
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00002442 *p_newtrace = res;
2443 }
2444 }
Guido van Rossumb209a111997-04-29 18:18:01 +00002445 Py_DECREF(res);
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00002446 return 0;
Guido van Rossumeee3fd41992-04-05 14:18:13 +00002447 }
Guido van Rossum96a42c81992-01-12 02:29:51 +00002448}
2449
Guido van Rossumb209a111997-04-29 18:18:01 +00002450PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002451PyEval_GetBuiltins(void)
Guido van Rossum6135a871995-01-09 17:53:26 +00002452{
Guido van Rossum25ce5661997-08-02 03:10:38 +00002453 PyThreadState *tstate = PyThreadState_Get();
2454 PyFrameObject *current_frame = tstate->frame;
Guido van Rossum6135a871995-01-09 17:53:26 +00002455 if (current_frame == NULL)
Guido van Rossum25ce5661997-08-02 03:10:38 +00002456 return tstate->interp->builtins;
Guido van Rossum6135a871995-01-09 17:53:26 +00002457 else
2458 return current_frame->f_builtins;
2459}
2460
Guido van Rossumb209a111997-04-29 18:18:01 +00002461PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002462PyEval_GetLocals(void)
Guido van Rossum5b722181993-03-30 17:46:03 +00002463{
Guido van Rossuma027efa1997-05-05 20:56:21 +00002464 PyFrameObject *current_frame = PyThreadState_Get()->frame;
Guido van Rossum5b722181993-03-30 17:46:03 +00002465 if (current_frame == NULL)
2466 return NULL;
Guido van Rossumb209a111997-04-29 18:18:01 +00002467 PyFrame_FastToLocals(current_frame);
Guido van Rossum5b722181993-03-30 17:46:03 +00002468 return current_frame->f_locals;
2469}
2470
Guido van Rossumb209a111997-04-29 18:18:01 +00002471PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002472PyEval_GetGlobals(void)
Guido van Rossum3f5da241990-12-20 15:06:42 +00002473{
Guido van Rossuma027efa1997-05-05 20:56:21 +00002474 PyFrameObject *current_frame = PyThreadState_Get()->frame;
Guido van Rossum3f5da241990-12-20 15:06:42 +00002475 if (current_frame == NULL)
2476 return NULL;
2477 else
2478 return current_frame->f_globals;
2479}
2480
Guido van Rossumb209a111997-04-29 18:18:01 +00002481PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002482PyEval_GetFrame(void)
Guido van Rossume59214e1994-08-30 08:01:59 +00002483{
Guido van Rossuma027efa1997-05-05 20:56:21 +00002484 PyFrameObject *current_frame = PyThreadState_Get()->frame;
Guido van Rossumb209a111997-04-29 18:18:01 +00002485 return (PyObject *)current_frame;
Guido van Rossume59214e1994-08-30 08:01:59 +00002486}
2487
Guido van Rossum6135a871995-01-09 17:53:26 +00002488int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002489PyEval_GetRestricted(void)
Guido van Rossum6135a871995-01-09 17:53:26 +00002490{
Guido van Rossuma027efa1997-05-05 20:56:21 +00002491 PyFrameObject *current_frame = PyThreadState_Get()->frame;
Guido van Rossum6135a871995-01-09 17:53:26 +00002492 return current_frame == NULL ? 0 : current_frame->f_restricted;
2493}
2494
Guido van Rossumbe270261997-05-22 22:26:18 +00002495int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002496Py_FlushLine(void)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002497{
Guido van Rossumb209a111997-04-29 18:18:01 +00002498 PyObject *f = PySys_GetObject("stdout");
Guido van Rossumbe270261997-05-22 22:26:18 +00002499 if (f == NULL)
2500 return 0;
2501 if (!PyFile_SoftSpace(f, 0))
2502 return 0;
2503 return PyFile_WriteString("\n", f);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002504}
2505
Guido van Rossum3f5da241990-12-20 15:06:42 +00002506
Guido van Rossum681d79a1995-07-18 14:51:37 +00002507/* External interface to call any callable object.
2508 The arg must be a tuple or NULL. */
Guido van Rossum83bf35c1991-07-27 21:32:34 +00002509
Guido van Rossumd7ed6831997-08-30 15:02:50 +00002510#undef PyEval_CallObject
2511/* for backward compatibility: export this interface */
2512
Guido van Rossumb209a111997-04-29 18:18:01 +00002513PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002514PyEval_CallObject(PyObject *func, PyObject *arg)
Guido van Rossum83bf35c1991-07-27 21:32:34 +00002515{
Guido van Rossumb209a111997-04-29 18:18:01 +00002516 return PyEval_CallObjectWithKeywords(func, arg, (PyObject *)NULL);
Guido van Rossum681d79a1995-07-18 14:51:37 +00002517}
Guido van Rossumd7ed6831997-08-30 15:02:50 +00002518#define PyEval_CallObject(func,arg) \
2519 PyEval_CallObjectWithKeywords(func, arg, (PyObject *)NULL)
Guido van Rossume59214e1994-08-30 08:01:59 +00002520
Guido van Rossumb209a111997-04-29 18:18:01 +00002521PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002522PyEval_CallObjectWithKeywords(PyObject *func, PyObject *arg, PyObject *kw)
Guido van Rossum681d79a1995-07-18 14:51:37 +00002523{
Jeremy Hylton52820442001-01-03 23:52:36 +00002524 PyObject *result;
Guido van Rossum681d79a1995-07-18 14:51:37 +00002525
2526 if (arg == NULL)
Guido van Rossumb209a111997-04-29 18:18:01 +00002527 arg = PyTuple_New(0);
2528 else if (!PyTuple_Check(arg)) {
Guido van Rossuma027efa1997-05-05 20:56:21 +00002529 PyErr_SetString(PyExc_TypeError,
2530 "argument list must be a tuple");
Guido van Rossum681d79a1995-07-18 14:51:37 +00002531 return NULL;
2532 }
2533 else
Guido van Rossumb209a111997-04-29 18:18:01 +00002534 Py_INCREF(arg);
Guido van Rossum681d79a1995-07-18 14:51:37 +00002535
Guido van Rossumb209a111997-04-29 18:18:01 +00002536 if (kw != NULL && !PyDict_Check(kw)) {
Guido van Rossuma027efa1997-05-05 20:56:21 +00002537 PyErr_SetString(PyExc_TypeError,
2538 "keyword list must be a dictionary");
Guido van Rossum25826c92000-04-21 21:17:39 +00002539 Py_DECREF(arg);
Guido van Rossume3e61c11995-08-04 04:14:47 +00002540 return NULL;
2541 }
2542
Jeremy Hylton52820442001-01-03 23:52:36 +00002543 result = call_object(func, arg, kw);
Guido van Rossumb209a111997-04-29 18:18:01 +00002544 Py_DECREF(arg);
Jeremy Hylton52820442001-01-03 23:52:36 +00002545 return result;
2546}
2547
2548/* How often is each kind of object called? The answer depends on the
2549 program. An instrumented call_object() was used to run the Python
2550 regression test suite. The results were:
2551 4200000 PyCFunctions
2552 390000 fast_function() calls
2553 94000 other functions
2554 480000 all functions (sum of prev two)
2555 150000 methods
2556 100000 classes
2557
2558 Tests on other bodies of code show that PyCFunctions are still
2559 most common, but not by such a large margin.
2560*/
2561
2562static PyObject *
2563call_object(PyObject *func, PyObject *arg, PyObject *kw)
2564{
2565 ternaryfunc call;
2566 PyObject *result;
2567
2568 if (PyMethod_Check(func))
2569 result = call_method(func, arg, kw);
2570 else if (PyFunction_Check(func))
2571 result = call_eval_code2(func, arg, kw);
2572 else if (PyCFunction_Check(func))
2573 result = call_cfunction(func, arg, kw);
2574 else if (PyClass_Check(func))
2575 result = PyInstance_New(func, arg, kw);
2576 else if (PyInstance_Check(func))
2577 result = call_instance(func, arg, kw);
2578 else if ((call = func->ob_type->tp_call) != NULL)
2579 result = (*call)(func, arg, kw);
2580 else {
2581 PyErr_Format(PyExc_TypeError, "object is not callable: %s",
2582 PyString_AS_STRING(PyObject_Repr(func)));
2583 return NULL;
2584 }
Guido van Rossumb209a111997-04-29 18:18:01 +00002585 if (result == NULL && !PyErr_Occurred())
2586 PyErr_SetString(PyExc_SystemError,
Guido van Rossum681d79a1995-07-18 14:51:37 +00002587 "NULL result without error in call_object");
Guido van Rossume59214e1994-08-30 08:01:59 +00002588
2589 return result;
Guido van Rossum83bf35c1991-07-27 21:32:34 +00002590}
2591
Guido van Rossumb209a111997-04-29 18:18:01 +00002592static PyObject *
Jeremy Hylton52820442001-01-03 23:52:36 +00002593call_cfunction(PyObject *func, PyObject *arg, PyObject *kw)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002594{
Jeremy Hylton52820442001-01-03 23:52:36 +00002595 PyCFunctionObject* f = (PyCFunctionObject*)func;
2596 PyCFunction meth = PyCFunction_GET_FUNCTION(func);
2597 PyObject *self = PyCFunction_GET_SELF(func);
2598 int flags = PyCFunction_GET_FLAGS(func);
2599
Jeremy Hylton52820442001-01-03 23:52:36 +00002600 if (flags & METH_KEYWORDS) {
Fred Drake1a7aab72001-01-04 22:33:02 +00002601 if (kw == NULL) {
2602 static PyObject *dict = NULL;
2603 if (dict == NULL) {
2604 dict = PyDict_New();
2605 if (dict == NULL)
2606 return NULL;
2607 }
2608 kw = dict;
2609 Py_INCREF(dict);
2610 }
Jeremy Hylton52820442001-01-03 23:52:36 +00002611 return (*(PyCFunctionWithKeywords)meth)(self, arg, kw);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002612 }
Jeremy Hylton52820442001-01-03 23:52:36 +00002613 if (kw != NULL && PyDict_Size(kw) != 0) {
2614 PyErr_Format(PyExc_TypeError,
2615 "%.200s() takes no keyword arguments",
2616 f->m_ml->ml_name);
2617 return NULL;
2618 }
Fred Drake1a7aab72001-01-04 22:33:02 +00002619 if (flags & METH_VARARGS) {
2620 return (*meth)(self, arg);
2621 }
2622 if (!(flags & METH_VARARGS)) {
2623 /* the really old style */
2624 int size = PyTuple_GET_SIZE(arg);
2625 if (size == 1)
2626 arg = PyTuple_GET_ITEM(arg, 0);
2627 else if (size == 0)
2628 arg = NULL;
2629 return (*meth)(self, arg);
2630 }
Jeremy Hylton52820442001-01-03 23:52:36 +00002631 /* should never get here ??? */
2632 PyErr_BadInternalCall();
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002633 return NULL;
2634}
2635
Guido van Rossumb209a111997-04-29 18:18:01 +00002636static PyObject *
Jeremy Hylton52820442001-01-03 23:52:36 +00002637call_instance(PyObject *func, PyObject *arg, PyObject *kw)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002638{
Jeremy Hylton52820442001-01-03 23:52:36 +00002639 PyObject *res, *call = PyObject_GetAttrString(func, "__call__");
2640 if (call == NULL) {
2641 PyInstanceObject *inst = (PyInstanceObject*) func;
2642 PyErr_Clear();
2643 PyErr_Format(PyExc_AttributeError,
2644 "%.200s instance has no __call__ method",
2645 PyString_AsString(inst->in_class->cl_name));
Guido van Rossum681d79a1995-07-18 14:51:37 +00002646 return NULL;
2647 }
Jeremy Hylton52820442001-01-03 23:52:36 +00002648 res = call_object(call, arg, kw);
2649 Py_DECREF(call);
2650 return res;
2651}
2652
2653static PyObject *
2654call_method(PyObject *func, PyObject *arg, PyObject *kw)
2655{
2656 PyObject *self = PyMethod_GET_SELF(func);
2657 PyObject *class = PyMethod_GET_CLASS(func);
2658 PyObject *result;
2659
2660 func = PyMethod_GET_FUNCTION(func);
2661 if (self == NULL) {
2662 /* Unbound methods must be called with an instance of
2663 the class (or a derived class) as first argument */
2664 if (PyTuple_Size(arg) >= 1)
2665 self = PyTuple_GET_ITEM(arg, 0);
2666 if (!(self != NULL && PyInstance_Check(self)
2667 && PyClass_IsSubclass((PyObject *)
2668 (((PyInstanceObject *)self)->in_class),
2669 class))) {
2670 PyErr_SetString(PyExc_TypeError,
2671 "unbound method must be called with instance as first argument");
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002672 return NULL;
2673 }
Guido van Rossumb209a111997-04-29 18:18:01 +00002674 Py_INCREF(arg);
Jeremy Hylton52820442001-01-03 23:52:36 +00002675 } else {
2676 int argcount = PyTuple_Size(arg);
2677 PyObject *newarg = PyTuple_New(argcount + 1);
2678 int i;
2679 if (newarg == NULL)
2680 return NULL;
2681 Py_INCREF(self);
2682 PyTuple_SET_ITEM(newarg, 0, self);
2683 for (i = 0; i < argcount; i++) {
2684 PyObject *v = PyTuple_GET_ITEM(arg, i);
2685 Py_XINCREF(v);
2686 PyTuple_SET_ITEM(newarg, i+1, v);
2687 }
2688 arg = newarg;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002689 }
Jeremy Hylton52820442001-01-03 23:52:36 +00002690 result = call_object(func, arg, kw);
2691 Py_DECREF(arg);
2692 return result;
2693}
2694
2695static PyObject *
2696call_eval_code2(PyObject *func, PyObject *arg, PyObject *kw)
2697{
2698 PyObject *result;
2699 PyObject *argdefs;
2700 PyObject **d, **k;
2701 int nk, nd;
2702
2703 argdefs = PyFunction_GET_DEFAULTS(func);
Guido van Rossumb209a111997-04-29 18:18:01 +00002704 if (argdefs != NULL && PyTuple_Check(argdefs)) {
2705 d = &PyTuple_GET_ITEM((PyTupleObject *)argdefs, 0);
2706 nd = PyTuple_Size(argdefs);
Guido van Rossum681d79a1995-07-18 14:51:37 +00002707 }
2708 else {
2709 d = NULL;
2710 nd = 0;
2711 }
2712
2713 if (kw != NULL) {
2714 int pos, i;
Guido van Rossumb209a111997-04-29 18:18:01 +00002715 nk = PyDict_Size(kw);
2716 k = PyMem_NEW(PyObject *, 2*nk);
Guido van Rossum681d79a1995-07-18 14:51:37 +00002717 if (k == NULL) {
Guido van Rossumb209a111997-04-29 18:18:01 +00002718 PyErr_NoMemory();
2719 Py_DECREF(arg);
Guido van Rossum681d79a1995-07-18 14:51:37 +00002720 return NULL;
Guido van Rossume59214e1994-08-30 08:01:59 +00002721 }
Guido van Rossum681d79a1995-07-18 14:51:37 +00002722 pos = i = 0;
Guido van Rossumb209a111997-04-29 18:18:01 +00002723 while (PyDict_Next(kw, &pos, &k[i], &k[i+1]))
Guido van Rossum681d79a1995-07-18 14:51:37 +00002724 i += 2;
2725 nk = i/2;
2726 /* XXX This is broken if the caller deletes dict items! */
2727 }
2728 else {
2729 k = NULL;
2730 nk = 0;
Guido van Rossume59214e1994-08-30 08:01:59 +00002731 }
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002732
Guido van Rossum681d79a1995-07-18 14:51:37 +00002733 result = eval_code2(
Jeremy Hylton52820442001-01-03 23:52:36 +00002734 (PyCodeObject *)PyFunction_GET_CODE(func),
2735 PyFunction_GET_GLOBALS(func), (PyObject *)NULL,
Guido van Rossumb209a111997-04-29 18:18:01 +00002736 &PyTuple_GET_ITEM(arg, 0), PyTuple_Size(arg),
Guido van Rossum681d79a1995-07-18 14:51:37 +00002737 k, nk,
Jeremy Hylton52820442001-01-03 23:52:36 +00002738 d, nd);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002739
Guido van Rossumb18618d2000-05-03 23:44:39 +00002740 if (k != NULL)
2741 PyMem_DEL(k);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002742
Guido van Rossum681d79a1995-07-18 14:51:37 +00002743 return result;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002744}
2745
Jeremy Hylton52820442001-01-03 23:52:36 +00002746#define EXT_POP(STACK_POINTER) (*--(STACK_POINTER))
2747
2748/* The two fast_xxx() functions optimize calls for which no argument
2749 tuple is necessary; the objects are passed directly from the stack.
2750 fast_cfunction() is called for METH_OLDARGS functions.
2751 fast_function() is for functions with no special argument handling.
2752*/
2753
2754static PyObject *
2755fast_cfunction(PyObject *func, PyObject ***pp_stack, int na)
2756{
2757 PyCFunction meth = PyCFunction_GET_FUNCTION(func);
2758 PyObject *self = PyCFunction_GET_SELF(func);
2759
2760 if (na == 0)
2761 return (*meth)(self, NULL);
Charles G. Waldmaneec72a72001-01-10 22:11:59 +00002762 else if (na == 1) {
2763 PyObject *arg = EXT_POP(*pp_stack);
2764 PyObject *result = (*meth)(self, arg);
2765 Py_DECREF(arg);
2766 return result;
2767 } else {
Jeremy Hylton52820442001-01-03 23:52:36 +00002768 PyObject *args = load_args(pp_stack, na);
2769 PyObject *result = (*meth)(self, args);
2770 Py_DECREF(args);
2771 return result;
2772 }
2773}
2774
2775static PyObject *
2776fast_function(PyObject *func, PyObject ***pp_stack, int n, int na, int nk)
2777{
2778 PyObject *co = PyFunction_GET_CODE(func);
2779 PyObject *globals = PyFunction_GET_GLOBALS(func);
2780 PyObject *argdefs = PyFunction_GET_DEFAULTS(func);
2781 PyObject **d = NULL;
2782 int nd = 0;
2783
2784 if (argdefs != NULL) {
2785 d = &PyTuple_GET_ITEM(argdefs, 0);
2786 nd = ((PyTupleObject *)argdefs)->ob_size;
2787 }
2788 return eval_code2((PyCodeObject *)co, globals,
2789 (PyObject *)NULL, (*pp_stack)-n, na,
2790 (*pp_stack)-2*nk, nk, d, nd);
2791}
2792
2793static PyObject *
2794update_keyword_args(PyObject *orig_kwdict, int nk, PyObject ***pp_stack)
2795{
2796 PyObject *kwdict = NULL;
2797 if (orig_kwdict == NULL)
2798 kwdict = PyDict_New();
2799 else {
2800 kwdict = PyDict_Copy(orig_kwdict);
2801 Py_DECREF(orig_kwdict);
2802 }
2803 if (kwdict == NULL)
2804 return NULL;
2805 while (--nk >= 0) {
2806 int err;
2807 PyObject *value = EXT_POP(*pp_stack);
2808 PyObject *key = EXT_POP(*pp_stack);
2809 if (PyDict_GetItem(kwdict, key) != NULL) {
2810 PyErr_Format(PyExc_TypeError,
2811 "keyword parameter '%.400s' "
2812 "redefined in function call",
2813 PyString_AsString(key));
2814 Py_DECREF(key);
2815 Py_DECREF(value);
2816 Py_DECREF(kwdict);
2817 return NULL;
2818 }
2819 err = PyDict_SetItem(kwdict, key, value);
2820 Py_DECREF(key);
2821 Py_DECREF(value);
2822 if (err) {
2823 Py_DECREF(kwdict);
2824 return NULL;
2825 }
2826 }
2827 return kwdict;
2828}
2829
2830static PyObject *
2831update_star_args(int nstack, int nstar, PyObject *stararg,
2832 PyObject ***pp_stack)
2833{
2834 PyObject *callargs, *w;
2835
2836 callargs = PyTuple_New(nstack + nstar);
2837 if (callargs == NULL) {
2838 return NULL;
2839 }
2840 if (nstar) {
2841 int i;
2842 for (i = 0; i < nstar; i++) {
2843 PyObject *a = PyTuple_GET_ITEM(stararg, i);
2844 Py_INCREF(a);
2845 PyTuple_SET_ITEM(callargs, nstack + i, a);
2846 }
2847 }
2848 while (--nstack >= 0) {
2849 w = EXT_POP(*pp_stack);
2850 PyTuple_SET_ITEM(callargs, nstack, w);
2851 }
2852 return callargs;
2853}
2854
2855static PyObject *
2856load_args(PyObject ***pp_stack, int na)
2857{
2858 PyObject *args = PyTuple_New(na);
2859 PyObject *w;
2860
2861 if (args == NULL)
2862 return NULL;
2863 while (--na >= 0) {
2864 w = EXT_POP(*pp_stack);
2865 PyTuple_SET_ITEM(args, na, w);
2866 }
2867 return args;
2868}
2869
2870static PyObject *
2871do_call(PyObject *func, PyObject ***pp_stack, int na, int nk)
2872{
2873 PyObject *callargs = NULL;
2874 PyObject *kwdict = NULL;
2875 PyObject *result = NULL;
2876
2877 if (nk > 0) {
2878 kwdict = update_keyword_args(NULL, nk, pp_stack);
2879 if (kwdict == NULL)
2880 goto call_fail;
2881 }
2882 callargs = load_args(pp_stack, na);
2883 if (callargs == NULL)
2884 goto call_fail;
2885 result = call_object(func, callargs, kwdict);
2886 call_fail:
2887 Py_XDECREF(callargs);
2888 Py_XDECREF(kwdict);
2889 return result;
2890}
2891
2892static PyObject *
2893ext_do_call(PyObject *func, PyObject ***pp_stack, int flags, int na, int nk)
2894{
2895 int nstar = 0;
2896 PyObject *callargs = NULL;
2897 PyObject *stararg = NULL;
2898 PyObject *kwdict = NULL;
2899 PyObject *result = NULL;
2900
2901 if (flags & CALL_FLAG_KW) {
2902 kwdict = EXT_POP(*pp_stack);
2903 if (!(kwdict && PyDict_Check(kwdict))) {
2904 PyErr_SetString(PyExc_TypeError,
2905 "** argument must be a dictionary");
2906 goto ext_call_fail;
2907 }
2908 }
2909 if (flags & CALL_FLAG_VAR) {
2910 stararg = EXT_POP(*pp_stack);
2911 if (!PyTuple_Check(stararg)) {
2912 PyObject *t = NULL;
2913 t = PySequence_Tuple(stararg);
2914 if (t == NULL) {
2915 if (PyErr_ExceptionMatches(PyExc_TypeError)) {
2916 PyErr_SetString(PyExc_TypeError,
2917 "* argument must be a sequence");
2918 }
2919 goto ext_call_fail;
2920 }
2921 Py_DECREF(stararg);
2922 stararg = t;
2923 }
2924 nstar = PyTuple_GET_SIZE(stararg);
2925 }
2926 if (nk > 0) {
2927 kwdict = update_keyword_args(kwdict, nk, pp_stack);
2928 if (kwdict == NULL)
2929 goto ext_call_fail;
2930 }
2931 callargs = update_star_args(na, nstar, stararg, pp_stack);
2932 if (callargs == NULL)
2933 goto ext_call_fail;
2934 result = call_object(func, callargs, kwdict);
2935 ext_call_fail:
2936 Py_XDECREF(callargs);
2937 Py_XDECREF(kwdict);
2938 Py_XDECREF(stararg);
2939 return result;
2940}
2941
Guido van Rossum3b9c6671996-07-30 18:40:29 +00002942#define SLICE_ERROR_MSG \
2943 "standard sequence type does not support step size other than one"
2944
Guido van Rossumb209a111997-04-29 18:18:01 +00002945static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002946loop_subscript(PyObject *v, PyObject *w)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002947{
Guido van Rossumb209a111997-04-29 18:18:01 +00002948 PySequenceMethods *sq = v->ob_type->tp_as_sequence;
Guido van Rossume59214e1994-08-30 08:01:59 +00002949 int i;
Guido van Rossum7e33c6e1998-05-22 00:52:29 +00002950 if (sq == NULL || sq->sq_item == NULL) {
Guido van Rossumb209a111997-04-29 18:18:01 +00002951 PyErr_SetString(PyExc_TypeError, "loop over non-sequence");
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002952 return NULL;
2953 }
Guido van Rossumb209a111997-04-29 18:18:01 +00002954 i = PyInt_AsLong(w);
Guido van Rossume59214e1994-08-30 08:01:59 +00002955 v = (*sq->sq_item)(v, i);
2956 if (v)
2957 return v;
Barry Warsaw4249f541997-08-22 21:26:19 +00002958 if (PyErr_ExceptionMatches(PyExc_IndexError))
Guido van Rossumb209a111997-04-29 18:18:01 +00002959 PyErr_Clear();
Guido van Rossume59214e1994-08-30 08:01:59 +00002960 return NULL;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002961}
2962
Guido van Rossum20c6add2000-05-08 14:06:50 +00002963/* Extract a slice index from a PyInt or PyLong, the index is bound to
2964 the range [-INT_MAX+1, INTMAX]. Returns 0 and an exception if there is
2965 and error. Returns 1 on success.*/
2966
2967int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002968_PyEval_SliceIndex(PyObject *v, int *pi)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00002969{
2970 if (v != NULL) {
Guido van Rossuma027efa1997-05-05 20:56:21 +00002971 long x;
Andrew M. Kuchling2194b162000-02-23 22:18:48 +00002972 if (PyInt_Check(v)) {
2973 x = PyInt_AsLong(v);
2974 } else if (PyLong_Check(v)) {
2975 x = PyLong_AsLong(v);
2976 if (x==-1 && PyErr_Occurred()) {
2977 PyObject *long_zero;
2978
2979 if (!PyErr_ExceptionMatches( PyExc_OverflowError ) ) {
2980 /* It's not an overflow error, so just
2981 signal an error */
Guido van Rossum20c6add2000-05-08 14:06:50 +00002982 return 0;
Andrew M. Kuchling2194b162000-02-23 22:18:48 +00002983 }
2984
2985 /* It's an overflow error, so we need to
2986 check the sign of the long integer,
2987 set the value to INT_MAX or 0, and clear
2988 the error. */
2989
2990 /* Create a long integer with a value of 0 */
2991 long_zero = PyLong_FromLong( 0L );
Guido van Rossum20c6add2000-05-08 14:06:50 +00002992 if (long_zero == NULL) return 0;
Andrew M. Kuchling2194b162000-02-23 22:18:48 +00002993
2994 /* Check sign */
2995 if (PyObject_Compare(long_zero, v) < 0)
2996 x = INT_MAX;
2997 else
2998 x = 0;
2999
3000 /* Free the long integer we created, and clear the
3001 OverflowError */
3002 Py_DECREF(long_zero);
3003 PyErr_Clear();
3004 }
3005 } else {
Guido van Rossuma027efa1997-05-05 20:56:21 +00003006 PyErr_SetString(PyExc_TypeError,
Fred Drake661ea262000-10-24 19:57:45 +00003007 "slice indices must be integers");
Guido van Rossum20c6add2000-05-08 14:06:50 +00003008 return 0;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003009 }
Guido van Rossuma027efa1997-05-05 20:56:21 +00003010 /* Truncate -- very long indices are truncated anyway */
3011 if (x > INT_MAX)
3012 x = INT_MAX;
3013 else if (x < -INT_MAX)
3014 x = 0;
3015 *pi = x;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003016 }
Guido van Rossum20c6add2000-05-08 14:06:50 +00003017 return 1;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003018}
3019
Guido van Rossumb209a111997-04-29 18:18:01 +00003020static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003021apply_slice(PyObject *u, PyObject *v, PyObject *w) /* return u[v:w] */
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003022{
Guido van Rossuma027efa1997-05-05 20:56:21 +00003023 int ilow = 0, ihigh = INT_MAX;
Guido van Rossum20c6add2000-05-08 14:06:50 +00003024 if (!_PyEval_SliceIndex(v, &ilow))
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003025 return NULL;
Guido van Rossum20c6add2000-05-08 14:06:50 +00003026 if (!_PyEval_SliceIndex(w, &ihigh))
Guido van Rossum04691fc1992-08-12 15:35:34 +00003027 return NULL;
Guido van Rossuma027efa1997-05-05 20:56:21 +00003028 return PySequence_GetSlice(u, ilow, ihigh);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003029}
Guido van Rossum3f5da241990-12-20 15:06:42 +00003030
3031static int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003032assign_slice(PyObject *u, PyObject *v, PyObject *w, PyObject *x) /* u[v:w] = x */
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003033{
Guido van Rossuma027efa1997-05-05 20:56:21 +00003034 int ilow = 0, ihigh = INT_MAX;
Guido van Rossum20c6add2000-05-08 14:06:50 +00003035 if (!_PyEval_SliceIndex(v, &ilow))
Guido van Rossum3f5da241990-12-20 15:06:42 +00003036 return -1;
Guido van Rossum20c6add2000-05-08 14:06:50 +00003037 if (!_PyEval_SliceIndex(w, &ihigh))
Guido van Rossum3f5da241990-12-20 15:06:42 +00003038 return -1;
Guido van Rossuma027efa1997-05-05 20:56:21 +00003039 if (x == NULL)
3040 return PySequence_DelSlice(u, ilow, ihigh);
3041 else
3042 return PySequence_SetSlice(u, ilow, ihigh, x);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003043}
3044
Guido van Rossumb209a111997-04-29 18:18:01 +00003045static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003046cmp_outcome(int op, register PyObject *v, register PyObject *w)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003047{
3048 register int cmp;
3049 register int res = 0;
3050 switch (op) {
Guido van Rossum3f5da241990-12-20 15:06:42 +00003051 case IS:
3052 case IS_NOT:
3053 res = (v == w);
Guido van Rossum04691fc1992-08-12 15:35:34 +00003054 if (op == (int) IS_NOT)
Guido van Rossum3f5da241990-12-20 15:06:42 +00003055 res = !res;
3056 break;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003057 case IN:
3058 case NOT_IN:
Guido van Rossum7e33c6e1998-05-22 00:52:29 +00003059 res = PySequence_Contains(w, v);
Guido van Rossum3f5da241990-12-20 15:06:42 +00003060 if (res < 0)
3061 return NULL;
Guido van Rossum04691fc1992-08-12 15:35:34 +00003062 if (op == (int) NOT_IN)
Guido van Rossum3f5da241990-12-20 15:06:42 +00003063 res = !res;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003064 break;
3065 case EXC_MATCH:
Barry Warsaw4249f541997-08-22 21:26:19 +00003066 res = PyErr_GivenExceptionMatches(v, w);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003067 break;
3068 default:
Guido van Rossumb209a111997-04-29 18:18:01 +00003069 cmp = PyObject_Compare(v, w);
Guido van Rossumc8b6df91997-05-23 00:06:51 +00003070 if (cmp && PyErr_Occurred())
3071 return NULL;
Guido van Rossum3f5da241990-12-20 15:06:42 +00003072 switch (op) {
3073 case LT: res = cmp < 0; break;
3074 case LE: res = cmp <= 0; break;
3075 case EQ: res = cmp == 0; break;
3076 case NE: res = cmp != 0; break;
3077 case GT: res = cmp > 0; break;
3078 case GE: res = cmp >= 0; break;
3079 /* XXX no default? (res is initialized to 0 though) */
3080 }
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003081 }
Guido van Rossumb209a111997-04-29 18:18:01 +00003082 v = res ? Py_True : Py_False;
3083 Py_INCREF(v);
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003084 return v;
3085}
3086
Thomas Wouters52152252000-08-17 22:55:00 +00003087static PyObject *
3088import_from(PyObject *v, PyObject *name)
Guido van Rossume9736fc1990-11-18 17:33:06 +00003089{
Guido van Rossumb209a111997-04-29 18:18:01 +00003090 PyObject *w, *x;
3091 if (!PyModule_Check(v)) {
Guido van Rossuma027efa1997-05-05 20:56:21 +00003092 PyErr_SetString(PyExc_TypeError,
Fred Drake661ea262000-10-24 19:57:45 +00003093 "import-from requires a module object");
Thomas Wouters52152252000-08-17 22:55:00 +00003094 return NULL;
3095 }
3096 w = PyModule_GetDict(v); /* TDB: can this not fail ? */
3097 x = PyDict_GetItem(w, name);
3098 if (x == NULL) {
3099 PyErr_Format(PyExc_ImportError,
3100 "cannot import name %.230s",
3101 PyString_AsString(name));
3102 } else
3103 Py_INCREF(x);
3104 return x;
3105}
3106
3107static int
3108import_all_from(PyObject *locals, PyObject *v)
3109{
3110 int pos = 0, err;
3111 PyObject *name, *value;
3112 PyObject *w;
3113
3114 if (!PyModule_Check(v)) {
3115 PyErr_SetString(PyExc_TypeError,
Fred Drake661ea262000-10-24 19:57:45 +00003116 "import-from requires a module object");
Guido van Rossum1ae940a1995-01-02 19:04:15 +00003117 return -1;
3118 }
Thomas Wouters52152252000-08-17 22:55:00 +00003119 w = PyModule_GetDict(v); /* TBD: can this not fail ? */
3120
3121 while (PyDict_Next(w, &pos, &name, &value)) {
3122 if (!PyString_Check(name) ||
3123 PyString_AsString(name)[0] == '_')
Guido van Rossume9736fc1990-11-18 17:33:06 +00003124 continue;
Thomas Wouters52152252000-08-17 22:55:00 +00003125 Py_INCREF(value);
3126 err = PyDict_SetItem(locals, name, value);
3127 Py_DECREF(value);
3128 if (err != 0)
Guido van Rossum3f5da241990-12-20 15:06:42 +00003129 return -1;
Guido van Rossume9736fc1990-11-18 17:33:06 +00003130 }
Thomas Wouters52152252000-08-17 22:55:00 +00003131 return 0;
Guido van Rossume9736fc1990-11-18 17:33:06 +00003132}
3133
Guido van Rossumb209a111997-04-29 18:18:01 +00003134static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003135build_class(PyObject *methods, PyObject *bases, PyObject *name)
Guido van Rossume9736fc1990-11-18 17:33:06 +00003136{
Guido van Rossumcd649651997-08-22 16:56:16 +00003137 int i, n;
Guido van Rossumb209a111997-04-29 18:18:01 +00003138 if (!PyTuple_Check(bases)) {
Guido van Rossuma027efa1997-05-05 20:56:21 +00003139 PyErr_SetString(PyExc_SystemError,
3140 "build_class with non-tuple bases");
Guido van Rossum25831651993-05-19 14:50:45 +00003141 return NULL;
Guido van Rossume9736fc1990-11-18 17:33:06 +00003142 }
Guido van Rossumb209a111997-04-29 18:18:01 +00003143 if (!PyDict_Check(methods)) {
Guido van Rossuma027efa1997-05-05 20:56:21 +00003144 PyErr_SetString(PyExc_SystemError,
3145 "build_class with non-dictionary");
Guido van Rossume9736fc1990-11-18 17:33:06 +00003146 return NULL;
3147 }
Guido van Rossumb209a111997-04-29 18:18:01 +00003148 if (!PyString_Check(name)) {
Guido van Rossuma027efa1997-05-05 20:56:21 +00003149 PyErr_SetString(PyExc_SystemError,
Guido van Rossum7a5b7962000-03-31 13:52:29 +00003150 "build_class with non-string name");
Guido van Rossum25831651993-05-19 14:50:45 +00003151 return NULL;
3152 }
Guido van Rossumcd649651997-08-22 16:56:16 +00003153 n = PyTuple_Size(bases);
3154 for (i = 0; i < n; i++) {
Guido van Rossumb209a111997-04-29 18:18:01 +00003155 PyObject *base = PyTuple_GET_ITEM(bases, i);
3156 if (!PyClass_Check(base)) {
Guido van Rossum150b2df1996-12-05 23:17:11 +00003157 /* Call the base's *type*, if it is callable.
3158 This code is a hook for Donald Beaudry's
3159 and Jim Fulton's type extensions. In
Thomas Wouters7e474022000-07-16 12:04:32 +00003160 unextended Python it will never be triggered
Guido van Rossum55b9ab51997-07-31 03:54:02 +00003161 since its types are not callable.
3162 Ditto: call the bases's *class*, if it has
3163 one. This makes the same thing possible
3164 without writing C code. A true meta-object
3165 protocol! */
3166 PyObject *basetype = (PyObject *)base->ob_type;
3167 PyObject *callable = NULL;
3168 if (PyCallable_Check(basetype))
3169 callable = basetype;
3170 else
3171 callable = PyObject_GetAttrString(
3172 base, "__class__");
3173 if (callable) {
3174 PyObject *args;
3175 PyObject *newclass = NULL;
3176 args = Py_BuildValue(
3177 "(OOO)", name, bases, methods);
3178 if (args != NULL) {
3179 newclass = PyEval_CallObject(
3180 callable, args);
3181 Py_DECREF(args);
3182 }
Guido van Rossum730806d1998-04-10 22:27:42 +00003183 if (callable != basetype) {
Guido van Rossum55b9ab51997-07-31 03:54:02 +00003184 Py_DECREF(callable);
Guido van Rossum730806d1998-04-10 22:27:42 +00003185 }
Guido van Rossum55b9ab51997-07-31 03:54:02 +00003186 return newclass;
Guido van Rossum150b2df1996-12-05 23:17:11 +00003187 }
Guido van Rossumb209a111997-04-29 18:18:01 +00003188 PyErr_SetString(PyExc_TypeError,
Guido van Rossum25831651993-05-19 14:50:45 +00003189 "base is not a class object");
3190 return NULL;
3191 }
3192 }
Guido van Rossumb209a111997-04-29 18:18:01 +00003193 return PyClass_New(bases, methods, name);
Guido van Rossum25831651993-05-19 14:50:45 +00003194}
3195
Guido van Rossumdb3165e1993-10-18 17:06:59 +00003196static int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003197exec_statement(PyFrameObject *f, PyObject *prog, PyObject *globals,
3198 PyObject *locals)
Guido van Rossumdb3165e1993-10-18 17:06:59 +00003199{
Guido van Rossumdb3165e1993-10-18 17:06:59 +00003200 int n;
Guido van Rossumb209a111997-04-29 18:18:01 +00003201 PyObject *v;
Guido van Rossum681d79a1995-07-18 14:51:37 +00003202 int plain = 0;
Guido van Rossumdb3165e1993-10-18 17:06:59 +00003203
Guido van Rossumb209a111997-04-29 18:18:01 +00003204 if (PyTuple_Check(prog) && globals == Py_None && locals == Py_None &&
3205 ((n = PyTuple_Size(prog)) == 2 || n == 3)) {
Guido van Rossumdb3165e1993-10-18 17:06:59 +00003206 /* Backward compatibility hack */
Guido van Rossumb209a111997-04-29 18:18:01 +00003207 globals = PyTuple_GetItem(prog, 1);
Guido van Rossumdb3165e1993-10-18 17:06:59 +00003208 if (n == 3)
Guido van Rossumb209a111997-04-29 18:18:01 +00003209 locals = PyTuple_GetItem(prog, 2);
3210 prog = PyTuple_GetItem(prog, 0);
Guido van Rossumdb3165e1993-10-18 17:06:59 +00003211 }
Guido van Rossumb209a111997-04-29 18:18:01 +00003212 if (globals == Py_None) {
3213 globals = PyEval_GetGlobals();
3214 if (locals == Py_None) {
3215 locals = PyEval_GetLocals();
Guido van Rossum681d79a1995-07-18 14:51:37 +00003216 plain = 1;
3217 }
Guido van Rossumdb3165e1993-10-18 17:06:59 +00003218 }
Guido van Rossumb209a111997-04-29 18:18:01 +00003219 else if (locals == Py_None)
Guido van Rossumdb3165e1993-10-18 17:06:59 +00003220 locals = globals;
Guido van Rossumb209a111997-04-29 18:18:01 +00003221 if (!PyString_Check(prog) &&
Marc-André Lemburgd1ba4432000-09-19 21:04:18 +00003222 !PyUnicode_Check(prog) &&
Guido van Rossumb209a111997-04-29 18:18:01 +00003223 !PyCode_Check(prog) &&
3224 !PyFile_Check(prog)) {
3225 PyErr_SetString(PyExc_TypeError,
Fred Drake661ea262000-10-24 19:57:45 +00003226 "exec: arg 1 must be a string, file, or code object");
Guido van Rossumdb3165e1993-10-18 17:06:59 +00003227 return -1;
3228 }
Fred Drake661ea262000-10-24 19:57:45 +00003229 if (!PyDict_Check(globals)) {
Guido van Rossumb209a111997-04-29 18:18:01 +00003230 PyErr_SetString(PyExc_TypeError,
Fred Drake661ea262000-10-24 19:57:45 +00003231 "exec: arg 2 must be a dictionary or None");
3232 return -1;
3233 }
3234 if (!PyDict_Check(locals)) {
3235 PyErr_SetString(PyExc_TypeError,
3236 "exec: arg 3 must be a dictionary or None");
Guido van Rossumdb3165e1993-10-18 17:06:59 +00003237 return -1;
3238 }
Guido van Rossumb209a111997-04-29 18:18:01 +00003239 if (PyDict_GetItemString(globals, "__builtins__") == NULL)
Guido van Rossuma027efa1997-05-05 20:56:21 +00003240 PyDict_SetItemString(globals, "__builtins__", f->f_builtins);
Guido van Rossumb209a111997-04-29 18:18:01 +00003241 if (PyCode_Check(prog)) {
Guido van Rossuma400d8a2000-01-12 22:45:54 +00003242 v = PyEval_EvalCode((PyCodeObject *) prog, globals, locals);
Guido van Rossumdb3165e1993-10-18 17:06:59 +00003243 }
Guido van Rossuma400d8a2000-01-12 22:45:54 +00003244 else if (PyFile_Check(prog)) {
Guido van Rossumb209a111997-04-29 18:18:01 +00003245 FILE *fp = PyFile_AsFile(prog);
3246 char *name = PyString_AsString(PyFile_Name(prog));
Guido van Rossuma400d8a2000-01-12 22:45:54 +00003247 v = PyRun_File(fp, name, Py_file_input, globals, locals);
3248 }
3249 else {
Marc-André Lemburgd1ba4432000-09-19 21:04:18 +00003250 char *str;
3251 if (PyString_AsStringAndSize(prog, &str, NULL))
Guido van Rossumdb3165e1993-10-18 17:06:59 +00003252 return -1;
Marc-André Lemburgd1ba4432000-09-19 21:04:18 +00003253 v = PyRun_String(str, Py_file_input, globals, locals);
Guido van Rossumdb3165e1993-10-18 17:06:59 +00003254 }
Guido van Rossuma400d8a2000-01-12 22:45:54 +00003255 if (plain)
3256 PyFrame_LocalsToFast(f, 0);
Guido van Rossum681d79a1995-07-18 14:51:37 +00003257 if (v == NULL)
Guido van Rossumdb3165e1993-10-18 17:06:59 +00003258 return -1;
Guido van Rossumb209a111997-04-29 18:18:01 +00003259 Py_DECREF(v);
Guido van Rossumdb3165e1993-10-18 17:06:59 +00003260 return 0;
3261}
Guido van Rossum24c13741995-02-14 09:42:43 +00003262
Paul Prescode68140d2000-08-30 20:25:01 +00003263static void
3264format_exc_check_arg(PyObject *exc, char *format_str, PyObject *obj)
3265{
3266 char *obj_str;
3267
3268 if (!obj)
3269 return;
3270
3271 obj_str = PyString_AsString(obj);
3272 if (!obj_str)
3273 return;
3274
3275 PyErr_Format(exc, format_str, obj_str);
3276}
Guido van Rossum950361c1997-01-24 13:49:28 +00003277
3278#ifdef DYNAMIC_EXECUTION_PROFILE
3279
3280PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003281getarray(long a[256])
Guido van Rossum950361c1997-01-24 13:49:28 +00003282{
3283 int i;
3284 PyObject *l = PyList_New(256);
3285 if (l == NULL) return NULL;
3286 for (i = 0; i < 256; i++) {
3287 PyObject *x = PyInt_FromLong(a[i]);
3288 if (x == NULL) {
3289 Py_DECREF(l);
3290 return NULL;
3291 }
3292 PyList_SetItem(l, i, x);
3293 }
3294 for (i = 0; i < 256; i++)
3295 a[i] = 0;
3296 return l;
3297}
3298
3299PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003300_Py_GetDXProfile(PyObject *self, PyObject *args)
Guido van Rossum950361c1997-01-24 13:49:28 +00003301{
3302#ifndef DXPAIRS
3303 return getarray(dxp);
3304#else
3305 int i;
3306 PyObject *l = PyList_New(257);
3307 if (l == NULL) return NULL;
3308 for (i = 0; i < 257; i++) {
3309 PyObject *x = getarray(dxpairs[i]);
3310 if (x == NULL) {
3311 Py_DECREF(l);
3312 return NULL;
3313 }
3314 PyList_SetItem(l, i, x);
3315 }
3316 return l;
3317#endif
3318}
3319
3320#endif