History

add hg and python

cinap_lenrek committed 15 years ago

Commit 4bb9e221 parent 987265c3706 files · +1228772 −-233Browse files

Showing the changes to sys/src/cmd/python/Python/ceval.c (1 of 3706 files). Show all

Unified · Split

sys/src/cmd/python/Python/ceval.c+4351−0
@@ -0,0 +1,4351 @@
1
2/* Execute compiled code */
3
4/* XXX TO DO:
5 XXX speed up searching for keywords by using a dictionary
6 XXX document it!
7 */
8
9/* enable more aggressive intra-module optimizations, where available */
10#define PY_LOCAL_AGGRESSIVE
11
12#include "Python.h"
13
14#include "code.h"
15#include "frameobject.h"
16#include "eval.h"
17#include "opcode.h"
18#include "structmember.h"
19
20#include <ctype.h>
21
22#ifndef WITH_TSC
23
24#define READ_TIMESTAMP(var)
25
26#else
27
28typedef unsigned long long uint64;
29
30#if defined(__ppc__) /* <- Don't know if this is the correct symbol; this
31 section should work for GCC on any PowerPC platform,
32 irrespective of OS. POWER? Who knows :-) */
33
34#define READ_TIMESTAMP(var) ppc_getcounter(&var)
35
36static void
37ppc_getcounter(uint64 *v)
38{
39 register unsigned long tbu, tb, tbu2;
40
41 loop:
42 asm volatile ("mftbu %0" : "=r" (tbu) );
43 asm volatile ("mftb %0" : "=r" (tb) );
44 asm volatile ("mftbu %0" : "=r" (tbu2));
45 if (__builtin_expect(tbu != tbu2, 0)) goto loop;
46
47 /* The slightly peculiar way of writing the next lines is
48 compiled better by GCC than any other way I tried. */
49 ((long*)(v))[0] = tbu;
50 ((long*)(v))[1] = tb;
51}
52
53#else /* this is for linux/x86 (and probably any other GCC/x86 combo) */
54
55#define READ_TIMESTAMP(val) \
56 __asm__ __volatile__("rdtsc" : "=A" (val))
57
58#endif
59
60void dump_tsc(int opcode, int ticked, uint64 inst0, uint64 inst1,
61 uint64 loop0, uint64 loop1, uint64 intr0, uint64 intr1)
62{
63 uint64 intr, inst, loop;
64 PyThreadState *tstate = PyThreadState_Get();
65 if (!tstate->interp->tscdump)
66 return;
67 intr = intr1 - intr0;
68 inst = inst1 - inst0 - intr;
69 loop = loop1 - loop0 - intr;
70 fprintf(stderr, "opcode=%03d t=%d inst=%06lld loop=%06lld\n",
71 opcode, ticked, inst, loop);
72}
73
74#endif
75
76/* Turn this on if your compiler chokes on the big switch: */
77/* #define CASE_TOO_BIG 1 */
78
79#ifdef Py_DEBUG
80/* For debugging the interpreter: */
81#define LLTRACE 1 /* Low-level trace feature */
82#define CHECKEXC 1 /* Double-check exception checking */
83#endif
84
85typedef PyObject *(*callproc)(PyObject *, PyObject *, PyObject *);
86
87/* Forward declarations */
88#ifdef WITH_TSC
89static PyObject * call_function(PyObject ***, int, uint64*, uint64*);
90#else
91static PyObject * call_function(PyObject ***, int);
92#endif
93static PyObject * fast_function(PyObject *, PyObject ***, int, int, int);
94static PyObject * do_call(PyObject *, PyObject ***, int, int);
95static PyObject * ext_do_call(PyObject *, PyObject ***, int, int, int);
96static PyObject * update_keyword_args(PyObject *, int, PyObject ***,PyObject *);
97static PyObject * update_star_args(int, int, PyObject *, PyObject ***);
98static PyObject * load_args(PyObject ***, int);
99#define CALL_FLAG_VAR 1
100#define CALL_FLAG_KW 2
101
102#ifdef LLTRACE
103static int lltrace;
104static int prtrace(PyObject *, char *);
105#endif
106static int call_trace(Py_tracefunc, PyObject *, PyFrameObject *,
107 int, PyObject *);
108static void call_trace_protected(Py_tracefunc, PyObject *,
109 PyFrameObject *, int, PyObject *);
110static void call_exc_trace(Py_tracefunc, PyObject *, PyFrameObject *);
111static int maybe_call_line_trace(Py_tracefunc, PyObject *,
112 PyFrameObject *, int *, int *, int *);
113
114static PyObject * apply_slice(PyObject *, PyObject *, PyObject *);
115static int assign_slice(PyObject *, PyObject *,
116 PyObject *, PyObject *);
117static PyObject * cmp_outcome(int, PyObject *, PyObject *);
118static PyObject * import_from(PyObject *, PyObject *);
119static int import_all_from(PyObject *, PyObject *);
120static PyObject * build_class(PyObject *, PyObject *, PyObject *);
121static int exec_statement(PyFrameObject *,
122 PyObject *, PyObject *, PyObject *);
123static void set_exc_info(PyThreadState *, PyObject *, PyObject *, PyObject *);
124static void reset_exc_info(PyThreadState *);
125static void format_exc_check_arg(PyObject *, char *, PyObject *);
126static PyObject * string_concatenate(PyObject *, PyObject *,
127 PyFrameObject *, unsigned char *);
128
129#define NAME_ERROR_MSG \
130 "name '%.200s' is not defined"
131#define GLOBAL_NAME_ERROR_MSG \
132 "global name '%.200s' is not defined"
133#define UNBOUNDLOCAL_ERROR_MSG \
134 "local variable '%.200s' referenced before assignment"
135#define UNBOUNDFREE_ERROR_MSG \
136 "free variable '%.200s' referenced before assignment" \
137 " in enclosing scope"
138
139/* Dynamic execution profile */
140#ifdef DYNAMIC_EXECUTION_PROFILE
141#ifdef DXPAIRS
142static long dxpairs[257][256];
143#define dxp dxpairs[256]
144#else
145static long dxp[256];
146#endif
147#endif
148
149/* Function call profile */
150#ifdef CALL_PROFILE
151#define PCALL_NUM 11
152static int pcall[PCALL_NUM];
153
154#define PCALL_ALL 0
155#define PCALL_FUNCTION 1
156#define PCALL_FAST_FUNCTION 2
157#define PCALL_FASTER_FUNCTION 3
158#define PCALL_METHOD 4
159#define PCALL_BOUND_METHOD 5
160#define PCALL_CFUNCTION 6
161#define PCALL_TYPE 7
162#define PCALL_GENERATOR 8
163#define PCALL_OTHER 9
164#define PCALL_POP 10
165
166/* Notes about the statistics
167
168 PCALL_FAST stats
169
170 FAST_FUNCTION means no argument tuple needs to be created.
171 FASTER_FUNCTION means that the fast-path frame setup code is used.
172
173 If there is a method call where the call can be optimized by changing
174 the argument tuple and calling the function directly, it gets recorded
175 twice.
176
177 As a result, the relationship among the statistics appears to be
178 PCALL_ALL == PCALL_FUNCTION + PCALL_METHOD - PCALL_BOUND_METHOD +
179 PCALL_CFUNCTION + PCALL_TYPE + PCALL_GENERATOR + PCALL_OTHER
180 PCALL_FUNCTION > PCALL_FAST_FUNCTION > PCALL_FASTER_FUNCTION
181 PCALL_METHOD > PCALL_BOUND_METHOD
182*/
183
184#define PCALL(POS) pcall[POS]++
185
186PyObject *
187PyEval_GetCallStats(PyObject *self)
188{
189 return Py_BuildValue("iiiiiiiiiii",
190 pcall[0], pcall[1], pcall[2], pcall[3],
191 pcall[4], pcall[5], pcall[6], pcall[7],
192 pcall[8], pcall[9], pcall[10]);
193}
194#else
195#define PCALL(O)
196
197PyObject *
198PyEval_GetCallStats(PyObject *self)
199{
200 Py_INCREF(Py_None);
201 return Py_None;
202}
203#endif
204
205
206#ifdef WITH_THREAD
207
208#ifdef HAVE_ERRNO_H
209#include <errno.h>
210#endif
211#include "pythread.h"
212
213static PyThread_type_lock interpreter_lock = 0; /* This is the GIL */
214static long main_thread = 0;
215
216int
217PyEval_ThreadsInitialized(void)
218{
219 return interpreter_lock != 0;
220}
221
222void
223PyEval_InitThreads(void)
224{
225 if (interpreter_lock)
226 return;
227 interpreter_lock = PyThread_allocate_lock();
228 PyThread_acquire_lock(interpreter_lock, 1);
229 main_thread = PyThread_get_thread_ident();
230}
231
232void
233PyEval_AcquireLock(void)
234{
235 PyThread_acquire_lock(interpreter_lock, 1);
236}
237
238void
239PyEval_ReleaseLock(void)
240{
241 PyThread_release_lock(interpreter_lock);
242}
243
244void
245PyEval_AcquireThread(PyThreadState *tstate)
246{
247 if (tstate == NULL)
248 Py_FatalError("PyEval_AcquireThread: NULL new thread state");
249 /* Check someone has called PyEval_InitThreads() to create the lock */
250 assert(interpreter_lock);
251 PyThread_acquire_lock(interpreter_lock, 1);
252 if (PyThreadState_Swap(tstate) != NULL)
253 Py_FatalError(
254 "PyEval_AcquireThread: non-NULL old thread state");
255}
256
257void
258PyEval_ReleaseThread(PyThreadState *tstate)
259{
260 if (tstate == NULL)
261 Py_FatalError("PyEval_ReleaseThread: NULL thread state");
262 if (PyThreadState_Swap(NULL) != tstate)
263 Py_FatalError("PyEval_ReleaseThread: wrong thread state");
264 PyThread_release_lock(interpreter_lock);
265}
266
267/* This function is called from PyOS_AfterFork to ensure that newly
268 created child processes don't hold locks referring to threads which
269 are not running in the child process. (This could also be done using
270 pthread_atfork mechanism, at least for the pthreads implementation.) */
271
272void
273PyEval_ReInitThreads(void)
274{
275 if (!interpreter_lock)
276 return;
277 /*XXX Can't use PyThread_free_lock here because it does too
278 much error-checking. Doing this cleanly would require
279 adding a new function to each thread_*.h. Instead, just
280 create a new lock and waste a little bit of memory */
281 interpreter_lock = PyThread_allocate_lock();
282 PyThread_acquire_lock(interpreter_lock, 1);
283 main_thread = PyThread_get_thread_ident();
284}
285#endif
286
287/* Functions save_thread and restore_thread are always defined so
288 dynamically loaded modules needn't be compiled separately for use
289 with and without threads: */
290
291PyThreadState *
292PyEval_SaveThread(void)
293{
294 PyThreadState *tstate = PyThreadState_Swap(NULL);
295 if (tstate == NULL)
296 Py_FatalError("PyEval_SaveThread: NULL tstate");
297#ifdef WITH_THREAD
298 if (interpreter_lock)
299 PyThread_release_lock(interpreter_lock);
300#endif
301 return tstate;
302}
303
304void
305PyEval_RestoreThread(PyThreadState *tstate)
306{
307 if (tstate == NULL)
308 Py_FatalError("PyEval_RestoreThread: NULL tstate");
309#ifdef WITH_THREAD
310 if (interpreter_lock) {
311 int err = errno;
312 PyThread_acquire_lock(interpreter_lock, 1);
313 errno = err;
314 }
315#endif
316 PyThreadState_Swap(tstate);
317}
318
319
320/* Mechanism whereby asynchronously executing callbacks (e.g. UNIX
321 signal handlers or Mac I/O completion routines) can schedule calls
322 to a function to be called synchronously.
323 The synchronous function is called with one void* argument.
324 It should return 0 for success or -1 for failure -- failure should
325 be accompanied by an exception.
326
327 If registry succeeds, the registry function returns 0; if it fails
328 (e.g. due to too many pending calls) it returns -1 (without setting
329 an exception condition).
330
331 Note that because registry may occur from within signal handlers,
332 or other asynchronous events, calling malloc() is unsafe!
333
334#ifdef WITH_THREAD
335 Any thread can schedule pending calls, but only the main thread
336 will execute them.
337#endif
338
339 XXX WARNING! ASYNCHRONOUSLY EXECUTING CODE!
340 There are two possible race conditions:
341 (1) nested asynchronous registry calls;
342 (2) registry calls made while pending calls are being processed.
343 While (1) is very unlikely, (2) is a real possibility.
344 The current code is safe against (2), but not against (1).
345 The safety against (2) is derived from the fact that only one
346 thread (the main thread) ever takes things out of the queue.
347
348 XXX Darn! With the advent of thread state, we should have an array
349 of pending calls per thread in the thread state! Later...
350*/
351
352#define NPENDINGCALLS 32
353static struct {
354 int (*func)(void *);
355 void *arg;
356} pendingcalls[NPENDINGCALLS];
357static volatile int pendingfirst = 0;
358static volatile int pendinglast = 0;
359static volatile int things_to_do = 0;
360
361int
362Py_AddPendingCall(int (*func)(void *), void *arg)
363{
364 static int busy = 0;
365 int i, j;
366 /* XXX Begin critical section */
367 /* XXX If you want this to be safe against nested
368 XXX asynchronous calls, you'll have to work harder! */
369 if (busy)
370 return -1;
371 busy = 1;
372 i = pendinglast;
373 j = (i + 1) % NPENDINGCALLS;
374 if (j == pendingfirst) {
375 busy = 0;
376 return -1; /* Queue full */
377 }
378 pendingcalls[i].func = func;
379 pendingcalls[i].arg = arg;
380 pendinglast = j;
381
382 _Py_Ticker = 0;
383 things_to_do = 1; /* Signal main loop */
384 busy = 0;
385 /* XXX End critical section */
386 return 0;
387}
388
389int
390Py_MakePendingCalls(void)
391{
392 static int busy = 0;
393#ifdef WITH_THREAD
394 if (main_thread && PyThread_get_thread_ident() != main_thread)
395 return 0;
396#endif
397 if (busy)
398 return 0;
399 busy = 1;
400 things_to_do = 0;
401 for (;;) {
402 int i;
403 int (*func)(void *);
404 void *arg;
405 i = pendingfirst;
406 if (i == pendinglast)
407 break; /* Queue empty */
408 func = pendingcalls[i].func;
409 arg = pendingcalls[i].arg;
410 pendingfirst = (i + 1) % NPENDINGCALLS;
411 if (func(arg) < 0) {
412 busy = 0;
413 things_to_do = 1; /* We're not done yet */
414 return -1;
415 }
416 }
417 busy = 0;
418 return 0;
419}
420
421
422/* The interpreter's recursion limit */
423
424#ifndef Py_DEFAULT_RECURSION_LIMIT
425#define Py_DEFAULT_RECURSION_LIMIT 1000
426#endif
427static int recursion_limit = Py_DEFAULT_RECURSION_LIMIT;
428int _Py_CheckRecursionLimit = Py_DEFAULT_RECURSION_LIMIT;
429
430int
431Py_GetRecursionLimit(void)
432{
433 return recursion_limit;
434}
435
436void
437Py_SetRecursionLimit(int new_limit)
438{
439 recursion_limit = new_limit;
440 _Py_CheckRecursionLimit = recursion_limit;
441}
442
443/* the macro Py_EnterRecursiveCall() only calls _Py_CheckRecursiveCall()
444 if the recursion_depth reaches _Py_CheckRecursionLimit.
445 If USE_STACKCHECK, the macro decrements _Py_CheckRecursionLimit
446 to guarantee that _Py_CheckRecursiveCall() is regularly called.
447 Without USE_STACKCHECK, there is no need for this. */
448int
449_Py_CheckRecursiveCall(char *where)
450{
451 PyThreadState *tstate = PyThreadState_GET();
452
453#ifdef USE_STACKCHECK
454 if (PyOS_CheckStack()) {
455 --tstate->recursion_depth;
456 PyErr_SetString(PyExc_MemoryError, "Stack overflow");
457 return -1;
458 }
459#endif
460 if (tstate->recursion_depth > recursion_limit) {
461 --tstate->recursion_depth;
462 PyErr_Format(PyExc_RuntimeError,
463 "maximum recursion depth exceeded%s",
464 where);
465 return -1;
466 }
467 _Py_CheckRecursionLimit = recursion_limit;
468 return 0;
469}
470
471/* Status code for main loop (reason for stack unwind) */
472enum why_code {
473 WHY_NOT = 0x0001, /* No error */
474 WHY_EXCEPTION = 0x0002, /* Exception occurred */
475 WHY_RERAISE = 0x0004, /* Exception re-raised by 'finally' */
476 WHY_RETURN = 0x0008, /* 'return' statement */
477 WHY_BREAK = 0x0010, /* 'break' statement */
478 WHY_CONTINUE = 0x0020, /* 'continue' statement */
479 WHY_YIELD = 0x0040 /* 'yield' operator */
480};
481
482static enum why_code do_raise(PyObject *, PyObject *, PyObject *);
483static int unpack_iterable(PyObject *, int, PyObject **);
484
485/* for manipulating the thread switch and periodic "stuff" - used to be
486 per thread, now just a pair o' globals */
487int _Py_CheckInterval = 100;
488volatile int _Py_Ticker = 100;
489
490PyObject *
491PyEval_EvalCode(PyCodeObject *co, PyObject *globals, PyObject *locals)
492{
493 /* XXX raise SystemError if globals is NULL */
494 return PyEval_EvalCodeEx(co,
495 globals, locals,
496 (PyObject **)NULL, 0,
497 (PyObject **)NULL, 0,
498 (PyObject **)NULL, 0,
499 NULL);
500}
501
502
503/* Interpreter main loop */
504
505PyObject *
506PyEval_EvalFrame(PyFrameObject *f) {
507 /* This is for backward compatibility with extension modules that
508 used this API; core interpreter code should call PyEval_EvalFrameEx() */
509 return PyEval_EvalFrameEx(f, 0);
510}
511
512PyObject *
513PyEval_EvalFrameEx(PyFrameObject *f, int throwflag)
514{
515#ifdef DXPAIRS
516 int lastopcode = 0;
517#endif
518 register PyObject **stack_pointer; /* Next free slot in value stack */
519 register unsigned char *next_instr;
520 register int opcode; /* Current opcode */
521 register int oparg; /* Current opcode argument, if any */
522 register enum why_code why; /* Reason for block stack unwind */
523 register int err; /* Error status -- nonzero if error */
524 register PyObject *x; /* Result object -- NULL if error */
525 register PyObject *v; /* Temporary objects popped off stack */
526 register PyObject *w;
527 register PyObject *u;
528 register PyObject *t;
529 register PyObject *stream = NULL; /* for PRINT opcodes */
530 register PyObject **fastlocals, **freevars;
531 PyObject *retval = NULL; /* Return value */
532 PyThreadState *tstate = PyThreadState_GET();
533 PyCodeObject *co;
534
535 /* when tracing we set things up so that
536
537 not (instr_lb <= current_bytecode_offset < instr_ub)
538
539 is true when the line being executed has changed. The
540 initial values are such as to make this false the first
541 time it is tested. */
542 int instr_ub = -1, instr_lb = 0, instr_prev = -1;
543
544 unsigned char *first_instr;
545 PyObject *names;
546 PyObject *consts;
547#if defined(Py_DEBUG) || defined(LLTRACE)
548 /* Make it easier to find out where we are with a debugger */
549 char *filename;
550#endif
551
552/* Tuple access macros */
553
554#ifndef Py_DEBUG
555#define GETITEM(v, i) PyTuple_GET_ITEM((PyTupleObject *)(v), (i))
556#else
557#define GETITEM(v, i) PyTuple_GetItem((v), (i))
558#endif
559
560#ifdef WITH_TSC
561/* Use Pentium timestamp counter to mark certain events:
562 inst0 -- beginning of switch statement for opcode dispatch
563 inst1 -- end of switch statement (may be skipped)
564 loop0 -- the top of the mainloop
565 loop1 -- place where control returns again to top of mainloop
566 (may be skipped)
567 intr1 -- beginning of long interruption
568 intr2 -- end of long interruption
569
570 Many opcodes call out to helper C functions. In some cases, the
571 time in those functions should be counted towards the time for the
572 opcode, but not in all cases. For example, a CALL_FUNCTION opcode
573 calls another Python function; there's no point in charge all the
574 bytecode executed by the called function to the caller.
575
576 It's hard to make a useful judgement statically. In the presence
577 of operator overloading, it's impossible to tell if a call will
578 execute new Python code or not.
579
580 It's a case-by-case judgement. I'll use intr1 for the following
581 cases:
582
583 EXEC_STMT
584 IMPORT_STAR
585 IMPORT_FROM
586 CALL_FUNCTION (and friends)
587
588 */
589 uint64 inst0, inst1, loop0, loop1, intr0 = 0, intr1 = 0;
590 int ticked = 0;
591
592 READ_TIMESTAMP(inst0);
593 READ_TIMESTAMP(inst1);
594 READ_TIMESTAMP(loop0);
595 READ_TIMESTAMP(loop1);
596
597 /* shut up the compiler */
598 opcode = 0;
599#endif
600
601/* Code access macros */
602
603#define INSTR_OFFSET() ((int)(next_instr - first_instr))
604#define NEXTOP() (*next_instr++)
605#define NEXTARG() (next_instr += 2, (next_instr[-1]<<8) + next_instr[-2])
606#define PEEKARG() ((next_instr[2]<<8) + next_instr[1])
607#define JUMPTO(x) (next_instr = first_instr + (x))
608#define JUMPBY(x) (next_instr += (x))
609
610/* OpCode prediction macros
611 Some opcodes tend to come in pairs thus making it possible to predict
612 the second code when the first is run. For example, COMPARE_OP is often
613 followed by JUMP_IF_FALSE or JUMP_IF_TRUE. And, those opcodes are often
614 followed by a POP_TOP.
615
616 Verifying the prediction costs a single high-speed test of register
617 variable against a constant. If the pairing was good, then the
618 processor has a high likelihood of making its own successful branch
619 prediction which results in a nearly zero overhead transition to the
620 next opcode.
621
622 A successful prediction saves a trip through the eval-loop including
623 its two unpredictable branches, the HASARG test and the switch-case.
624
625 If collecting opcode statistics, turn off prediction so that
626 statistics are accurately maintained (the predictions bypass
627 the opcode frequency counter updates).
628*/
629
630#ifdef DYNAMIC_EXECUTION_PROFILE
631#define PREDICT(op) if (0) goto PRED_##op
632#else
633#define PREDICT(op) if (*next_instr == op) goto PRED_##op
634#endif
635
636#define PREDICTED(op) PRED_##op: next_instr++
637#define PREDICTED_WITH_ARG(op) PRED_##op: oparg = PEEKARG(); next_instr += 3
638
639/* Stack manipulation macros */
640
641/* The stack can grow at most MAXINT deep, as co_nlocals and
642 co_stacksize are ints. */
643#define STACK_LEVEL() ((int)(stack_pointer - f->f_valuestack))
644#define EMPTY() (STACK_LEVEL() == 0)
645#define TOP() (stack_pointer[-1])
646#define SECOND() (stack_pointer[-2])
647#define THIRD() (stack_pointer[-3])
648#define FOURTH() (stack_pointer[-4])
649#define SET_TOP(v) (stack_pointer[-1] = (v))
650#define SET_SECOND(v) (stack_pointer[-2] = (v))
651#define SET_THIRD(v) (stack_pointer[-3] = (v))
652#define SET_FOURTH(v) (stack_pointer[-4] = (v))
653#define BASIC_STACKADJ(n) (stack_pointer += n)
654#define BASIC_PUSH(v) (*stack_pointer++ = (v))
655#define BASIC_POP() (*--stack_pointer)
656
657#ifdef LLTRACE
658#define PUSH(v) { (void)(BASIC_PUSH(v), \
659 lltrace && prtrace(TOP(), "push")); \
660 assert(STACK_LEVEL() <= co->co_stacksize); }
661#define POP() ((void)(lltrace && prtrace(TOP(), "pop")), BASIC_POP())
662#define STACKADJ(n) { (void)(BASIC_STACKADJ(n), \
663 lltrace && prtrace(TOP(), "stackadj")); \
664 assert(STACK_LEVEL() <= co->co_stacksize); }
665#define EXT_POP(STACK_POINTER) (lltrace && prtrace(*(STACK_POINTER), "ext_pop"), *--(STACK_POINTER))
666#else
667#define PUSH(v) BASIC_PUSH(v)
668#define POP() BASIC_POP()
669#define STACKADJ(n) BASIC_STACKADJ(n)
670#define EXT_POP(STACK_POINTER) (*--(STACK_POINTER))
671#endif
672
673/* Local variable macros */
674
675#define GETLOCAL(i) (fastlocals[i])
676
677/* The SETLOCAL() macro must not DECREF the local variable in-place and
678 then store the new value; it must copy the old value to a temporary
679 value, then store the new value, and then DECREF the temporary value.
680 This is because it is possible that during the DECREF the frame is
681 accessed by other code (e.g. a __del__ method or gc.collect()) and the
682 variable would be pointing to already-freed memory. */
683#define SETLOCAL(i, value) do { PyObject *tmp = GETLOCAL(i); \
684 GETLOCAL(i) = value; \
685 Py_XDECREF(tmp); } while (0)
686
687/* Start of code */
688
689 if (f == NULL)
690 return NULL;
691
692 /* push frame */
693 if (Py_EnterRecursiveCall(""))
694 return NULL;
695
696 tstate->frame = f;
697
698 if (tstate->use_tracing) {
699 if (tstate->c_tracefunc != NULL) {
700 /* tstate->c_tracefunc, if defined, is a
701 function that will be called on *every* entry
702 to a code block. Its return value, if not
703 None, is a function that will be called at
704 the start of each executed line of code.
705 (Actually, the function must return itself
706 in order to continue tracing.) The trace
707 functions are called with three arguments:
708 a pointer to the current frame, a string
709 indicating why the function is called, and
710 an argument which depends on the situation.
711 The global trace function is also called
712 whenever an exception is detected. */
713 if (call_trace(tstate->c_tracefunc, tstate->c_traceobj,
714 f, PyTrace_CALL, Py_None)) {
715 /* Trace function raised an error */
716 goto exit_eval_frame;
717 }
718 }
719 if (tstate->c_profilefunc != NULL) {
720 /* Similar for c_profilefunc, except it needn't
721 return itself and isn't called for "line" events */
722 if (call_trace(tstate->c_profilefunc,
723 tstate->c_profileobj,
724 f, PyTrace_CALL, Py_None)) {
725 /* Profile function raised an error */
726 goto exit_eval_frame;
727 }
728 }
729 }
730
731 co = f->f_code;
732 names = co->co_names;
733 consts = co->co_consts;
734 fastlocals = f->f_localsplus;
735 freevars = f->f_localsplus + co->co_nlocals;
736 first_instr = (unsigned char*) PyString_AS_STRING(co->co_code);
737 /* An explanation is in order for the next line.
738
739 f->f_lasti now refers to the index of the last instruction
740 executed. You might think this was obvious from the name, but
741 this wasn't always true before 2.3! PyFrame_New now sets
742 f->f_lasti to -1 (i.e. the index *before* the first instruction)
743 and YIELD_VALUE doesn't fiddle with f_lasti any more. So this
744 does work. Promise. */
745 next_instr = first_instr + f->f_lasti + 1;
746 stack_pointer = f->f_stacktop;
747 assert(stack_pointer != NULL);
748 f->f_stacktop = NULL; /* remains NULL unless yield suspends frame */
749
750#ifdef LLTRACE
751 lltrace = PyDict_GetItemString(f->f_globals, "__lltrace__") != NULL;
752#endif
753#if defined(Py_DEBUG) || defined(LLTRACE)
754 filename = PyString_AsString(co->co_filename);
755#endif
756
757 why = WHY_NOT;
758 err = 0;
759 x = Py_None; /* Not a reference, just anything non-NULL */
760 w = NULL;
761
762 if (throwflag) { /* support for generator.throw() */
763 why = WHY_EXCEPTION;
764 goto on_error;
765 }
766
767 for (;;) {
768#ifdef WITH_TSC
769 if (inst1 == 0) {
770 /* Almost surely, the opcode executed a break
771 or a continue, preventing inst1 from being set
772 on the way out of the loop.
773 */
774 READ_TIMESTAMP(inst1);
775 loop1 = inst1;
776 }
777 dump_tsc(opcode, ticked, inst0, inst1, loop0, loop1,
778 intr0, intr1);
779 ticked = 0;
780 inst1 = 0;
781 intr0 = 0;
782 intr1 = 0;
783 READ_TIMESTAMP(loop0);
784#endif
785 assert(stack_pointer >= f->f_valuestack); /* else underflow */
786 assert(STACK_LEVEL() <= co->co_stacksize); /* else overflow */
787
788 /* Do periodic things. Doing this every time through
789 the loop would add too much overhead, so we do it
790 only every Nth instruction. We also do it if
791 ``things_to_do'' is set, i.e. when an asynchronous
792 event needs attention (e.g. a signal handler or
793 async I/O handler); see Py_AddPendingCall() and
794 Py_MakePendingCalls() above. */
795
796 if (--_Py_Ticker < 0) {
797 if (*next_instr == SETUP_FINALLY) {
798 /* Make the last opcode before
799 a try: finally: block uninterruptable. */
800 goto fast_next_opcode;
801 }
802 _Py_Ticker = _Py_CheckInterval;
803 tstate->tick_counter++;
804#ifdef WITH_TSC
805 ticked = 1;
806#endif
807 if (things_to_do) {
808 if (Py_MakePendingCalls() < 0) {
809 why = WHY_EXCEPTION;
810 goto on_error;
811 }
812 if (things_to_do)
813 /* MakePendingCalls() didn't succeed.
814 Force early re-execution of this
815 "periodic" code, possibly after
816 a thread switch */
817 _Py_Ticker = 0;
818 }
819#ifdef WITH_THREAD
820 if (interpreter_lock) {
821 /* Give another thread a chance */
822
823 if (PyThreadState_Swap(NULL) != tstate)
824 Py_FatalError("ceval: tstate mix-up");
825 PyThread_release_lock(interpreter_lock);
826
827 /* Other threads may run now */
828
829 PyThread_acquire_lock(interpreter_lock, 1);
830 if (PyThreadState_Swap(tstate) != NULL)
831 Py_FatalError("ceval: orphan tstate");
832
833 /* Check for thread interrupts */
834
835 if (tstate->async_exc != NULL) {
836 x = tstate->async_exc;
837 tstate->async_exc = NULL;
838 PyErr_SetNone(x);
839 Py_DECREF(x);
840 why = WHY_EXCEPTION;
841 goto on_error;
842 }
843 }
844#endif
845 }
846
847 fast_next_opcode:
848 f->f_lasti = INSTR_OFFSET();
849
850 /* line-by-line tracing support */
851
852 if (tstate->c_tracefunc != NULL && !tstate->tracing) {
853 /* see maybe_call_line_trace
854 for expository comments */
855 f->f_stacktop = stack_pointer;
856
857 err = maybe_call_line_trace(tstate->c_tracefunc,
858 tstate->c_traceobj,
859 f, &instr_lb, &instr_ub,
860 &instr_prev);
861 /* Reload possibly changed frame fields */
862 JUMPTO(f->f_lasti);
863 if (f->f_stacktop != NULL) {
864 stack_pointer = f->f_stacktop;
865 f->f_stacktop = NULL;
866 }
867 if (err) {
868 /* trace function raised an exception */
869 goto on_error;
870 }
871 }
872
873 /* Extract opcode and argument */
874
875 opcode = NEXTOP();
876 oparg = 0; /* allows oparg to be stored in a register because
877 it doesn't have to be remembered across a full loop */
878 if (HAS_ARG(opcode))
879 oparg = NEXTARG();
880 dispatch_opcode:
881#ifdef DYNAMIC_EXECUTION_PROFILE
882#ifdef DXPAIRS
883 dxpairs[lastopcode][opcode]++;
884 lastopcode = opcode;
885#endif
886 dxp[opcode]++;
887#endif
888
889#ifdef LLTRACE
890 /* Instruction tracing */
891
892 if (lltrace) {
893 if (HAS_ARG(opcode)) {
894 printf("%d: %d, %d\n",
895 f->f_lasti, opcode, oparg);
896 }
897 else {
898 printf("%d: %d\n",
899 f->f_lasti, opcode);
900 }
901 }
902#endif
903
904 /* Main switch on opcode */
905 READ_TIMESTAMP(inst0);
906
907 switch (opcode) {
908
909 /* BEWARE!
910 It is essential that any operation that fails sets either
911 x to NULL, err to nonzero, or why to anything but WHY_NOT,
912 and that no operation that succeeds does this! */
913
914 /* case STOP_CODE: this is an error! */
915
916 case NOP:
917 goto fast_next_opcode;
918
919 case LOAD_FAST:
920 x = GETLOCAL(oparg);
921 if (x != NULL) {
922 Py_INCREF(x);
923 PUSH(x);
924 goto fast_next_opcode;
925 }
926 format_exc_check_arg(PyExc_UnboundLocalError,
927 UNBOUNDLOCAL_ERROR_MSG,
928 PyTuple_GetItem(co->co_varnames, oparg));
929 break;
930
931 case LOAD_CONST:
932 x = GETITEM(consts, oparg);
933 Py_INCREF(x);
934 PUSH(x);
935 goto fast_next_opcode;
936
937 PREDICTED_WITH_ARG(STORE_FAST);
938 case STORE_FAST:
939 v = POP();
940 SETLOCAL(oparg, v);
941 goto fast_next_opcode;
942
943 PREDICTED(POP_TOP);
944 case POP_TOP:
945 v = POP();
946 Py_DECREF(v);
947 goto fast_next_opcode;
948
949 case ROT_TWO:
950 v = TOP();
951 w = SECOND();
952 SET_TOP(w);
953 SET_SECOND(v);
954 goto fast_next_opcode;
955
956 case ROT_THREE:
957 v = TOP();
958 w = SECOND();
959 x = THIRD();
960 SET_TOP(w);
961 SET_SECOND(x);
962 SET_THIRD(v);
963 goto fast_next_opcode;
964
965 case ROT_FOUR:
966 u = TOP();
967 v = SECOND();
968 w = THIRD();
969 x = FOURTH();
970 SET_TOP(v);
971 SET_SECOND(w);
972 SET_THIRD(x);
973 SET_FOURTH(u);
974 goto fast_next_opcode;
975
976 case DUP_TOP:
977 v = TOP();
978 Py_INCREF(v);
979 PUSH(v);
980 goto fast_next_opcode;
981
982 case DUP_TOPX:
983 if (oparg == 2) {
984 x = TOP();
985 Py_INCREF(x);
986 w = SECOND();
987 Py_INCREF(w);
988 STACKADJ(2);
989 SET_TOP(x);
990 SET_SECOND(w);
991 goto fast_next_opcode;
992 } else if (oparg == 3) {
993 x = TOP();
994 Py_INCREF(x);
995 w = SECOND();
996 Py_INCREF(w);
997 v = THIRD();
998 Py_INCREF(v);
999 STACKADJ(3);
1000 SET_TOP(x);
1001 SET_SECOND(w);
1002 SET_THIRD(v);
1003 goto fast_next_opcode;
1004 }
1005 Py_FatalError("invalid argument to DUP_TOPX"
1006 " (bytecode corruption?)");
1007 break;
1008
1009 case UNARY_POSITIVE:
1010 v = TOP();
1011 x = PyNumber_Positive(v);
1012 Py_DECREF(v);
1013 SET_TOP(x);
1014 if (x != NULL) continue;
1015 break;
1016
1017 case UNARY_NEGATIVE:
1018 v = TOP();
1019 x = PyNumber_Negative(v);
1020 Py_DECREF(v);
1021 SET_TOP(x);
1022 if (x != NULL) continue;
1023 break;
1024
1025 case UNARY_NOT:
1026 v = TOP();
1027 err = PyObject_IsTrue(v);
1028 Py_DECREF(v);
1029 if (err == 0) {
1030 Py_INCREF(Py_True);
1031 SET_TOP(Py_True);
1032 continue;
1033 }
1034 else if (err > 0) {
1035 Py_INCREF(Py_False);
1036 SET_TOP(Py_False);
1037 err = 0;
1038 continue;
1039 }
1040 STACKADJ(-1);
1041 break;
1042
1043 case UNARY_CONVERT:
1044 v = TOP();
1045 x = PyObject_Repr(v);
1046 Py_DECREF(v);
1047 SET_TOP(x);
1048 if (x != NULL) continue;
1049 break;
1050
1051 case UNARY_INVERT:
1052 v = TOP();
1053 x = PyNumber_Invert(v);
1054 Py_DECREF(v);
1055 SET_TOP(x);
1056 if (x != NULL) continue;
1057 break;
1058
1059 case BINARY_POWER:
1060 w = POP();
1061 v = TOP();
1062 x = PyNumber_Power(v, w, Py_None);
1063 Py_DECREF(v);
1064 Py_DECREF(w);
1065 SET_TOP(x);
1066 if (x != NULL) continue;
1067 break;
1068
1069 case BINARY_MULTIPLY:
1070 w = POP();
1071 v = TOP();
1072 x = PyNumber_Multiply(v, w);
1073 Py_DECREF(v);
1074 Py_DECREF(w);
1075 SET_TOP(x);
1076 if (x != NULL) continue;
1077 break;
1078
1079 case BINARY_DIVIDE:
1080 if (!_Py_QnewFlag) {
1081 w = POP();
1082 v = TOP();
1083 x = PyNumber_Divide(v, w);
1084 Py_DECREF(v);
1085 Py_DECREF(w);
1086 SET_TOP(x);
1087 if (x != NULL) continue;
1088 break;
1089 }
1090 /* -Qnew is in effect: fall through to
1091 BINARY_TRUE_DIVIDE */
1092 case BINARY_TRUE_DIVIDE:
1093 w = POP();
1094 v = TOP();
1095 x = PyNumber_TrueDivide(v, w);
1096 Py_DECREF(v);
1097 Py_DECREF(w);
1098 SET_TOP(x);
1099 if (x != NULL) continue;
1100 break;
1101
1102 case BINARY_FLOOR_DIVIDE:
1103 w = POP();
1104 v = TOP();
1105 x = PyNumber_FloorDivide(v, w);
1106 Py_DECREF(v);
1107 Py_DECREF(w);
1108 SET_TOP(x);
1109 if (x != NULL) continue;
1110 break;
1111
1112 case BINARY_MODULO:
1113 w = POP();
1114 v = TOP();
1115 x = PyNumber_Remainder(v, w);
1116 Py_DECREF(v);
1117 Py_DECREF(w);
1118 SET_TOP(x);
1119 if (x != NULL) continue;
1120 break;
1121
1122 case BINARY_ADD:
1123 w = POP();
1124 v = TOP();
1125 if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
1126 /* INLINE: int + int */
1127 register long a, b, i;
1128 a = PyInt_AS_LONG(v);
1129 b = PyInt_AS_LONG(w);
1130 i = a + b;
1131 if ((i^a) < 0 && (i^b) < 0)
1132 goto slow_add;
1133 x = PyInt_FromLong(i);
1134 }
1135 else if (PyString_CheckExact(v) &&
1136 PyString_CheckExact(w)) {
1137 x = string_concatenate(v, w, f, next_instr);
1138 /* string_concatenate consumed the ref to v */
1139 goto skip_decref_vx;
1140 }
1141 else {
1142 slow_add:
1143 x = PyNumber_Add(v, w);
1144 }
1145 Py_DECREF(v);
1146 skip_decref_vx:
1147 Py_DECREF(w);
1148 SET_TOP(x);
1149 if (x != NULL) continue;
1150 break;
1151
1152 case BINARY_SUBTRACT:
1153 w = POP();
1154 v = TOP();
1155 if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
1156 /* INLINE: int - int */
1157 register long a, b, i;
1158 a = PyInt_AS_LONG(v);
1159 b = PyInt_AS_LONG(w);
1160 i = a - b;
1161 if ((i^a) < 0 && (i^~b) < 0)
1162 goto slow_sub;
1163 x = PyInt_FromLong(i);
1164 }
1165 else {
1166 slow_sub:
1167 x = PyNumber_Subtract(v, w);
1168 }
1169 Py_DECREF(v);
1170 Py_DECREF(w);
1171 SET_TOP(x);
1172 if (x != NULL) continue;
1173 break;
1174
1175 case BINARY_SUBSCR:
1176 w = POP();
1177 v = TOP();
1178 if (PyList_CheckExact(v) && PyInt_CheckExact(w)) {
1179 /* INLINE: list[int] */
1180 Py_ssize_t i = PyInt_AsSsize_t(w);
1181 if (i < 0)
1182 i += PyList_GET_SIZE(v);
1183 if (i >= 0 && i < PyList_GET_SIZE(v)) {
1184 x = PyList_GET_ITEM(v, i);
1185 Py_INCREF(x);
1186 }
1187 else
1188 goto slow_get;
1189 }
1190 else
1191 slow_get:
1192 x = PyObject_GetItem(v, w);
1193 Py_DECREF(v);
1194 Py_DECREF(w);
1195 SET_TOP(x);
1196 if (x != NULL) continue;
1197 break;
1198
1199 case BINARY_LSHIFT:
1200 w = POP();
1201 v = TOP();
1202 x = PyNumber_Lshift(v, w);
1203 Py_DECREF(v);
1204 Py_DECREF(w);
1205 SET_TOP(x);
1206 if (x != NULL) continue;
1207 break;
1208
1209 case BINARY_RSHIFT:
1210 w = POP();
1211 v = TOP();
1212 x = PyNumber_Rshift(v, w);
1213 Py_DECREF(v);
1214 Py_DECREF(w);
1215 SET_TOP(x);
1216 if (x != NULL) continue;
1217 break;
1218
1219 case BINARY_AND:
1220 w = POP();
1221 v = TOP();
1222 x = PyNumber_And(v, w);
1223 Py_DECREF(v);
1224 Py_DECREF(w);
1225 SET_TOP(x);
1226 if (x != NULL) continue;
1227 break;
1228
1229 case BINARY_XOR:
1230 w = POP();
1231 v = TOP();
1232 x = PyNumber_Xor(v, w);
1233 Py_DECREF(v);
1234 Py_DECREF(w);
1235 SET_TOP(x);
1236 if (x != NULL) continue;
1237 break;
1238
1239 case BINARY_OR:
1240 w = POP();
1241 v = TOP();
1242 x = PyNumber_Or(v, w);
1243 Py_DECREF(v);
1244 Py_DECREF(w);
1245 SET_TOP(x);
1246 if (x != NULL) continue;
1247 break;
1248
1249 case LIST_APPEND:
1250 w = POP();
1251 v = POP();
1252 err = PyList_Append(v, w);
1253 Py_DECREF(v);
1254 Py_DECREF(w);
1255 if (err == 0) {
1256 PREDICT(JUMP_ABSOLUTE);
1257 continue;
1258 }
1259 break;
1260
1261 case INPLACE_POWER:
1262 w = POP();
1263 v = TOP();
1264 x = PyNumber_InPlacePower(v, w, Py_None);
1265 Py_DECREF(v);
1266 Py_DECREF(w);
1267 SET_TOP(x);
1268 if (x != NULL) continue;
1269 break;
1270
1271 case INPLACE_MULTIPLY:
1272 w = POP();
1273 v = TOP();
1274 x = PyNumber_InPlaceMultiply(v, w);
1275 Py_DECREF(v);
1276 Py_DECREF(w);
1277 SET_TOP(x);
1278 if (x != NULL) continue;
1279 break;
1280
1281 case INPLACE_DIVIDE:
1282 if (!_Py_QnewFlag) {
1283 w = POP();
1284 v = TOP();
1285 x = PyNumber_InPlaceDivide(v, w);
1286 Py_DECREF(v);
1287 Py_DECREF(w);
1288 SET_TOP(x);
1289 if (x != NULL) continue;
1290 break;
1291 }
1292 /* -Qnew is in effect: fall through to
1293 INPLACE_TRUE_DIVIDE */
1294 case INPLACE_TRUE_DIVIDE:
1295 w = POP();
1296 v = TOP();
1297 x = PyNumber_InPlaceTrueDivide(v, w);
1298 Py_DECREF(v);
1299 Py_DECREF(w);
1300 SET_TOP(x);
1301 if (x != NULL) continue;
1302 break;
1303
1304 case INPLACE_FLOOR_DIVIDE:
1305 w = POP();
1306 v = TOP();
1307 x = PyNumber_InPlaceFloorDivide(v, w);
1308 Py_DECREF(v);
1309 Py_DECREF(w);
1310 SET_TOP(x);
1311 if (x != NULL) continue;
1312 break;
1313
1314 case INPLACE_MODULO:
1315 w = POP();
1316 v = TOP();
1317 x = PyNumber_InPlaceRemainder(v, w);
1318 Py_DECREF(v);
1319 Py_DECREF(w);
1320 SET_TOP(x);
1321 if (x != NULL) continue;
1322 break;
1323
1324 case INPLACE_ADD:
1325 w = POP();
1326 v = TOP();
1327 if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
1328 /* INLINE: int + int */
1329 register long a, b, i;
1330 a = PyInt_AS_LONG(v);
1331 b = PyInt_AS_LONG(w);
1332 i = a + b;
1333 if ((i^a) < 0 && (i^b) < 0)
1334 goto slow_iadd;
1335 x = PyInt_FromLong(i);
1336 }
1337 else if (PyString_CheckExact(v) &&
1338 PyString_CheckExact(w)) {
1339 x = string_concatenate(v, w, f, next_instr);
1340 /* string_concatenate consumed the ref to v */
1341 goto skip_decref_v;
1342 }
1343 else {
1344 slow_iadd:
1345 x = PyNumber_InPlaceAdd(v, w);
1346 }
1347 Py_DECREF(v);
1348 skip_decref_v:
1349 Py_DECREF(w);
1350 SET_TOP(x);
1351 if (x != NULL) continue;
1352 break;
1353
1354 case INPLACE_SUBTRACT:
1355 w = POP();
1356 v = TOP();
1357 if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
1358 /* INLINE: int - int */
1359 register long a, b, i;
1360 a = PyInt_AS_LONG(v);
1361 b = PyInt_AS_LONG(w);
1362 i = a - b;
1363 if ((i^a) < 0 && (i^~b) < 0)
1364 goto slow_isub;
1365 x = PyInt_FromLong(i);
1366 }
1367 else {
1368 slow_isub:
1369 x = PyNumber_InPlaceSubtract(v, w);
1370 }
1371 Py_DECREF(v);
1372 Py_DECREF(w);
1373 SET_TOP(x);
1374 if (x != NULL) continue;
1375 break;
1376
1377 case INPLACE_LSHIFT:
1378 w = POP();
1379 v = TOP();
1380 x = PyNumber_InPlaceLshift(v, w);
1381 Py_DECREF(v);
1382 Py_DECREF(w);
1383 SET_TOP(x);
1384 if (x != NULL) continue;
1385 break;
1386
1387 case INPLACE_RSHIFT:
1388 w = POP();
1389 v = TOP();
1390 x = PyNumber_InPlaceRshift(v, w);
1391 Py_DECREF(v);
1392 Py_DECREF(w);
1393 SET_TOP(x);
1394 if (x != NULL) continue;
1395 break;
1396
1397 case INPLACE_AND:
1398 w = POP();
1399 v = TOP();
1400 x = PyNumber_InPlaceAnd(v, w);
1401 Py_DECREF(v);
1402 Py_DECREF(w);
1403 SET_TOP(x);
1404 if (x != NULL) continue;
1405 break;
1406
1407 case INPLACE_XOR:
1408 w = POP();
1409 v = TOP();
1410 x = PyNumber_InPlaceXor(v, w);
1411 Py_DECREF(v);
1412 Py_DECREF(w);
1413 SET_TOP(x);
1414 if (x != NULL) continue;
1415 break;
1416
1417 case INPLACE_OR:
1418 w = POP();
1419 v = TOP();
1420 x = PyNumber_InPlaceOr(v, w);
1421 Py_DECREF(v);
1422 Py_DECREF(w);
1423 SET_TOP(x);
1424 if (x != NULL) continue;
1425 break;
1426
1427 case SLICE+0:
1428 case SLICE+1:
1429 case SLICE+2:
1430 case SLICE+3:
1431 if ((opcode-SLICE) & 2)
1432 w = POP();
1433 else
1434 w = NULL;
1435 if ((opcode-SLICE) & 1)
1436 v = POP();
1437 else
1438 v = NULL;
1439 u = TOP();
1440 x = apply_slice(u, v, w);
1441 Py_DECREF(u);
1442 Py_XDECREF(v);
1443 Py_XDECREF(w);
1444 SET_TOP(x);
1445 if (x != NULL) continue;
1446 break;
1447
1448 case STORE_SLICE+0:
1449 case STORE_SLICE+1:
1450 case STORE_SLICE+2:
1451 case STORE_SLICE+3:
1452 if ((opcode-STORE_SLICE) & 2)
1453 w = POP();
1454 else
1455 w = NULL;
1456 if ((opcode-STORE_SLICE) & 1)
1457 v = POP();
1458 else
1459 v = NULL;
1460 u = POP();
1461 t = POP();
1462 err = assign_slice(u, v, w, t); /* u[v:w] = t */
1463 Py_DECREF(t);
1464 Py_DECREF(u);
1465 Py_XDECREF(v);
1466 Py_XDECREF(w);
1467 if (err == 0) continue;
1468 break;
1469
1470 case DELETE_SLICE+0:
1471 case DELETE_SLICE+1:
1472 case DELETE_SLICE+2:
1473 case DELETE_SLICE+3:
1474 if ((opcode-DELETE_SLICE) & 2)
1475 w = POP();
1476 else
1477 w = NULL;
1478 if ((opcode-DELETE_SLICE) & 1)
1479 v = POP();
1480 else
1481 v = NULL;
1482 u = POP();
1483 err = assign_slice(u, v, w, (PyObject *)NULL);
1484 /* del u[v:w] */
1485 Py_DECREF(u);
1486 Py_XDECREF(v);
1487 Py_XDECREF(w);
1488 if (err == 0) continue;
1489 break;
1490
1491 case STORE_SUBSCR:
1492 w = TOP();
1493 v = SECOND();
1494 u = THIRD();
1495 STACKADJ(-3);
1496 /* v[w] = u */
1497 err = PyObject_SetItem(v, w, u);
1498 Py_DECREF(u);
1499 Py_DECREF(v);
1500 Py_DECREF(w);
1501 if (err == 0) continue;
1502 break;
1503
1504 case DELETE_SUBSCR:
1505 w = TOP();
1506 v = SECOND();
1507 STACKADJ(-2);
1508 /* del v[w] */
1509 err = PyObject_DelItem(v, w);
1510 Py_DECREF(v);
1511 Py_DECREF(w);
1512 if (err == 0) continue;
1513 break;
1514
1515 case PRINT_EXPR:
1516 v = POP();
1517 w = PySys_GetObject("displayhook");
1518 if (w == NULL) {
1519 PyErr_SetString(PyExc_RuntimeError,
1520 "lost sys.displayhook");
1521 err = -1;
1522 x = NULL;
1523 }
1524 if (err == 0) {
1525 x = PyTuple_Pack(1, v);
1526 if (x == NULL)
1527 err = -1;
1528 }
1529 if (err == 0) {
1530 w = PyEval_CallObject(w, x);
1531 Py_XDECREF(w);
1532 if (w == NULL)
1533 err = -1;
1534 }
1535 Py_DECREF(v);
1536 Py_XDECREF(x);
1537 break;
1538
1539 case PRINT_ITEM_TO:
1540 w = stream = POP();
1541 /* fall through to PRINT_ITEM */
1542
1543 case PRINT_ITEM:
1544 v = POP();
1545 if (stream == NULL || stream == Py_None) {
1546 w = PySys_GetObject("stdout");
1547 if (w == NULL) {
1548 PyErr_SetString(PyExc_RuntimeError,
1549 "lost sys.stdout");
1550 err = -1;
1551 }
1552 }
1553 /* PyFile_SoftSpace() can exececute arbitrary code
1554 if sys.stdout is an instance with a __getattr__.
1555 If __getattr__ raises an exception, w will
1556 be freed, so we need to prevent that temporarily. */
1557 Py_XINCREF(w);
1558 if (w != NULL && PyFile_SoftSpace(w, 0))
1559 err = PyFile_WriteString(" ", w);
1560 if (err == 0)
1561 err = PyFile_WriteObject(v, w, Py_PRINT_RAW);
1562 if (err == 0) {
1563 /* XXX move into writeobject() ? */
1564 if (PyString_Check(v)) {
1565 char *s = PyString_AS_STRING(v);
1566 Py_ssize_t len = PyString_GET_SIZE(v);
1567 if (len == 0 ||
1568 !isspace(Py_CHARMASK(s[len-1])) ||
1569 s[len-1] == ' ')
1570 PyFile_SoftSpace(w, 1);
1571 }
1572#ifdef Py_USING_UNICODE
1573 else if (PyUnicode_Check(v)) {
1574 Py_UNICODE *s = PyUnicode_AS_UNICODE(v);
1575 Py_ssize_t len = PyUnicode_GET_SIZE(v);
1576 if (len == 0 ||
1577 !Py_UNICODE_ISSPACE(s[len-1]) ||
1578 s[len-1] == ' ')
1579 PyFile_SoftSpace(w, 1);
1580 }
1581#endif
1582 else
1583 PyFile_SoftSpace(w, 1);
1584 }
1585 Py_XDECREF(w);
1586 Py_DECREF(v);
1587 Py_XDECREF(stream);
1588 stream = NULL;
1589 if (err == 0)
1590 continue;
1591 break;
1592
1593 case PRINT_NEWLINE_TO:
1594 w = stream = POP();
1595 /* fall through to PRINT_NEWLINE */
1596
1597 case PRINT_NEWLINE:
1598 if (stream == NULL || stream == Py_None) {
1599 w = PySys_GetObject("stdout");
1600 if (w == NULL)
1601 PyErr_SetString(PyExc_RuntimeError,
1602 "lost sys.stdout");
1603 }
1604 if (w != NULL) {
1605 err = PyFile_WriteString("\n", w);
1606 if (err == 0)
1607 PyFile_SoftSpace(w, 0);
1608 }
1609 Py_XDECREF(stream);
1610 stream = NULL;
1611 break;
1612
1613
1614#ifdef CASE_TOO_BIG
1615 default: switch (opcode) {
1616#endif
1617 case RAISE_VARARGS:
1618 u = v = w = NULL;
1619 switch (oparg) {
1620 case 3:
1621 u = POP(); /* traceback */
1622 /* Fallthrough */
1623 case 2:
1624 v = POP(); /* value */
1625 /* Fallthrough */
1626 case 1:
1627 w = POP(); /* exc */
1628 case 0: /* Fallthrough */
1629 why = do_raise(w, v, u);
1630 break;
1631 default:
1632 PyErr_SetString(PyExc_SystemError,
1633 "bad RAISE_VARARGS oparg");
1634 why = WHY_EXCEPTION;
1635 break;
1636 }
1637 break;
1638
1639 case LOAD_LOCALS:
1640 if ((x = f->f_locals) != NULL) {
1641 Py_INCREF(x);
1642 PUSH(x);
1643 continue;
1644 }
1645 PyErr_SetString(PyExc_SystemError, "no locals");
1646 break;
1647
1648 case RETURN_VALUE:
1649 retval = POP();
1650 why = WHY_RETURN;
1651 goto fast_block_end;
1652
1653 case YIELD_VALUE:
1654 retval = POP();
1655 f->f_stacktop = stack_pointer;
1656 why = WHY_YIELD;
1657 goto fast_yield;
1658
1659 case EXEC_STMT:
1660 w = TOP();
1661 v = SECOND();
1662 u = THIRD();
1663 STACKADJ(-3);
1664 READ_TIMESTAMP(intr0);
1665 err = exec_statement(f, u, v, w);
1666 READ_TIMESTAMP(intr1);
1667 Py_DECREF(u);
1668 Py_DECREF(v);
1669 Py_DECREF(w);
1670 break;
1671
1672 case POP_BLOCK:
1673 {
1674 PyTryBlock *b = PyFrame_BlockPop(f);
1675 while (STACK_LEVEL() > b->b_level) {
1676 v = POP();
1677 Py_DECREF(v);
1678 }
1679 }
1680 continue;
1681
1682 case END_FINALLY:
1683 v = POP();
1684 if (PyInt_Check(v)) {
1685 why = (enum why_code) PyInt_AS_LONG(v);
1686 assert(why != WHY_YIELD);
1687 if (why == WHY_RETURN ||
1688 why == WHY_CONTINUE)
1689 retval = POP();
1690 }
1691 else if (PyExceptionClass_Check(v) || PyString_Check(v)) {
1692 w = POP();
1693 u = POP();
1694 PyErr_Restore(v, w, u);
1695 why = WHY_RERAISE;
1696 break;
1697 }
1698 else if (v != Py_None) {
1699 PyErr_SetString(PyExc_SystemError,
1700 "'finally' pops bad exception");
1701 why = WHY_EXCEPTION;
1702 }
1703 Py_DECREF(v);
1704 break;
1705
1706 case BUILD_CLASS:
1707 u = TOP();
1708 v = SECOND();
1709 w = THIRD();
1710 STACKADJ(-2);
1711 x = build_class(u, v, w);
1712 SET_TOP(x);
1713 Py_DECREF(u);
1714 Py_DECREF(v);
1715 Py_DECREF(w);
1716 break;
1717
1718 case STORE_NAME:
1719 w = GETITEM(names, oparg);
1720 v = POP();
1721 if ((x = f->f_locals) != NULL) {
1722 if (PyDict_CheckExact(x))
1723 err = PyDict_SetItem(x, w, v);
1724 else
1725 err = PyObject_SetItem(x, w, v);
1726 Py_DECREF(v);
1727 if (err == 0) continue;
1728 break;
1729 }
1730 PyErr_Format(PyExc_SystemError,
1731 "no locals found when storing %s",
1732 PyObject_REPR(w));
1733 break;
1734
1735 case DELETE_NAME:
1736 w = GETITEM(names, oparg);
1737 if ((x = f->f_locals) != NULL) {
1738 if ((err = PyObject_DelItem(x, w)) != 0)
1739 format_exc_check_arg(PyExc_NameError,
1740 NAME_ERROR_MSG ,w);
1741 break;
1742 }
1743 PyErr_Format(PyExc_SystemError,
1744 "no locals when deleting %s",
1745 PyObject_REPR(w));
1746 break;
1747
1748 PREDICTED_WITH_ARG(UNPACK_SEQUENCE);
1749 case UNPACK_SEQUENCE:
1750 v = POP();
1751 if (PyTuple_CheckExact(v) && PyTuple_GET_SIZE(v) == oparg) {
1752 PyObject **items = ((PyTupleObject *)v)->ob_item;
1753 while (oparg--) {
1754 w = items[oparg];
1755 Py_INCREF(w);
1756 PUSH(w);
1757 }
1758 Py_DECREF(v);
1759 continue;
1760 } else if (PyList_CheckExact(v) && PyList_GET_SIZE(v) == oparg) {
1761 PyObject **items = ((PyListObject *)v)->ob_item;
1762 while (oparg--) {
1763 w = items[oparg];
1764 Py_INCREF(w);
1765 PUSH(w);
1766 }
1767 } else if (unpack_iterable(v, oparg,
1768 stack_pointer + oparg)) {
1769 stack_pointer += oparg;
1770 } else {
1771 /* unpack_iterable() raised an exception */
1772 why = WHY_EXCEPTION;
1773 }
1774 Py_DECREF(v);
1775 break;
1776
1777 case STORE_ATTR:
1778 w = GETITEM(names, oparg);
1779 v = TOP();
1780 u = SECOND();
1781 STACKADJ(-2);
1782 err = PyObject_SetAttr(v, w, u); /* v.w = u */
1783 Py_DECREF(v);
1784 Py_DECREF(u);
1785 if (err == 0) continue;
1786 break;
1787
1788 case DELETE_ATTR:
1789 w = GETITEM(names, oparg);
1790 v = POP();
1791 err = PyObject_SetAttr(v, w, (PyObject *)NULL);
1792 /* del v.w */
1793 Py_DECREF(v);
1794 break;
1795
1796 case STORE_GLOBAL:
1797 w = GETITEM(names, oparg);
1798 v = POP();
1799 err = PyDict_SetItem(f->f_globals, w, v);
1800 Py_DECREF(v);
1801 if (err == 0) continue;
1802 break;
1803
1804 case DELETE_GLOBAL:
1805 w = GETITEM(names, oparg);
1806 if ((err = PyDict_DelItem(f->f_globals, w)) != 0)
1807 format_exc_check_arg(
1808 PyExc_NameError, GLOBAL_NAME_ERROR_MSG, w);
1809 break;
1810
1811 case LOAD_NAME:
1812 w = GETITEM(names, oparg);
1813 if ((v = f->f_locals) == NULL) {
1814 PyErr_Format(PyExc_SystemError,
1815 "no locals when loading %s",
1816 PyObject_REPR(w));
1817 break;
1818 }
1819 if (PyDict_CheckExact(v)) {
1820 x = PyDict_GetItem(v, w);
1821 Py_XINCREF(x);
1822 }
1823 else {
1824 x = PyObject_GetItem(v, w);
1825 if (x == NULL && PyErr_Occurred()) {
1826 if (!PyErr_ExceptionMatches(PyExc_KeyError))
1827 break;
1828 PyErr_Clear();
1829 }
1830 }
1831 if (x == NULL) {
1832 x = PyDict_GetItem(f->f_globals, w);
1833 if (x == NULL) {
1834 x = PyDict_GetItem(f->f_builtins, w);
1835 if (x == NULL) {
1836 format_exc_check_arg(
1837 PyExc_NameError,
1838 NAME_ERROR_MSG ,w);
1839 break;
1840 }
1841 }
1842 Py_INCREF(x);
1843 }
1844 PUSH(x);
1845 continue;
1846
1847 case LOAD_GLOBAL:
1848 w = GETITEM(names, oparg);
1849 if (PyString_CheckExact(w)) {
1850 /* Inline the PyDict_GetItem() calls.
1851 WARNING: this is an extreme speed hack.
1852 Do not try this at home. */
1853 long hash = ((PyStringObject *)w)->ob_shash;
1854 if (hash != -1) {
1855 PyDictObject *d;
1856 PyDictEntry *e;
1857 d = (PyDictObject *)(f->f_globals);
1858 e = d->ma_lookup(d, w, hash);
1859 if (e == NULL) {
1860 x = NULL;
1861 break;
1862 }
1863 x = e->me_value;
1864 if (x != NULL) {
1865 Py_INCREF(x);
1866 PUSH(x);
1867 continue;
1868 }
1869 d = (PyDictObject *)(f->f_builtins);
1870 e = d->ma_lookup(d, w, hash);
1871 if (e == NULL) {
1872 x = NULL;
1873 break;
1874 }
1875 x = e->me_value;
1876 if (x != NULL) {
1877 Py_INCREF(x);
1878 PUSH(x);
1879 continue;
1880 }
1881 goto load_global_error;
1882 }
1883 }
1884 /* This is the un-inlined version of the code above */
1885 x = PyDict_GetItem(f->f_globals, w);
1886 if (x == NULL) {
1887 x = PyDict_GetItem(f->f_builtins, w);
1888 if (x == NULL) {
1889 load_global_error:
1890 format_exc_check_arg(
1891 PyExc_NameError,
1892 GLOBAL_NAME_ERROR_MSG, w);
1893 break;
1894 }
1895 }
1896 Py_INCREF(x);
1897 PUSH(x);
1898 continue;
1899
1900 case DELETE_FAST:
1901 x = GETLOCAL(oparg);
1902 if (x != NULL) {
1903 SETLOCAL(oparg, NULL);
1904 continue;
1905 }
1906 format_exc_check_arg(
1907 PyExc_UnboundLocalError,
1908 UNBOUNDLOCAL_ERROR_MSG,
1909 PyTuple_GetItem(co->co_varnames, oparg)
1910 );
1911 break;
1912
1913 case LOAD_CLOSURE:
1914 x = freevars[oparg];
1915 Py_INCREF(x);
1916 PUSH(x);
1917 if (x != NULL) continue;
1918 break;
1919
1920 case LOAD_DEREF:
1921 x = freevars[oparg];
1922 w = PyCell_Get(x);
1923 if (w != NULL) {
1924 PUSH(w);
1925 continue;
1926 }
1927 err = -1;
1928 /* Don't stomp existing exception */
1929 if (PyErr_Occurred())
1930 break;
1931 if (oparg < PyTuple_GET_SIZE(co->co_cellvars)) {
1932 v = PyTuple_GET_ITEM(co->co_cellvars,
1933 oparg);
1934 format_exc_check_arg(
1935 PyExc_UnboundLocalError,
1936 UNBOUNDLOCAL_ERROR_MSG,
1937 v);
1938 } else {
1939 v = PyTuple_GET_ITEM(
1940 co->co_freevars,
1941 oparg - PyTuple_GET_SIZE(co->co_cellvars));
1942 format_exc_check_arg(
1943 PyExc_NameError,
1944 UNBOUNDFREE_ERROR_MSG,
1945 v);
1946 }
1947 break;
1948
1949 case STORE_DEREF:
1950 w = POP();
1951 x = freevars[oparg];
1952 PyCell_Set(x, w);
1953 Py_DECREF(w);
1954 continue;
1955
1956 case BUILD_TUPLE:
1957 x = PyTuple_New(oparg);
1958 if (x != NULL) {
1959 for (; --oparg >= 0;) {
1960 w = POP();
1961 PyTuple_SET_ITEM(x, oparg, w);
1962 }
1963 PUSH(x);
1964 continue;
1965 }
1966 break;
1967
1968 case BUILD_LIST:
1969 x = PyList_New(oparg);
1970 if (x != NULL) {
1971 for (; --oparg >= 0;) {
1972 w = POP();
1973 PyList_SET_ITEM(x, oparg, w);
1974 }
1975 PUSH(x);
1976 continue;
1977 }
1978 break;
1979
1980 case BUILD_MAP:
1981 x = PyDict_New();
1982 PUSH(x);
1983 if (x != NULL) continue;
1984 break;
1985
1986 case LOAD_ATTR:
1987 w = GETITEM(names, oparg);
1988 v = TOP();
1989 x = PyObject_GetAttr(v, w);
1990 Py_DECREF(v);
1991 SET_TOP(x);
1992 if (x != NULL) continue;
1993 break;
1994
1995 case COMPARE_OP:
1996 w = POP();
1997 v = TOP();
1998 if (PyInt_CheckExact(w) && PyInt_CheckExact(v)) {
1999 /* INLINE: cmp(int, int) */
2000 register long a, b;
2001 register int res;
2002 a = PyInt_AS_LONG(v);
2003 b = PyInt_AS_LONG(w);
2004 switch (oparg) {
2005 case PyCmp_LT: res = a < b; break;
2006 case PyCmp_LE: res = a <= b; break;
2007 case PyCmp_EQ: res = a == b; break;
2008 case PyCmp_NE: res = a != b; break;
2009 case PyCmp_GT: res = a > b; break;
2010 case PyCmp_GE: res = a >= b; break;
2011 case PyCmp_IS: res = v == w; break;
2012 case PyCmp_IS_NOT: res = v != w; break;
2013 default: goto slow_compare;
2014 }
2015 x = res ? Py_True : Py_False;
2016 Py_INCREF(x);
2017 }
2018 else {
2019 slow_compare:
2020 x = cmp_outcome(oparg, v, w);
2021 }
2022 Py_DECREF(v);
2023 Py_DECREF(w);
2024 SET_TOP(x);
2025 if (x == NULL) break;
2026 PREDICT(JUMP_IF_FALSE);
2027 PREDICT(JUMP_IF_TRUE);
2028 continue;
2029
2030 case IMPORT_NAME:
2031 w = GETITEM(names, oparg);
2032 x = PyDict_GetItemString(f->f_builtins, "__import__");
2033 if (x == NULL) {
2034 PyErr_SetString(PyExc_ImportError,
2035 "__import__ not found");
2036 break;
2037 }
2038 v = POP();
2039 u = TOP();
2040 if (PyInt_AsLong(u) != -1 || PyErr_Occurred())
2041 w = PyTuple_Pack(5,
2042 w,
2043 f->f_globals,
2044 f->f_locals == NULL ?
2045 Py_None : f->f_locals,
2046 v,
2047 u);
2048 else
2049 w = PyTuple_Pack(4,
2050 w,
2051 f->f_globals,
2052 f->f_locals == NULL ?
2053 Py_None : f->f_locals,
2054 v);
2055 Py_DECREF(v);
2056 Py_DECREF(u);
2057 if (w == NULL) {
2058 u = POP();
2059 x = NULL;
2060 break;
2061 }
2062 READ_TIMESTAMP(intr0);
2063 x = PyEval_CallObject(x, w);
2064 READ_TIMESTAMP(intr1);
2065 Py_DECREF(w);
2066 SET_TOP(x);
2067 if (x != NULL) continue;
2068 break;
2069
2070 case IMPORT_STAR:
2071 v = POP();
2072 PyFrame_FastToLocals(f);
2073 if ((x = f->f_locals) == NULL) {
2074 PyErr_SetString(PyExc_SystemError,
2075 "no locals found during 'import *'");
2076 break;
2077 }
2078 READ_TIMESTAMP(intr0);
2079 err = import_all_from(x, v);
2080 READ_TIMESTAMP(intr1);
2081 PyFrame_LocalsToFast(f, 0);
2082 Py_DECREF(v);
2083 if (err == 0) continue;
2084 break;
2085
2086 case IMPORT_FROM:
2087 w = GETITEM(names, oparg);
2088 v = TOP();
2089 READ_TIMESTAMP(intr0);
2090 x = import_from(v, w);
2091 READ_TIMESTAMP(intr1);
2092 PUSH(x);
2093 if (x != NULL) continue;
2094 break;
2095
2096 case JUMP_FORWARD:
2097 JUMPBY(oparg);
2098 goto fast_next_opcode;
2099
2100 PREDICTED_WITH_ARG(JUMP_IF_FALSE);
2101 case JUMP_IF_FALSE:
2102 w = TOP();
2103 if (w == Py_True) {
2104 PREDICT(POP_TOP);
2105 goto fast_next_opcode;
2106 }
2107 if (w == Py_False) {
2108 JUMPBY(oparg);
2109 goto fast_next_opcode;
2110 }
2111 err = PyObject_IsTrue(w);
2112 if (err > 0)
2113 err = 0;
2114 else if (err == 0)
2115 JUMPBY(oparg);
2116 else
2117 break;
2118 continue;
2119
2120 PREDICTED_WITH_ARG(JUMP_IF_TRUE);
2121 case JUMP_IF_TRUE:
2122 w = TOP();
2123 if (w == Py_False) {
2124 PREDICT(POP_TOP);
2125 goto fast_next_opcode;
2126 }
2127 if (w == Py_True) {
2128 JUMPBY(oparg);
2129 goto fast_next_opcode;
2130 }
2131 err = PyObject_IsTrue(w);
2132 if (err > 0) {
2133 err = 0;
2134 JUMPBY(oparg);
2135 }
2136 else if (err == 0)
2137 ;
2138 else
2139 break;
2140 continue;
2141
2142 PREDICTED_WITH_ARG(JUMP_ABSOLUTE);
2143 case JUMP_ABSOLUTE:
2144 JUMPTO(oparg);
2145 continue;
2146
2147 case GET_ITER:
2148 /* before: [obj]; after [getiter(obj)] */
2149 v = TOP();
2150 x = PyObject_GetIter(v);
2151 Py_DECREF(v);
2152 if (x != NULL) {
2153 SET_TOP(x);
2154 PREDICT(FOR_ITER);
2155 continue;
2156 }
2157 STACKADJ(-1);
2158 break;
2159
2160 PREDICTED_WITH_ARG(FOR_ITER);
2161 case FOR_ITER:
2162 /* before: [iter]; after: [iter, iter()] *or* [] */
2163 v = TOP();
2164 x = (*v->ob_type->tp_iternext)(v);
2165 if (x != NULL) {
2166 PUSH(x);
2167 PREDICT(STORE_FAST);
2168 PREDICT(UNPACK_SEQUENCE);
2169 continue;
2170 }
2171 if (PyErr_Occurred()) {
2172 if (!PyErr_ExceptionMatches(PyExc_StopIteration))
2173 break;
2174 PyErr_Clear();
2175 }
2176 /* iterator ended normally */
2177 x = v = POP();
2178 Py_DECREF(v);
2179 JUMPBY(oparg);
2180 continue;
2181
2182 case BREAK_LOOP:
2183 why = WHY_BREAK;
2184 goto fast_block_end;
2185
2186 case CONTINUE_LOOP:
2187 retval = PyInt_FromLong(oparg);
2188 if (!retval) {
2189 x = NULL;
2190 break;
2191 }
2192 why = WHY_CONTINUE;
2193 goto fast_block_end;
2194
2195 case SETUP_LOOP:
2196 case SETUP_EXCEPT:
2197 case SETUP_FINALLY:
2198 /* NOTE: If you add any new block-setup opcodes that are not try/except/finally
2199 handlers, you may need to update the PyGen_NeedsFinalizing() function. */
2200
2201 PyFrame_BlockSetup(f, opcode, INSTR_OFFSET() + oparg,
2202 STACK_LEVEL());
2203 continue;
2204
2205 case WITH_CLEANUP:
2206 {
2207 /* TOP is the context.__exit__ bound method.
2208 Below that are 1-3 values indicating how/why
2209 we entered the finally clause:
2210 - SECOND = None
2211 - (SECOND, THIRD) = (WHY_{RETURN,CONTINUE}), retval
2212 - SECOND = WHY_*; no retval below it
2213 - (SECOND, THIRD, FOURTH) = exc_info()
2214 In the last case, we must call
2215 TOP(SECOND, THIRD, FOURTH)
2216 otherwise we must call
2217 TOP(None, None, None)
2218
2219 In addition, if the stack represents an exception,
2220 *and* the function call returns a 'true' value, we
2221 "zap" this information, to prevent END_FINALLY from
2222 re-raising the exception. (But non-local gotos
2223 should still be resumed.)
2224 */
2225
2226 x = TOP();
2227 u = SECOND();
2228 if (PyInt_Check(u) || u == Py_None) {
2229 u = v = w = Py_None;
2230 }
2231 else {
2232 v = THIRD();
2233 w = FOURTH();
2234 }
2235 /* XXX Not the fastest way to call it... */
2236 x = PyObject_CallFunctionObjArgs(x, u, v, w, NULL);
2237 if (x == NULL)
2238 break; /* Go to error exit */
2239 if (u != Py_None && PyObject_IsTrue(x)) {
2240 /* There was an exception and a true return */
2241 Py_DECREF(x);
2242 x = TOP(); /* Again */
2243 STACKADJ(-3);
2244 Py_INCREF(Py_None);
2245 SET_TOP(Py_None);
2246 Py_DECREF(x);
2247 Py_DECREF(u);
2248 Py_DECREF(v);
2249 Py_DECREF(w);
2250 } else {
2251 /* Let END_FINALLY do its thing */
2252 Py_DECREF(x);
2253 x = POP();
2254 Py_DECREF(x);
2255 }
2256 break;
2257 }
2258
2259 case CALL_FUNCTION:
2260 {
2261 PyObject **sp;
2262 PCALL(PCALL_ALL);
2263 sp = stack_pointer;
2264#ifdef WITH_TSC
2265 x = call_function(&sp, oparg, &intr0, &intr1);
2266#else
2267 x = call_function(&sp, oparg);
2268#endif
2269 stack_pointer = sp;
2270 PUSH(x);
2271 if (x != NULL)
2272 continue;
2273 break;
2274 }
2275
2276 case CALL_FUNCTION_VAR:
2277 case CALL_FUNCTION_KW:
2278 case CALL_FUNCTION_VAR_KW:
2279 {
2280 int na = oparg & 0xff;
2281 int nk = (oparg>>8) & 0xff;
2282 int flags = (opcode - CALL_FUNCTION) & 3;
2283 int n = na + 2 * nk;
2284 PyObject **pfunc, *func, **sp;
2285 PCALL(PCALL_ALL);
2286 if (flags & CALL_FLAG_VAR)
2287 n++;
2288 if (flags & CALL_FLAG_KW)
2289 n++;
2290 pfunc = stack_pointer - n - 1;
2291 func = *pfunc;
2292
2293 if (PyMethod_Check(func)
2294 && PyMethod_GET_SELF(func) != NULL) {
2295 PyObject *self = PyMethod_GET_SELF(func);
2296 Py_INCREF(self);
2297 func = PyMethod_GET_FUNCTION(func);
2298 Py_INCREF(func);
2299 Py_DECREF(*pfunc);
2300 *pfunc = self;
2301 na++;
2302 n++;
2303 } else
2304 Py_INCREF(func);
2305 sp = stack_pointer;
2306 READ_TIMESTAMP(intr0);
2307 x = ext_do_call(func, &sp, flags, na, nk);
2308 READ_TIMESTAMP(intr1);
2309 stack_pointer = sp;
2310 Py_DECREF(func);
2311
2312 while (stack_pointer > pfunc) {
2313 w = POP();
2314 Py_DECREF(w);
2315 }
2316 PUSH(x);
2317 if (x != NULL)
2318 continue;
2319 break;
2320 }
2321
2322 case MAKE_FUNCTION:
2323 v = POP(); /* code object */
2324 x = PyFunction_New(v, f->f_globals);
2325 Py_DECREF(v);
2326 /* XXX Maybe this should be a separate opcode? */
2327 if (x != NULL && oparg > 0) {
2328 v = PyTuple_New(oparg);
2329 if (v == NULL) {
2330 Py_DECREF(x);
2331 x = NULL;
2332 break;
2333 }
2334 while (--oparg >= 0) {
2335 w = POP();
2336 PyTuple_SET_ITEM(v, oparg, w);
2337 }
2338 err = PyFunction_SetDefaults(x, v);
2339 Py_DECREF(v);
2340 }
2341 PUSH(x);
2342 break;
2343
2344 case MAKE_CLOSURE:
2345 {
2346 v = POP(); /* code object */
2347 x = PyFunction_New(v, f->f_globals);
2348 Py_DECREF(v);
2349 if (x != NULL) {
2350 v = POP();
2351 err = PyFunction_SetClosure(x, v);
2352 Py_DECREF(v);
2353 }
2354 if (x != NULL && oparg > 0) {
2355 v = PyTuple_New(oparg);
2356 if (v == NULL) {
2357 Py_DECREF(x);
2358 x = NULL;
2359 break;
2360 }
2361 while (--oparg >= 0) {
2362 w = POP();
2363 PyTuple_SET_ITEM(v, oparg, w);
2364 }
2365 err = PyFunction_SetDefaults(x, v);
2366 Py_DECREF(v);
2367 }
2368 PUSH(x);
2369 break;
2370 }
2371
2372 case BUILD_SLICE:
2373 if (oparg == 3)
2374 w = POP();
2375 else
2376 w = NULL;
2377 v = POP();
2378 u = TOP();
2379 x = PySlice_New(u, v, w);
2380 Py_DECREF(u);
2381 Py_DECREF(v);
2382 Py_XDECREF(w);
2383 SET_TOP(x);
2384 if (x != NULL) continue;
2385 break;
2386
2387 case EXTENDED_ARG:
2388 opcode = NEXTOP();
2389 oparg = oparg<<16 | NEXTARG();
2390 goto dispatch_opcode;
2391
2392 default:
2393 fprintf(stderr,
2394 "XXX lineno: %d, opcode: %d\n",
2395 PyCode_Addr2Line(f->f_code, f->f_lasti),
2396 opcode);
2397 PyErr_SetString(PyExc_SystemError, "unknown opcode");
2398 why = WHY_EXCEPTION;
2399 break;
2400
2401#ifdef CASE_TOO_BIG
2402 }
2403#endif
2404
2405 } /* switch */
2406
2407 on_error:
2408
2409 READ_TIMESTAMP(inst1);
2410
2411 /* Quickly continue if no error occurred */
2412
2413 if (why == WHY_NOT) {
2414 if (err == 0 && x != NULL) {
2415#ifdef CHECKEXC
2416 /* This check is expensive! */
2417 if (PyErr_Occurred())
2418 fprintf(stderr,
2419 "XXX undetected error\n");
2420 else {
2421#endif
2422 READ_TIMESTAMP(loop1);
2423 continue; /* Normal, fast path */
2424#ifdef CHECKEXC
2425 }
2426#endif
2427 }
2428 why = WHY_EXCEPTION;
2429 x = Py_None;
2430 err = 0;
2431 }
2432
2433 /* Double-check exception status */
2434
2435 if (why == WHY_EXCEPTION || why == WHY_RERAISE) {
2436 if (!PyErr_Occurred()) {
2437 PyErr_SetString(PyExc_SystemError,
2438 "error return without exception set");
2439 why = WHY_EXCEPTION;
2440 }
2441 }
2442#ifdef CHECKEXC
2443 else {
2444 /* This check is expensive! */
2445 if (PyErr_Occurred()) {
2446 char buf[1024];
2447 sprintf(buf, "Stack unwind with exception "
2448 "set and why=%d", why);
2449 Py_FatalError(buf);
2450 }
2451 }
2452#endif
2453
2454 /* Log traceback info if this is a real exception */
2455
2456 if (why == WHY_EXCEPTION) {
2457 PyTraceBack_Here(f);
2458
2459 if (tstate->c_tracefunc != NULL)
2460 call_exc_trace(tstate->c_tracefunc,
2461 tstate->c_traceobj, f);
2462 }
2463
2464 /* For the rest, treat WHY_RERAISE as WHY_EXCEPTION */
2465
2466 if (why == WHY_RERAISE)
2467 why = WHY_EXCEPTION;
2468
2469 /* Unwind stacks if a (pseudo) exception occurred */
2470
2471fast_block_end:
2472 while (why != WHY_NOT && f->f_iblock > 0) {
2473 PyTryBlock *b = PyFrame_BlockPop(f);
2474
2475 assert(why != WHY_YIELD);
2476 if (b->b_type == SETUP_LOOP && why == WHY_CONTINUE) {
2477 /* For a continue inside a try block,
2478 don't pop the block for the loop. */
2479 PyFrame_BlockSetup(f, b->b_type, b->b_handler,
2480 b->b_level);
2481 why = WHY_NOT;
2482 JUMPTO(PyInt_AS_LONG(retval));
2483 Py_DECREF(retval);
2484 break;
2485 }
2486
2487 while (STACK_LEVEL() > b->b_level) {
2488 v = POP();
2489 Py_XDECREF(v);
2490 }
2491 if (b->b_type == SETUP_LOOP && why == WHY_BREAK) {
2492 why = WHY_NOT;
2493 JUMPTO(b->b_handler);
2494 break;
2495 }
2496 if (b->b_type == SETUP_FINALLY ||
2497 (b->b_type == SETUP_EXCEPT &&
2498 why == WHY_EXCEPTION)) {
2499 if (why == WHY_EXCEPTION) {
2500 PyObject *exc, *val, *tb;
2501 PyErr_Fetch(&exc, &val, &tb);
2502 if (val == NULL) {
2503 val = Py_None;
2504 Py_INCREF(val);
2505 }
2506 /* Make the raw exception data
2507 available to the handler,
2508 so a program can emulate the
2509 Python main loop. Don't do
2510 this for 'finally'. */
2511 if (b->b_type == SETUP_EXCEPT) {
2512 PyErr_NormalizeException(
2513 &exc, &val, &tb);
2514 set_exc_info(tstate,
2515 exc, val, tb);
2516 }
2517 if (tb == NULL) {
2518 Py_INCREF(Py_None);
2519 PUSH(Py_None);
2520 } else
2521 PUSH(tb);
2522 PUSH(val);
2523 PUSH(exc);
2524 }
2525 else {
2526 if (why & (WHY_RETURN | WHY_CONTINUE))
2527 PUSH(retval);
2528 v = PyInt_FromLong((long)why);
2529 PUSH(v);
2530 }
2531 why = WHY_NOT;
2532 JUMPTO(b->b_handler);
2533 break;
2534 }
2535 } /* unwind stack */
2536
2537 /* End the loop if we still have an error (or return) */
2538
2539 if (why != WHY_NOT)
2540 break;
2541 READ_TIMESTAMP(loop1);
2542
2543 } /* main loop */
2544
2545 assert(why != WHY_YIELD);
2546 /* Pop remaining stack entries. */
2547 while (!EMPTY()) {
2548 v = POP();
2549 Py_XDECREF(v);
2550 }
2551
2552 if (why != WHY_RETURN)
2553 retval = NULL;
2554
2555fast_yield:
2556 if (tstate->use_tracing) {
2557 if (tstate->c_tracefunc) {
2558 if (why == WHY_RETURN || why == WHY_YIELD) {
2559 if (call_trace(tstate->c_tracefunc,
2560 tstate->c_traceobj, f,
2561 PyTrace_RETURN, retval)) {
2562 Py_XDECREF(retval);
2563 retval = NULL;
2564 why = WHY_EXCEPTION;
2565 }
2566 }
2567 else if (why == WHY_EXCEPTION) {
2568 call_trace_protected(tstate->c_tracefunc,
2569 tstate->c_traceobj, f,
2570 PyTrace_RETURN, NULL);
2571 }
2572 }
2573 if (tstate->c_profilefunc) {
2574 if (why == WHY_EXCEPTION)
2575 call_trace_protected(tstate->c_profilefunc,
2576 tstate->c_profileobj, f,
2577 PyTrace_RETURN, NULL);
2578 else if (call_trace(tstate->c_profilefunc,
2579 tstate->c_profileobj, f,
2580 PyTrace_RETURN, retval)) {
2581 Py_XDECREF(retval);
2582 retval = NULL;
2583 why = WHY_EXCEPTION;
2584 }
2585 }
2586 }
2587
2588 if (tstate->frame->f_exc_type != NULL)
2589 reset_exc_info(tstate);
2590 else {
2591 assert(tstate->frame->f_exc_value == NULL);
2592 assert(tstate->frame->f_exc_traceback == NULL);
2593 }
2594
2595 /* pop frame */
2596 exit_eval_frame:
2597 Py_LeaveRecursiveCall();
2598 tstate->frame = f->f_back;
2599
2600 return retval;
2601}
2602
2603/* This is gonna seem *real weird*, but if you put some other code between
2604 PyEval_EvalFrame() and PyEval_EvalCodeEx() you will need to adjust
2605 the test in the if statements in Misc/gdbinit (pystack and pystackv). */
2606
2607PyObject *
2608PyEval_EvalCodeEx(PyCodeObject *co, PyObject *globals, PyObject *locals,
2609 PyObject **args, int argcount, PyObject **kws, int kwcount,
2610 PyObject **defs, int defcount, PyObject *closure)
2611{
2612 register PyFrameObject *f;
2613 register PyObject *retval = NULL;
2614 register PyObject **fastlocals, **freevars;
2615 PyThreadState *tstate = PyThreadState_GET();
2616 PyObject *x, *u;
2617
2618 if (globals == NULL) {
2619 PyErr_SetString(PyExc_SystemError,
2620 "PyEval_EvalCodeEx: NULL globals");
2621 return NULL;
2622 }
2623
2624 assert(tstate != NULL);
2625 assert(globals != NULL);
2626 f = PyFrame_New(tstate, co, globals, locals);
2627 if (f == NULL)
2628 return NULL;
2629
2630 fastlocals = f->f_localsplus;
2631 freevars = f->f_localsplus + co->co_nlocals;
2632
2633 if (co->co_argcount > 0 ||
2634 co->co_flags & (CO_VARARGS | CO_VARKEYWORDS)) {
2635 int i;
2636 int n = argcount;
2637 PyObject *kwdict = NULL;
2638 if (co->co_flags & CO_VARKEYWORDS) {
2639 kwdict = PyDict_New();
2640 if (kwdict == NULL)
2641 goto fail;
2642 i = co->co_argcount;
2643 if (co->co_flags & CO_VARARGS)
2644 i++;
2645 SETLOCAL(i, kwdict);
2646 }
2647 if (argcount > co->co_argcount) {
2648 if (!(co->co_flags & CO_VARARGS)) {
2649 PyErr_Format(PyExc_TypeError,
2650 "%.200s() takes %s %d "
2651 "%sargument%s (%d given)",
2652 PyString_AsString(co->co_name),
2653 defcount ? "at most" : "exactly",
2654 co->co_argcount,
2655 kwcount ? "non-keyword " : "",
2656 co->co_argcount == 1 ? "" : "s",
2657 argcount);
2658 goto fail;
2659 }
2660 n = co->co_argcount;
2661 }
2662 for (i = 0; i < n; i++) {
2663 x = args[i];
2664 Py_INCREF(x);
2665 SETLOCAL(i, x);
2666 }
2667 if (co->co_flags & CO_VARARGS) {
2668 u = PyTuple_New(argcount - n);
2669 if (u == NULL)
2670 goto fail;
2671 SETLOCAL(co->co_argcount, u);
2672 for (i = n; i < argcount; i++) {
2673 x = args[i];
2674 Py_INCREF(x);
2675 PyTuple_SET_ITEM(u, i-n, x);
2676 }
2677 }
2678 for (i = 0; i < kwcount; i++) {
2679 PyObject *keyword = kws[2*i];
2680 PyObject *value = kws[2*i + 1];
2681 int j;
2682 if (keyword == NULL || !PyString_Check(keyword)) {
2683 PyErr_Format(PyExc_TypeError,
2684 "%.200s() keywords must be strings",
2685 PyString_AsString(co->co_name));
2686 goto fail;
2687 }
2688 /* XXX slow -- speed up using dictionary? */
2689 for (j = 0; j < co->co_argcount; j++) {
2690 PyObject *nm = PyTuple_GET_ITEM(
2691 co->co_varnames, j);
2692 int cmp = PyObject_RichCompareBool(
2693 keyword, nm, Py_EQ);
2694 if (cmp > 0)
2695 break;
2696 else if (cmp < 0)
2697 goto fail;
2698 }
2699 /* Check errors from Compare */
2700 if (PyErr_Occurred())
2701 goto fail;
2702 if (j >= co->co_argcount) {
2703 if (kwdict == NULL) {
2704 PyErr_Format(PyExc_TypeError,
2705 "%.200s() got an unexpected "
2706 "keyword argument '%.400s'",
2707 PyString_AsString(co->co_name),
2708 PyString_AsString(keyword));
2709 goto fail;
2710 }
2711 PyDict_SetItem(kwdict, keyword, value);
2712 }
2713 else {
2714 if (GETLOCAL(j) != NULL) {
2715 PyErr_Format(PyExc_TypeError,
2716 "%.200s() got multiple "
2717 "values for keyword "
2718 "argument '%.400s'",
2719 PyString_AsString(co->co_name),
2720 PyString_AsString(keyword));
2721 goto fail;
2722 }
2723 Py_INCREF(value);
2724 SETLOCAL(j, value);
2725 }
2726 }
2727 if (argcount < co->co_argcount) {
2728 int m = co->co_argcount - defcount;
2729 for (i = argcount; i < m; i++) {
2730 if (GETLOCAL(i) == NULL) {
2731 PyErr_Format(PyExc_TypeError,
2732 "%.200s() takes %s %d "
2733 "%sargument%s (%d given)",
2734 PyString_AsString(co->co_name),
2735 ((co->co_flags & CO_VARARGS) ||
2736 defcount) ? "at least"
2737 : "exactly",
2738 m, kwcount ? "non-keyword " : "",
2739 m == 1 ? "" : "s", i);
2740 goto fail;
2741 }
2742 }
2743 if (n > m)
2744 i = n - m;
2745 else
2746 i = 0;
2747 for (; i < defcount; i++) {
2748 if (GETLOCAL(m+i) == NULL) {
2749 PyObject *def = defs[i];
2750 Py_INCREF(def);
2751 SETLOCAL(m+i, def);
2752 }
2753 }
2754 }
2755 }
2756 else {
2757 if (argcount > 0 || kwcount > 0) {
2758 PyErr_Format(PyExc_TypeError,
2759 "%.200s() takes no arguments (%d given)",
2760 PyString_AsString(co->co_name),
2761 argcount + kwcount);
2762 goto fail;
2763 }
2764 }
2765 /* Allocate and initialize storage for cell vars, and copy free
2766 vars into frame. This isn't too efficient right now. */
2767 if (PyTuple_GET_SIZE(co->co_cellvars)) {
2768 int i, j, nargs, found;
2769 char *cellname, *argname;
2770 PyObject *c;
2771
2772 nargs = co->co_argcount;
2773 if (co->co_flags & CO_VARARGS)
2774 nargs++;
2775 if (co->co_flags & CO_VARKEYWORDS)
2776 nargs++;
2777
2778 /* Initialize each cell var, taking into account
2779 cell vars that are initialized from arguments.
2780
2781 Should arrange for the compiler to put cellvars
2782 that are arguments at the beginning of the cellvars
2783 list so that we can march over it more efficiently?
2784 */
2785 for (i = 0; i < PyTuple_GET_SIZE(co->co_cellvars); ++i) {
2786 cellname = PyString_AS_STRING(
2787 PyTuple_GET_ITEM(co->co_cellvars, i));
2788 found = 0;
2789 for (j = 0; j < nargs; j++) {
2790 argname = PyString_AS_STRING(
2791 PyTuple_GET_ITEM(co->co_varnames, j));
2792 if (strcmp(cellname, argname) == 0) {
2793 c = PyCell_New(GETLOCAL(j));
2794 if (c == NULL)
2795 goto fail;
2796 GETLOCAL(co->co_nlocals + i) = c;
2797 found = 1;
2798 break;
2799 }
2800 }
2801 if (found == 0) {
2802 c = PyCell_New(NULL);
2803 if (c == NULL)
2804 goto fail;
2805 SETLOCAL(co->co_nlocals + i, c);
2806 }
2807 }
2808 }
2809 if (PyTuple_GET_SIZE(co->co_freevars)) {
2810 int i;
2811 for (i = 0; i < PyTuple_GET_SIZE(co->co_freevars); ++i) {
2812 PyObject *o = PyTuple_GET_ITEM(closure, i);
2813 Py_INCREF(o);
2814 freevars[PyTuple_GET_SIZE(co->co_cellvars) + i] = o;
2815 }
2816 }
2817
2818 if (co->co_flags & CO_GENERATOR) {
2819 /* Don't need to keep the reference to f_back, it will be set
2820 * when the generator is resumed. */
2821 Py_XDECREF(f->f_back);
2822 f->f_back = NULL;
2823
2824 PCALL(PCALL_GENERATOR);
2825
2826 /* Create a new generator that owns the ready to run frame
2827 * and return that as the value. */
2828 return PyGen_New(f);
2829 }
2830
2831 retval = PyEval_EvalFrameEx(f,0);
2832
2833 fail: /* Jump here from prelude on failure */
2834
2835 /* decref'ing the frame can cause __del__ methods to get invoked,
2836 which can call back into Python. While we're done with the
2837 current Python frame (f), the associated C stack is still in use,
2838 so recursion_depth must be boosted for the duration.
2839 */
2840 assert(tstate != NULL);
2841 ++tstate->recursion_depth;
2842 Py_DECREF(f);
2843 --tstate->recursion_depth;
2844 return retval;
2845}
2846
2847
2848/* Implementation notes for set_exc_info() and reset_exc_info():
2849
2850- Below, 'exc_ZZZ' stands for 'exc_type', 'exc_value' and
2851 'exc_traceback'. These always travel together.
2852
2853- tstate->curexc_ZZZ is the "hot" exception that is set by
2854 PyErr_SetString(), cleared by PyErr_Clear(), and so on.
2855
2856- Once an exception is caught by an except clause, it is transferred
2857 from tstate->curexc_ZZZ to tstate->exc_ZZZ, from which sys.exc_info()
2858 can pick it up. This is the primary task of set_exc_info().
2859 XXX That can't be right: set_exc_info() doesn't look at tstate->curexc_ZZZ.
2860
2861- Now let me explain the complicated dance with frame->f_exc_ZZZ.
2862
2863 Long ago, when none of this existed, there were just a few globals:
2864 one set corresponding to the "hot" exception, and one set
2865 corresponding to sys.exc_ZZZ. (Actually, the latter weren't C
2866 globals; they were simply stored as sys.exc_ZZZ. For backwards
2867 compatibility, they still are!) The problem was that in code like
2868 this:
2869
2870 try:
2871 "something that may fail"
2872 except "some exception":
2873 "do something else first"
2874 "print the exception from sys.exc_ZZZ."
2875
2876 if "do something else first" invoked something that raised and caught
2877 an exception, sys.exc_ZZZ were overwritten. That was a frequent
2878 cause of subtle bugs. I fixed this by changing the semantics as
2879 follows:
2880
2881 - Within one frame, sys.exc_ZZZ will hold the last exception caught
2882 *in that frame*.
2883
2884 - But initially, and as long as no exception is caught in a given
2885 frame, sys.exc_ZZZ will hold the last exception caught in the
2886 previous frame (or the frame before that, etc.).
2887
2888 The first bullet fixed the bug in the above example. The second
2889 bullet was for backwards compatibility: it was (and is) common to
2890 have a function that is called when an exception is caught, and to
2891 have that function access the caught exception via sys.exc_ZZZ.
2892 (Example: traceback.print_exc()).
2893
2894 At the same time I fixed the problem that sys.exc_ZZZ weren't
2895 thread-safe, by introducing sys.exc_info() which gets it from tstate;
2896 but that's really a separate improvement.
2897
2898 The reset_exc_info() function in ceval.c restores the tstate->exc_ZZZ
2899 variables to what they were before the current frame was called. The
2900 set_exc_info() function saves them on the frame so that
2901 reset_exc_info() can restore them. The invariant is that
2902 frame->f_exc_ZZZ is NULL iff the current frame never caught an
2903 exception (where "catching" an exception applies only to successful
2904 except clauses); and if the current frame ever caught an exception,
2905 frame->f_exc_ZZZ is the exception that was stored in tstate->exc_ZZZ
2906 at the start of the current frame.
2907
2908*/
2909
2910static void
2911set_exc_info(PyThreadState *tstate,
2912 PyObject *type, PyObject *value, PyObject *tb)
2913{
2914 PyFrameObject *frame = tstate->frame;
2915 PyObject *tmp_type, *tmp_value, *tmp_tb;
2916
2917 assert(type != NULL);
2918 assert(frame != NULL);
2919 if (frame->f_exc_type == NULL) {
2920 assert(frame->f_exc_value == NULL);
2921 assert(frame->f_exc_traceback == NULL);
2922 /* This frame didn't catch an exception before. */
2923 /* Save previous exception of this thread in this frame. */
2924 if (tstate->exc_type == NULL) {
2925 /* XXX Why is this set to Py_None? */
2926 Py_INCREF(Py_None);
2927 tstate->exc_type = Py_None;
2928 }
2929 Py_INCREF(tstate->exc_type);
2930 Py_XINCREF(tstate->exc_value);
2931 Py_XINCREF(tstate->exc_traceback);
2932 frame->f_exc_type = tstate->exc_type;
2933 frame->f_exc_value = tstate->exc_value;
2934 frame->f_exc_traceback = tstate->exc_traceback;
2935 }
2936 /* Set new exception for this thread. */
2937 tmp_type = tstate->exc_type;
2938 tmp_value = tstate->exc_value;
2939 tmp_tb = tstate->exc_traceback;
2940 Py_INCREF(type);
2941 Py_XINCREF(value);
2942 Py_XINCREF(tb);
2943 tstate->exc_type = type;
2944 tstate->exc_value = value;
2945 tstate->exc_traceback = tb;
2946 Py_XDECREF(tmp_type);
2947 Py_XDECREF(tmp_value);
2948 Py_XDECREF(tmp_tb);
2949 /* For b/w compatibility */
2950 PySys_SetObject("exc_type", type);
2951 PySys_SetObject("exc_value", value);
2952 PySys_SetObject("exc_traceback", tb);
2953}
2954
2955static void
2956reset_exc_info(PyThreadState *tstate)
2957{
2958 PyFrameObject *frame;
2959 PyObject *tmp_type, *tmp_value, *tmp_tb;
2960
2961 /* It's a precondition that the thread state's frame caught an
2962 * exception -- verify in a debug build.
2963 */
2964 assert(tstate != NULL);
2965 frame = tstate->frame;
2966 assert(frame != NULL);
2967 assert(frame->f_exc_type != NULL);
2968
2969 /* Copy the frame's exception info back to the thread state. */
2970 tmp_type = tstate->exc_type;
2971 tmp_value = tstate->exc_value;
2972 tmp_tb = tstate->exc_traceback;
2973 Py_INCREF(frame->f_exc_type);
2974 Py_XINCREF(frame->f_exc_value);
2975 Py_XINCREF(frame->f_exc_traceback);
2976 tstate->exc_type = frame->f_exc_type;
2977 tstate->exc_value = frame->f_exc_value;
2978 tstate->exc_traceback = frame->f_exc_traceback;
2979 Py_XDECREF(tmp_type);
2980 Py_XDECREF(tmp_value);
2981 Py_XDECREF(tmp_tb);
2982
2983 /* For b/w compatibility */
2984 PySys_SetObject("exc_type", frame->f_exc_type);
2985 PySys_SetObject("exc_value", frame->f_exc_value);
2986 PySys_SetObject("exc_traceback", frame->f_exc_traceback);
2987
2988 /* Clear the frame's exception info. */
2989 tmp_type = frame->f_exc_type;
2990 tmp_value = frame->f_exc_value;
2991 tmp_tb = frame->f_exc_traceback;
2992 frame->f_exc_type = NULL;
2993 frame->f_exc_value = NULL;
2994 frame->f_exc_traceback = NULL;
2995 Py_DECREF(tmp_type);
2996 Py_XDECREF(tmp_value);
2997 Py_XDECREF(tmp_tb);
2998}
2999
3000/* Logic for the raise statement (too complicated for inlining).
3001 This *consumes* a reference count to each of its arguments. */
3002static enum why_code
3003do_raise(PyObject *type, PyObject *value, PyObject *tb)
3004{
3005 if (type == NULL) {
3006 /* Reraise */
3007 PyThreadState *tstate = PyThreadState_GET();
3008 type = tstate->exc_type == NULL ? Py_None : tstate->exc_type;
3009 value = tstate->exc_value;
3010 tb = tstate->exc_traceback;
3011 Py_XINCREF(type);
3012 Py_XINCREF(value);
3013 Py_XINCREF(tb);
3014 }
3015
3016 /* We support the following forms of raise:
3017 raise <class>, <classinstance>
3018 raise <class>, <argument tuple>
3019 raise <class>, None
3020 raise <class>, <argument>
3021 raise <classinstance>, None
3022 raise <string>, <object>
3023 raise <string>, None
3024
3025 An omitted second argument is the same as None.
3026
3027 In addition, raise <tuple>, <anything> is the same as
3028 raising the tuple's first item (and it better have one!);
3029 this rule is applied recursively.
3030
3031 Finally, an optional third argument can be supplied, which
3032 gives the traceback to be substituted (useful when
3033 re-raising an exception after examining it). */
3034
3035 /* First, check the traceback argument, replacing None with
3036 NULL. */
3037 if (tb == Py_None) {
3038 Py_DECREF(tb);
3039 tb = NULL;
3040 }
3041 else if (tb != NULL && !PyTraceBack_Check(tb)) {
3042 PyErr_SetString(PyExc_TypeError,
3043 "raise: arg 3 must be a traceback or None");
3044 goto raise_error;
3045 }
3046
3047 /* Next, replace a missing value with None */
3048 if (value == NULL) {
3049 value = Py_None;
3050 Py_INCREF(value);
3051 }
3052
3053 /* Next, repeatedly, replace a tuple exception with its first item */
3054 while (PyTuple_Check(type) && PyTuple_Size(type) > 0) {
3055 PyObject *tmp = type;
3056 type = PyTuple_GET_ITEM(type, 0);
3057 Py_INCREF(type);
3058 Py_DECREF(tmp);
3059 }
3060
3061 if (PyString_CheckExact(type)) {
3062 /* Raising builtin string is deprecated but still allowed --
3063 * do nothing. Raising an instance of a new-style str
3064 * subclass is right out. */
3065 if (PyErr_Warn(PyExc_DeprecationWarning,
3066 "raising a string exception is deprecated"))
3067 goto raise_error;
3068 }
3069 else if (PyExceptionClass_Check(type))
3070 PyErr_NormalizeException(&type, &value, &tb);
3071
3072 else if (PyExceptionInstance_Check(type)) {
3073 /* Raising an instance. The value should be a dummy. */
3074 if (value != Py_None) {
3075 PyErr_SetString(PyExc_TypeError,
3076 "instance exception may not have a separate value");
3077 goto raise_error;
3078 }
3079 else {
3080 /* Normalize to raise <class>, <instance> */
3081 Py_DECREF(value);
3082 value = type;
3083 type = PyExceptionInstance_Class(type);
3084 Py_INCREF(type);
3085 }
3086 }
3087 else {
3088 /* Not something you can raise. You get an exception
3089 anyway, just not what you specified :-) */
3090 PyErr_Format(PyExc_TypeError,
3091 "exceptions must be classes, instances, or "
3092 "strings (deprecated), not %s",
3093 type->ob_type->tp_name);
3094 goto raise_error;
3095 }
3096 PyErr_Restore(type, value, tb);
3097 if (tb == NULL)
3098 return WHY_EXCEPTION;
3099 else
3100 return WHY_RERAISE;
3101 raise_error:
3102 Py_XDECREF(value);
3103 Py_XDECREF(type);
3104 Py_XDECREF(tb);
3105 return WHY_EXCEPTION;
3106}
3107
3108/* Iterate v argcnt times and store the results on the stack (via decreasing
3109 sp). Return 1 for success, 0 if error. */
3110
3111static int
3112unpack_iterable(PyObject *v, int argcnt, PyObject **sp)
3113{
3114 int i = 0;
3115 PyObject *it; /* iter(v) */
3116 PyObject *w;
3117
3118 assert(v != NULL);
3119
3120 it = PyObject_GetIter(v);
3121 if (it == NULL)
3122 goto Error;
3123
3124 for (; i < argcnt; i++) {
3125 w = PyIter_Next(it);
3126 if (w == NULL) {
3127 /* Iterator done, via error or exhaustion. */
3128 if (!PyErr_Occurred()) {
3129 PyErr_Format(PyExc_ValueError,
3130 "need more than %d value%s to unpack",
3131 i, i == 1 ? "" : "s");
3132 }
3133 goto Error;
3134 }
3135 *--sp = w;
3136 }
3137
3138 /* We better have exhausted the iterator now. */
3139 w = PyIter_Next(it);
3140 if (w == NULL) {
3141 if (PyErr_Occurred())
3142 goto Error;
3143 Py_DECREF(it);
3144 return 1;
3145 }
3146 Py_DECREF(w);
3147 PyErr_SetString(PyExc_ValueError, "too many values to unpack");
3148 /* fall through */
3149Error:
3150 for (; i > 0; i--, sp++)
3151 Py_DECREF(*sp);
3152 Py_XDECREF(it);
3153 return 0;
3154}
3155
3156
3157#ifdef LLTRACE
3158static int
3159prtrace(PyObject *v, char *str)
3160{
3161 printf("%s ", str);
3162 if (PyObject_Print(v, stdout, 0) != 0)
3163 PyErr_Clear(); /* Don't know what else to do */
3164 printf("\n");
3165 return 1;
3166}
3167#endif
3168
3169static void
3170call_exc_trace(Py_tracefunc func, PyObject *self, PyFrameObject *f)
3171{
3172 PyObject *type, *value, *traceback, *arg;
3173 int err;
3174 PyErr_Fetch(&type, &value, &traceback);
3175 if (value == NULL) {
3176 value = Py_None;
3177 Py_INCREF(value);
3178 }
3179 arg = PyTuple_Pack(3, type, value, traceback);
3180 if (arg == NULL) {
3181 PyErr_Restore(type, value, traceback);
3182 return;
3183 }
3184 err = call_trace(func, self, f, PyTrace_EXCEPTION, arg);
3185 Py_DECREF(arg);
3186 if (err == 0)
3187 PyErr_Restore(type, value, traceback);
3188 else {
3189 Py_XDECREF(type);
3190 Py_XDECREF(value);
3191 Py_XDECREF(traceback);
3192 }
3193}
3194
3195static void
3196call_trace_protected(Py_tracefunc func, PyObject *obj, PyFrameObject *frame,
3197 int what, PyObject *arg)
3198{
3199 PyObject *type, *value, *traceback;
3200 int err;
3201 PyErr_Fetch(&type, &value, &traceback);
3202 err = call_trace(func, obj, frame, what, arg);
3203 if (err == 0)
3204 PyErr_Restore(type, value, traceback);
3205 else {
3206 Py_XDECREF(type);
3207 Py_XDECREF(value);
3208 Py_XDECREF(traceback);
3209 }
3210}
3211
3212static int
3213call_trace(Py_tracefunc func, PyObject *obj, PyFrameObject *frame,
3214 int what, PyObject *arg)
3215{
3216 register PyThreadState *tstate = frame->f_tstate;
3217 int result;
3218 if (tstate->tracing)
3219 return 0;
3220 tstate->tracing++;
3221 tstate->use_tracing = 0;
3222 result = func(obj, frame, what, arg);
3223 tstate->use_tracing = ((tstate->c_tracefunc != NULL)
3224 || (tstate->c_profilefunc != NULL));
3225 tstate->tracing--;
3226 return result;
3227}
3228
3229PyObject *
3230_PyEval_CallTracing(PyObject *func, PyObject *args)
3231{
3232 PyFrameObject *frame = PyEval_GetFrame();
3233 PyThreadState *tstate = frame->f_tstate;
3234 int save_tracing = tstate->tracing;
3235 int save_use_tracing = tstate->use_tracing;
3236 PyObject *result;
3237
3238 tstate->tracing = 0;
3239 tstate->use_tracing = ((tstate->c_tracefunc != NULL)
3240 || (tstate->c_profilefunc != NULL));
3241 result = PyObject_Call(func, args, NULL);
3242 tstate->tracing = save_tracing;
3243 tstate->use_tracing = save_use_tracing;
3244 return result;
3245}
3246
3247static int
3248maybe_call_line_trace(Py_tracefunc func, PyObject *obj,
3249 PyFrameObject *frame, int *instr_lb, int *instr_ub,
3250 int *instr_prev)
3251{
3252 int result = 0;
3253
3254 /* If the last instruction executed isn't in the current
3255 instruction window, reset the window. If the last
3256 instruction happens to fall at the start of a line or if it
3257 represents a jump backwards, call the trace function.
3258 */
3259 if ((frame->f_lasti < *instr_lb || frame->f_lasti >= *instr_ub)) {
3260 int line;
3261 PyAddrPair bounds;
3262
3263 line = PyCode_CheckLineNumber(frame->f_code, frame->f_lasti,
3264 &bounds);
3265 if (line >= 0) {
3266 frame->f_lineno = line;
3267 result = call_trace(func, obj, frame,
3268 PyTrace_LINE, Py_None);
3269 }
3270 *instr_lb = bounds.ap_lower;
3271 *instr_ub = bounds.ap_upper;
3272 }
3273 else if (frame->f_lasti <= *instr_prev) {
3274 result = call_trace(func, obj, frame, PyTrace_LINE, Py_None);
3275 }
3276 *instr_prev = frame->f_lasti;
3277 return result;
3278}
3279
3280void
3281PyEval_SetProfile(Py_tracefunc func, PyObject *arg)
3282{
3283 PyThreadState *tstate = PyThreadState_GET();
3284 PyObject *temp = tstate->c_profileobj;
3285 Py_XINCREF(arg);
3286 tstate->c_profilefunc = NULL;
3287 tstate->c_profileobj = NULL;
3288 /* Must make sure that tracing is not ignored if 'temp' is freed */
3289 tstate->use_tracing = tstate->c_tracefunc != NULL;
3290 Py_XDECREF(temp);
3291 tstate->c_profilefunc = func;
3292 tstate->c_profileobj = arg;
3293 /* Flag that tracing or profiling is turned on */
3294 tstate->use_tracing = (func != NULL) || (tstate->c_tracefunc != NULL);
3295}
3296
3297void
3298PyEval_SetTrace(Py_tracefunc func, PyObject *arg)
3299{
3300 PyThreadState *tstate = PyThreadState_GET();
3301 PyObject *temp = tstate->c_traceobj;
3302 Py_XINCREF(arg);
3303 tstate->c_tracefunc = NULL;
3304 tstate->c_traceobj = NULL;
3305 /* Must make sure that profiling is not ignored if 'temp' is freed */
3306 tstate->use_tracing = tstate->c_profilefunc != NULL;
3307 Py_XDECREF(temp);
3308 tstate->c_tracefunc = func;
3309 tstate->c_traceobj = arg;
3310 /* Flag that tracing or profiling is turned on */
3311 tstate->use_tracing = ((func != NULL)
3312 || (tstate->c_profilefunc != NULL));
3313}
3314
3315PyObject *
3316PyEval_GetBuiltins(void)
3317{
3318 PyFrameObject *current_frame = PyEval_GetFrame();
3319 if (current_frame == NULL)
3320 return PyThreadState_GET()->interp->builtins;
3321 else
3322 return current_frame->f_builtins;
3323}
3324
3325PyObject *
3326PyEval_GetLocals(void)
3327{
3328 PyFrameObject *current_frame = PyEval_GetFrame();
3329 if (current_frame == NULL)
3330 return NULL;
3331 PyFrame_FastToLocals(current_frame);
3332 return current_frame->f_locals;
3333}
3334
3335PyObject *
3336PyEval_GetGlobals(void)
3337{
3338 PyFrameObject *current_frame = PyEval_GetFrame();
3339 if (current_frame == NULL)
3340 return NULL;
3341 else
3342 return current_frame->f_globals;
3343}
3344
3345PyFrameObject *
3346PyEval_GetFrame(void)
3347{
3348 PyThreadState *tstate = PyThreadState_GET();
3349 return _PyThreadState_GetFrame(tstate);
3350}
3351
3352int
3353PyEval_GetRestricted(void)
3354{
3355 PyFrameObject *current_frame = PyEval_GetFrame();
3356 return current_frame == NULL ? 0 : PyFrame_IsRestricted(current_frame);
3357}
3358
3359int
3360PyEval_MergeCompilerFlags(PyCompilerFlags *cf)
3361{
3362 PyFrameObject *current_frame = PyEval_GetFrame();
3363 int result = cf->cf_flags != 0;
3364
3365 if (current_frame != NULL) {
3366 const int codeflags = current_frame->f_code->co_flags;
3367 const int compilerflags = codeflags & PyCF_MASK;
3368 if (compilerflags) {
3369 result = 1;
3370 cf->cf_flags |= compilerflags;
3371 }
3372#if 0 /* future keyword */
3373 if (codeflags & CO_GENERATOR_ALLOWED) {
3374 result = 1;
3375 cf->cf_flags |= CO_GENERATOR_ALLOWED;
3376 }
3377#endif
3378 }
3379 return result;
3380}
3381
3382int
3383Py_FlushLine(void)
3384{
3385 PyObject *f = PySys_GetObject("stdout");
3386 if (f == NULL)
3387 return 0;
3388 if (!PyFile_SoftSpace(f, 0))
3389 return 0;
3390 return PyFile_WriteString("\n", f);
3391}
3392
3393
3394/* External interface to call any callable object.
3395 The arg must be a tuple or NULL. */
3396
3397#undef PyEval_CallObject
3398/* for backward compatibility: export this interface */
3399
3400PyObject *
3401PyEval_CallObject(PyObject *func, PyObject *arg)
3402{
3403 return PyEval_CallObjectWithKeywords(func, arg, (PyObject *)NULL);
3404}
3405#define PyEval_CallObject(func,arg) \
3406 PyEval_CallObjectWithKeywords(func, arg, (PyObject *)NULL)
3407
3408PyObject *
3409PyEval_CallObjectWithKeywords(PyObject *func, PyObject *arg, PyObject *kw)
3410{
3411 PyObject *result;
3412
3413 if (arg == NULL) {
3414 arg = PyTuple_New(0);
3415 if (arg == NULL)
3416 return NULL;
3417 }
3418 else if (!PyTuple_Check(arg)) {
3419 PyErr_SetString(PyExc_TypeError,
3420 "argument list must be a tuple");
3421 return NULL;
3422 }
3423 else
3424 Py_INCREF(arg);
3425
3426 if (kw != NULL && !PyDict_Check(kw)) {
3427 PyErr_SetString(PyExc_TypeError,
3428 "keyword list must be a dictionary");
3429 Py_DECREF(arg);
3430 return NULL;
3431 }
3432
3433 result = PyObject_Call(func, arg, kw);
3434 Py_DECREF(arg);
3435 return result;
3436}
3437
3438const char *
3439PyEval_GetFuncName(PyObject *func)
3440{
3441 if (PyMethod_Check(func))
3442 return PyEval_GetFuncName(PyMethod_GET_FUNCTION(func));
3443 else if (PyFunction_Check(func))
3444 return PyString_AsString(((PyFunctionObject*)func)->func_name);
3445 else if (PyCFunction_Check(func))
3446 return ((PyCFunctionObject*)func)->m_ml->ml_name;
3447 else if (PyClass_Check(func))
3448 return PyString_AsString(((PyClassObject*)func)->cl_name);
3449 else if (PyInstance_Check(func)) {
3450 return PyString_AsString(
3451 ((PyInstanceObject*)func)->in_class->cl_name);
3452 } else {
3453 return func->ob_type->tp_name;
3454 }
3455}
3456
3457const char *
3458PyEval_GetFuncDesc(PyObject *func)
3459{
3460 if (PyMethod_Check(func))
3461 return "()";
3462 else if (PyFunction_Check(func))
3463 return "()";
3464 else if (PyCFunction_Check(func))
3465 return "()";
3466 else if (PyClass_Check(func))
3467 return " constructor";
3468 else if (PyInstance_Check(func)) {
3469 return " instance";
3470 } else {
3471 return " object";
3472 }
3473}
3474
3475static void
3476err_args(PyObject *func, int flags, int nargs)
3477{
3478 if (flags & METH_NOARGS)
3479 PyErr_Format(PyExc_TypeError,
3480 "%.200s() takes no arguments (%d given)",
3481 ((PyCFunctionObject *)func)->m_ml->ml_name,
3482 nargs);
3483 else
3484 PyErr_Format(PyExc_TypeError,
3485 "%.200s() takes exactly one argument (%d given)",
3486 ((PyCFunctionObject *)func)->m_ml->ml_name,
3487 nargs);
3488}
3489
3490#define C_TRACE(x, call) \
3491if (tstate->use_tracing && tstate->c_profilefunc) { \
3492 if (call_trace(tstate->c_profilefunc, \
3493 tstate->c_profileobj, \
3494 tstate->frame, PyTrace_C_CALL, \
3495 func)) { \
3496 x = NULL; \
3497 } \
3498 else { \
3499 x = call; \
3500 if (tstate->c_profilefunc != NULL) { \
3501 if (x == NULL) { \
3502 call_trace_protected(tstate->c_profilefunc, \
3503 tstate->c_profileobj, \
3504 tstate->frame, PyTrace_C_EXCEPTION, \
3505 func); \
3506 /* XXX should pass (type, value, tb) */ \
3507 } else { \
3508 if (call_trace(tstate->c_profilefunc, \
3509 tstate->c_profileobj, \
3510 tstate->frame, PyTrace_C_RETURN, \
3511 func)) { \
3512 Py_DECREF(x); \
3513 x = NULL; \
3514 } \
3515 } \
3516 } \
3517 } \
3518} else { \
3519 x = call; \
3520 }
3521
3522static PyObject *
3523call_function(PyObject ***pp_stack, int oparg
3524#ifdef WITH_TSC
3525 , uint64* pintr0, uint64* pintr1
3526#endif
3527 )
3528{
3529 int na = oparg & 0xff;
3530 int nk = (oparg>>8) & 0xff;
3531 int n = na + 2 * nk;
3532 PyObject **pfunc = (*pp_stack) - n - 1;
3533 PyObject *func = *pfunc;
3534 PyObject *x, *w;
3535
3536 /* Always dispatch PyCFunction first, because these are
3537 presumed to be the most frequent callable object.
3538 */
3539 if (PyCFunction_Check(func) && nk == 0) {
3540 int flags = PyCFunction_GET_FLAGS(func);
3541 PyThreadState *tstate = PyThreadState_GET();
3542
3543 PCALL(PCALL_CFUNCTION);
3544 if (flags & (METH_NOARGS | METH_O)) {
3545 PyCFunction meth = PyCFunction_GET_FUNCTION(func);
3546 PyObject *self = PyCFunction_GET_SELF(func);
3547 if (flags & METH_NOARGS && na == 0) {
3548 C_TRACE(x, (*meth)(self,NULL));
3549 }
3550 else if (flags & METH_O && na == 1) {
3551 PyObject *arg = EXT_POP(*pp_stack);
3552 C_TRACE(x, (*meth)(self,arg));
3553 Py_DECREF(arg);
3554 }
3555 else {
3556 err_args(func, flags, na);
3557 x = NULL;
3558 }
3559 }
3560 else {
3561 PyObject *callargs;
3562 callargs = load_args(pp_stack, na);
3563 READ_TIMESTAMP(*pintr0);
3564 C_TRACE(x, PyCFunction_Call(func,callargs,NULL));
3565 READ_TIMESTAMP(*pintr1);
3566 Py_XDECREF(callargs);
3567 }
3568 } else {
3569 if (PyMethod_Check(func) && PyMethod_GET_SELF(func) != NULL) {
3570 /* optimize access to bound methods */
3571 PyObject *self = PyMethod_GET_SELF(func);
3572 PCALL(PCALL_METHOD);
3573 PCALL(PCALL_BOUND_METHOD);
3574 Py_INCREF(self);
3575 func = PyMethod_GET_FUNCTION(func);
3576 Py_INCREF(func);
3577 Py_DECREF(*pfunc);
3578 *pfunc = self;
3579 na++;
3580 n++;
3581 } else
3582 Py_INCREF(func);
3583 READ_TIMESTAMP(*pintr0);
3584 if (PyFunction_Check(func))
3585 x = fast_function(func, pp_stack, n, na, nk);
3586 else
3587 x = do_call(func, pp_stack, na, nk);
3588 READ_TIMESTAMP(*pintr1);
3589 Py_DECREF(func);
3590 }
3591
3592 /* Clear the stack of the function object. Also removes
3593 the arguments in case they weren't consumed already
3594 (fast_function() and err_args() leave them on the stack).
3595 */
3596 while ((*pp_stack) > pfunc) {
3597 w = EXT_POP(*pp_stack);
3598 Py_DECREF(w);
3599 PCALL(PCALL_POP);
3600 }
3601 return x;
3602}
3603
3604/* The fast_function() function optimize calls for which no argument
3605 tuple is necessary; the objects are passed directly from the stack.
3606 For the simplest case -- a function that takes only positional
3607 arguments and is called with only positional arguments -- it
3608 inlines the most primitive frame setup code from
3609 PyEval_EvalCodeEx(), which vastly reduces the checks that must be
3610 done before evaluating the frame.
3611*/
3612
3613static PyObject *
3614fast_function(PyObject *func, PyObject ***pp_stack, int n, int na, int nk)
3615{
3616 PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
3617 PyObject *globals = PyFunction_GET_GLOBALS(func);
3618 PyObject *argdefs = PyFunction_GET_DEFAULTS(func);
3619 PyObject **d = NULL;
3620 int nd = 0;
3621
3622 PCALL(PCALL_FUNCTION);
3623 PCALL(PCALL_FAST_FUNCTION);
3624 if (argdefs == NULL && co->co_argcount == n && nk==0 &&
3625 co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) {
3626 PyFrameObject *f;
3627 PyObject *retval = NULL;
3628 PyThreadState *tstate = PyThreadState_GET();
3629 PyObject **fastlocals, **stack;
3630 int i;
3631
3632 PCALL(PCALL_FASTER_FUNCTION);
3633 assert(globals != NULL);
3634 /* XXX Perhaps we should create a specialized
3635 PyFrame_New() that doesn't take locals, but does
3636 take builtins without sanity checking them.
3637 */
3638 assert(tstate != NULL);
3639 f = PyFrame_New(tstate, co, globals, NULL);
3640 if (f == NULL)
3641 return NULL;
3642
3643 fastlocals = f->f_localsplus;
3644 stack = (*pp_stack) - n;
3645
3646 for (i = 0; i < n; i++) {
3647 Py_INCREF(*stack);
3648 fastlocals[i] = *stack++;
3649 }
3650 retval = PyEval_EvalFrameEx(f,0);
3651 ++tstate->recursion_depth;
3652 Py_DECREF(f);
3653 --tstate->recursion_depth;
3654 return retval;
3655 }
3656 if (argdefs != NULL) {
3657 d = &PyTuple_GET_ITEM(argdefs, 0);
3658 nd = ((PyTupleObject *)argdefs)->ob_size;
3659 }
3660 return PyEval_EvalCodeEx(co, globals,
3661 (PyObject *)NULL, (*pp_stack)-n, na,
3662 (*pp_stack)-2*nk, nk, d, nd,
3663 PyFunction_GET_CLOSURE(func));
3664}
3665
3666static PyObject *
3667update_keyword_args(PyObject *orig_kwdict, int nk, PyObject ***pp_stack,
3668 PyObject *func)
3669{
3670 PyObject *kwdict = NULL;
3671 if (orig_kwdict == NULL)
3672 kwdict = PyDict_New();
3673 else {
3674 kwdict = PyDict_Copy(orig_kwdict);
3675 Py_DECREF(orig_kwdict);
3676 }
3677 if (kwdict == NULL)
3678 return NULL;
3679 while (--nk >= 0) {
3680 int err;
3681 PyObject *value = EXT_POP(*pp_stack);
3682 PyObject *key = EXT_POP(*pp_stack);
3683 if (PyDict_GetItem(kwdict, key) != NULL) {
3684 PyErr_Format(PyExc_TypeError,
3685 "%.200s%s got multiple values "
3686 "for keyword argument '%.200s'",
3687 PyEval_GetFuncName(func),
3688 PyEval_GetFuncDesc(func),
3689 PyString_AsString(key));
3690 Py_DECREF(key);
3691 Py_DECREF(value);
3692 Py_DECREF(kwdict);
3693 return NULL;
3694 }
3695 err = PyDict_SetItem(kwdict, key, value);
3696 Py_DECREF(key);
3697 Py_DECREF(value);
3698 if (err) {
3699 Py_DECREF(kwdict);
3700 return NULL;
3701 }
3702 }
3703 return kwdict;
3704}
3705
3706static PyObject *
3707update_star_args(int nstack, int nstar, PyObject *stararg,
3708 PyObject ***pp_stack)
3709{
3710 PyObject *callargs, *w;
3711
3712 callargs = PyTuple_New(nstack + nstar);
3713 if (callargs == NULL) {
3714 return NULL;
3715 }
3716 if (nstar) {
3717 int i;
3718 for (i = 0; i < nstar; i++) {
3719 PyObject *a = PyTuple_GET_ITEM(stararg, i);
3720 Py_INCREF(a);
3721 PyTuple_SET_ITEM(callargs, nstack + i, a);
3722 }
3723 }
3724 while (--nstack >= 0) {
3725 w = EXT_POP(*pp_stack);
3726 PyTuple_SET_ITEM(callargs, nstack, w);
3727 }
3728 return callargs;
3729}
3730
3731static PyObject *
3732load_args(PyObject ***pp_stack, int na)
3733{
3734 PyObject *args = PyTuple_New(na);
3735 PyObject *w;
3736
3737 if (args == NULL)
3738 return NULL;
3739 while (--na >= 0) {
3740 w = EXT_POP(*pp_stack);
3741 PyTuple_SET_ITEM(args, na, w);
3742 }
3743 return args;
3744}
3745
3746static PyObject *
3747do_call(PyObject *func, PyObject ***pp_stack, int na, int nk)
3748{
3749 PyObject *callargs = NULL;
3750 PyObject *kwdict = NULL;
3751 PyObject *result = NULL;
3752
3753 if (nk > 0) {
3754 kwdict = update_keyword_args(NULL, nk, pp_stack, func);
3755 if (kwdict == NULL)
3756 goto call_fail;
3757 }
3758 callargs = load_args(pp_stack, na);
3759 if (callargs == NULL)
3760 goto call_fail;
3761#ifdef CALL_PROFILE
3762 /* At this point, we have to look at the type of func to
3763 update the call stats properly. Do it here so as to avoid
3764 exposing the call stats machinery outside ceval.c
3765 */
3766 if (PyFunction_Check(func))
3767 PCALL(PCALL_FUNCTION);
3768 else if (PyMethod_Check(func))
3769 PCALL(PCALL_METHOD);
3770 else if (PyType_Check(func))
3771 PCALL(PCALL_TYPE);
3772 else
3773 PCALL(PCALL_OTHER);
3774#endif
3775 result = PyObject_Call(func, callargs, kwdict);
3776 call_fail:
3777 Py_XDECREF(callargs);
3778 Py_XDECREF(kwdict);
3779 return result;
3780}
3781
3782static PyObject *
3783ext_do_call(PyObject *func, PyObject ***pp_stack, int flags, int na, int nk)
3784{
3785 int nstar = 0;
3786 PyObject *callargs = NULL;
3787 PyObject *stararg = NULL;
3788 PyObject *kwdict = NULL;
3789 PyObject *result = NULL;
3790
3791 if (flags & CALL_FLAG_KW) {
3792 kwdict = EXT_POP(*pp_stack);
3793 if (!(kwdict && PyDict_Check(kwdict))) {
3794 PyErr_Format(PyExc_TypeError,
3795 "%s%s argument after ** "
3796 "must be a dictionary",
3797 PyEval_GetFuncName(func),
3798 PyEval_GetFuncDesc(func));
3799 goto ext_call_fail;
3800 }
3801 }
3802 if (flags & CALL_FLAG_VAR) {
3803 stararg = EXT_POP(*pp_stack);
3804 if (!PyTuple_Check(stararg)) {
3805 PyObject *t = NULL;
3806 t = PySequence_Tuple(stararg);
3807 if (t == NULL) {
3808 if (PyErr_ExceptionMatches(PyExc_TypeError)) {
3809 PyErr_Format(PyExc_TypeError,
3810 "%s%s argument after * "
3811 "must be a sequence",
3812 PyEval_GetFuncName(func),
3813 PyEval_GetFuncDesc(func));
3814 }
3815 goto ext_call_fail;
3816 }
3817 Py_DECREF(stararg);
3818 stararg = t;
3819 }
3820 nstar = PyTuple_GET_SIZE(stararg);
3821 }
3822 if (nk > 0) {
3823 kwdict = update_keyword_args(kwdict, nk, pp_stack, func);
3824 if (kwdict == NULL)
3825 goto ext_call_fail;
3826 }
3827 callargs = update_star_args(na, nstar, stararg, pp_stack);
3828 if (callargs == NULL)
3829 goto ext_call_fail;
3830#ifdef CALL_PROFILE
3831 /* At this point, we have to look at the type of func to
3832 update the call stats properly. Do it here so as to avoid
3833 exposing the call stats machinery outside ceval.c
3834 */
3835 if (PyFunction_Check(func))
3836 PCALL(PCALL_FUNCTION);
3837 else if (PyMethod_Check(func))
3838 PCALL(PCALL_METHOD);
3839 else if (PyType_Check(func))
3840 PCALL(PCALL_TYPE);
3841 else
3842 PCALL(PCALL_OTHER);
3843#endif
3844 result = PyObject_Call(func, callargs, kwdict);
3845 ext_call_fail:
3846 Py_XDECREF(callargs);
3847 Py_XDECREF(kwdict);
3848 Py_XDECREF(stararg);
3849 return result;
3850}
3851
3852/* Extract a slice index from a PyInt or PyLong or an object with the
3853 nb_index slot defined, and store in *pi.
3854 Silently reduce values larger than PY_SSIZE_T_MAX to PY_SSIZE_T_MAX,
3855 and silently boost values less than -PY_SSIZE_T_MAX-1 to -PY_SSIZE_T_MAX-1.
3856 Return 0 on error, 1 on success.
3857*/
3858/* Note: If v is NULL, return success without storing into *pi. This
3859 is because_PyEval_SliceIndex() is called by apply_slice(), which can be
3860 called by the SLICE opcode with v and/or w equal to NULL.
3861*/
3862int
3863_PyEval_SliceIndex(PyObject *v, Py_ssize_t *pi)
3864{
3865 if (v != NULL) {
3866 Py_ssize_t x;
3867 if (PyInt_Check(v)) {
3868 /* XXX(nnorwitz): I think PyInt_AS_LONG is correct,
3869 however, it looks like it should be AsSsize_t.
3870 There should be a comment here explaining why.
3871 */
3872 x = PyInt_AS_LONG(v);
3873 }
3874 else if (PyIndex_Check(v)) {
3875 x = PyNumber_AsSsize_t(v, NULL);
3876 if (x == -1 && PyErr_Occurred())
3877 return 0;
3878 }
3879 else {
3880 PyErr_SetString(PyExc_TypeError,
3881 "slice indices must be integers or "
3882 "None or have an __index__ method");
3883 return 0;
3884 }
3885 *pi = x;
3886 }
3887 return 1;
3888}
3889
3890#undef ISINDEX
3891#define ISINDEX(x) ((x) == NULL || \
3892 PyInt_Check(x) || PyLong_Check(x) || PyIndex_Check(x))
3893
3894static PyObject *
3895apply_slice(PyObject *u, PyObject *v, PyObject *w) /* return u[v:w] */
3896{
3897 PyTypeObject *tp = u->ob_type;
3898 PySequenceMethods *sq = tp->tp_as_sequence;
3899
3900 if (sq && sq->sq_slice && ISINDEX(v) && ISINDEX(w)) {
3901 Py_ssize_t ilow = 0, ihigh = PY_SSIZE_T_MAX;
3902 if (!_PyEval_SliceIndex(v, &ilow))
3903 return NULL;
3904 if (!_PyEval_SliceIndex(w, &ihigh))
3905 return NULL;
3906 return PySequence_GetSlice(u, ilow, ihigh);
3907 }
3908 else {
3909 PyObject *slice = PySlice_New(v, w, NULL);
3910 if (slice != NULL) {
3911 PyObject *res = PyObject_GetItem(u, slice);
3912 Py_DECREF(slice);
3913 return res;
3914 }
3915 else
3916 return NULL;
3917 }
3918}
3919
3920static int
3921assign_slice(PyObject *u, PyObject *v, PyObject *w, PyObject *x)
3922 /* u[v:w] = x */
3923{
3924 PyTypeObject *tp = u->ob_type;
3925 PySequenceMethods *sq = tp->tp_as_sequence;
3926
3927 if (sq && sq->sq_ass_slice && ISINDEX(v) && ISINDEX(w)) {
3928 Py_ssize_t ilow = 0, ihigh = PY_SSIZE_T_MAX;
3929 if (!_PyEval_SliceIndex(v, &ilow))
3930 return -1;
3931 if (!_PyEval_SliceIndex(w, &ihigh))
3932 return -1;
3933 if (x == NULL)
3934 return PySequence_DelSlice(u, ilow, ihigh);
3935 else
3936 return PySequence_SetSlice(u, ilow, ihigh, x);
3937 }
3938 else {
3939 PyObject *slice = PySlice_New(v, w, NULL);
3940 if (slice != NULL) {
3941 int res;
3942 if (x != NULL)
3943 res = PyObject_SetItem(u, slice, x);
3944 else
3945 res = PyObject_DelItem(u, slice);
3946 Py_DECREF(slice);
3947 return res;
3948 }
3949 else
3950 return -1;
3951 }
3952}
3953
3954static PyObject *
3955cmp_outcome(int op, register PyObject *v, register PyObject *w)
3956{
3957 int res = 0;
3958 switch (op) {
3959 case PyCmp_IS:
3960 res = (v == w);
3961 break;
3962 case PyCmp_IS_NOT:
3963 res = (v != w);
3964 break;
3965 case PyCmp_IN:
3966 res = PySequence_Contains(w, v);
3967 if (res < 0)
3968 return NULL;
3969 break;
3970 case PyCmp_NOT_IN:
3971 res = PySequence_Contains(w, v);
3972 if (res < 0)
3973 return NULL;
3974 res = !res;
3975 break;
3976 case PyCmp_EXC_MATCH:
3977 res = PyErr_GivenExceptionMatches(v, w);
3978 break;
3979 default:
3980 return PyObject_RichCompare(v, w, op);
3981 }
3982 v = res ? Py_True : Py_False;
3983 Py_INCREF(v);
3984 return v;
3985}
3986
3987static PyObject *
3988import_from(PyObject *v, PyObject *name)
3989{
3990 PyObject *x;
3991
3992 x = PyObject_GetAttr(v, name);
3993 if (x == NULL && PyErr_ExceptionMatches(PyExc_AttributeError)) {
3994 PyErr_Format(PyExc_ImportError,
3995 "cannot import name %.230s",
3996 PyString_AsString(name));
3997 }
3998 return x;
3999}
4000
4001static int
4002import_all_from(PyObject *locals, PyObject *v)
4003{
4004 PyObject *all = PyObject_GetAttrString(v, "__all__");
4005 PyObject *dict, *name, *value;
4006 int skip_leading_underscores = 0;
4007 int pos, err;
4008
4009 if (all == NULL) {
4010 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
4011 return -1; /* Unexpected error */
4012 PyErr_Clear();
4013 dict = PyObject_GetAttrString(v, "__dict__");
4014 if (dict == NULL) {
4015 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
4016 return -1;
4017 PyErr_SetString(PyExc_ImportError,
4018 "from-import-* object has no __dict__ and no __all__");
4019 return -1;
4020 }
4021 all = PyMapping_Keys(dict);
4022 Py_DECREF(dict);
4023 if (all == NULL)
4024 return -1;
4025 skip_leading_underscores = 1;
4026 }
4027
4028 for (pos = 0, err = 0; ; pos++) {
4029 name = PySequence_GetItem(all, pos);
4030 if (name == NULL) {
4031 if (!PyErr_ExceptionMatches(PyExc_IndexError))
4032 err = -1;
4033 else
4034 PyErr_Clear();
4035 break;
4036 }
4037 if (skip_leading_underscores &&
4038 PyString_Check(name) &&
4039 PyString_AS_STRING(name)[0] == '_')
4040 {
4041 Py_DECREF(name);
4042 continue;
4043 }
4044 value = PyObject_GetAttr(v, name);
4045 if (value == NULL)
4046 err = -1;
4047 else if (PyDict_CheckExact(locals))
4048 err = PyDict_SetItem(locals, name, value);
4049 else
4050 err = PyObject_SetItem(locals, name, value);
4051 Py_DECREF(name);
4052 Py_XDECREF(value);
4053 if (err != 0)
4054 break;
4055 }
4056 Py_DECREF(all);
4057 return err;
4058}
4059
4060static PyObject *
4061build_class(PyObject *methods, PyObject *bases, PyObject *name)
4062{
4063 PyObject *metaclass = NULL, *result, *base;
4064
4065 if (PyDict_Check(methods))
4066 metaclass = PyDict_GetItemString(methods, "__metaclass__");
4067 if (metaclass != NULL)
4068 Py_INCREF(metaclass);
4069 else if (PyTuple_Check(bases) && PyTuple_GET_SIZE(bases) > 0) {
4070 base = PyTuple_GET_ITEM(bases, 0);
4071 metaclass = PyObject_GetAttrString(base, "__class__");
4072 if (metaclass == NULL) {
4073 PyErr_Clear();
4074 metaclass = (PyObject *)base->ob_type;
4075 Py_INCREF(metaclass);
4076 }
4077 }
4078 else {
4079 PyObject *g = PyEval_GetGlobals();
4080 if (g != NULL && PyDict_Check(g))
4081 metaclass = PyDict_GetItemString(g, "__metaclass__");
4082 if (metaclass == NULL)
4083 metaclass = (PyObject *) &PyClass_Type;
4084 Py_INCREF(metaclass);
4085 }
4086 result = PyObject_CallFunctionObjArgs(metaclass, name, bases, methods, NULL);
4087 Py_DECREF(metaclass);
4088 if (result == NULL && PyErr_ExceptionMatches(PyExc_TypeError)) {
4089 /* A type error here likely means that the user passed
4090 in a base that was not a class (such the random module
4091 instead of the random.random type). Help them out with
4092 by augmenting the error message with more information.*/
4093
4094 PyObject *ptype, *pvalue, *ptraceback;
4095
4096 PyErr_Fetch(&ptype, &pvalue, &ptraceback);
4097 if (PyString_Check(pvalue)) {
4098 PyObject *newmsg;
4099 newmsg = PyString_FromFormat(
4100 "Error when calling the metaclass bases\n %s",
4101 PyString_AS_STRING(pvalue));
4102 if (newmsg != NULL) {
4103 Py_DECREF(pvalue);
4104 pvalue = newmsg;
4105 }
4106 }
4107 PyErr_Restore(ptype, pvalue, ptraceback);
4108 }
4109 return result;
4110}
4111
4112static int
4113exec_statement(PyFrameObject *f, PyObject *prog, PyObject *globals,
4114 PyObject *locals)
4115{
4116 int n;
4117 PyObject *v;
4118 int plain = 0;
4119
4120 if (PyTuple_Check(prog) && globals == Py_None && locals == Py_None &&
4121 ((n = PyTuple_Size(prog)) == 2 || n == 3)) {
4122 /* Backward compatibility hack */
4123 globals = PyTuple_GetItem(prog, 1);
4124 if (n == 3)
4125 locals = PyTuple_GetItem(prog, 2);
4126 prog = PyTuple_GetItem(prog, 0);
4127 }
4128 if (globals == Py_None) {
4129 globals = PyEval_GetGlobals();
4130 if (locals == Py_None) {
4131 locals = PyEval_GetLocals();
4132 plain = 1;
4133 }
4134 if (!globals || !locals) {
4135 PyErr_SetString(PyExc_SystemError,
4136 "globals and locals cannot be NULL");
4137 return -1;
4138 }
4139 }
4140 else if (locals == Py_None)
4141 locals = globals;
4142 if (!PyString_Check(prog) &&
4143 !PyUnicode_Check(prog) &&
4144 !PyCode_Check(prog) &&
4145 !PyFile_Check(prog)) {
4146 PyErr_SetString(PyExc_TypeError,
4147 "exec: arg 1 must be a string, file, or code object");
4148 return -1;
4149 }
4150 if (!PyDict_Check(globals)) {
4151 PyErr_SetString(PyExc_TypeError,
4152 "exec: arg 2 must be a dictionary or None");
4153 return -1;
4154 }
4155 if (!PyMapping_Check(locals)) {
4156 PyErr_SetString(PyExc_TypeError,
4157 "exec: arg 3 must be a mapping or None");
4158 return -1;
4159 }
4160 if (PyDict_GetItemString(globals, "__builtins__") == NULL)
4161 PyDict_SetItemString(globals, "__builtins__", f->f_builtins);
4162 if (PyCode_Check(prog)) {
4163 if (PyCode_GetNumFree((PyCodeObject *)prog) > 0) {
4164 PyErr_SetString(PyExc_TypeError,
4165 "code object passed to exec may not contain free variables");
4166 return -1;
4167 }
4168 v = PyEval_EvalCode((PyCodeObject *) prog, globals, locals);
4169 }
4170 else if (PyFile_Check(prog)) {
4171 FILE *fp = PyFile_AsFile(prog);
4172 char *name = PyString_AsString(PyFile_Name(prog));
4173 PyCompilerFlags cf;
4174 if (name == NULL)
4175 return -1;
4176 cf.cf_flags = 0;
4177 if (PyEval_MergeCompilerFlags(&cf))
4178 v = PyRun_FileFlags(fp, name, Py_file_input, globals,
4179 locals, &cf);
4180 else
4181 v = PyRun_File(fp, name, Py_file_input, globals,
4182 locals);
4183 }
4184 else {
4185 PyObject *tmp = NULL;
4186 char *str;
4187 PyCompilerFlags cf;
4188 cf.cf_flags = 0;
4189#ifdef Py_USING_UNICODE
4190 if (PyUnicode_Check(prog)) {
4191 tmp = PyUnicode_AsUTF8String(prog);
4192 if (tmp == NULL)
4193 return -1;
4194 prog = tmp;
4195 cf.cf_flags |= PyCF_SOURCE_IS_UTF8;
4196 }
4197#endif
4198 if (PyString_AsStringAndSize(prog, &str, NULL))
4199 return -1;
4200 if (PyEval_MergeCompilerFlags(&cf))
4201 v = PyRun_StringFlags(str, Py_file_input, globals,
4202 locals, &cf);
4203 else
4204 v = PyRun_String(str, Py_file_input, globals, locals);
4205 Py_XDECREF(tmp);
4206 }
4207 if (plain)
4208 PyFrame_LocalsToFast(f, 0);
4209 if (v == NULL)
4210 return -1;
4211 Py_DECREF(v);
4212 return 0;
4213}
4214
4215static void
4216format_exc_check_arg(PyObject *exc, char *format_str, PyObject *obj)
4217{
4218 char *obj_str;
4219
4220 if (!obj)
4221 return;
4222
4223 obj_str = PyString_AsString(obj);
4224 if (!obj_str)
4225 return;
4226
4227 PyErr_Format(exc, format_str, obj_str);
4228}
4229
4230static PyObject *
4231string_concatenate(PyObject *v, PyObject *w,
4232 PyFrameObject *f, unsigned char *next_instr)
4233{
4234 /* This function implements 'variable += expr' when both arguments
4235 are strings. */
4236 Py_ssize_t v_len = PyString_GET_SIZE(v);
4237 Py_ssize_t w_len = PyString_GET_SIZE(w);
4238 Py_ssize_t new_len = v_len + w_len;
4239 if (new_len < 0) {
4240 PyErr_SetString(PyExc_OverflowError,
4241 "strings are too large to concat");
4242 return NULL;
4243 }
4244
4245 if (v->ob_refcnt == 2) {
4246 /* In the common case, there are 2 references to the value
4247 * stored in 'variable' when the += is performed: one on the
4248 * value stack (in 'v') and one still stored in the 'variable'.
4249 * We try to delete the variable now to reduce the refcnt to 1.
4250 */
4251 switch (*next_instr) {
4252 case STORE_FAST:
4253 {
4254 int oparg = PEEKARG();
4255 PyObject **fastlocals = f->f_localsplus;
4256 if (GETLOCAL(oparg) == v)
4257 SETLOCAL(oparg, NULL);
4258 break;
4259 }
4260 case STORE_DEREF:
4261 {
4262 PyObject **freevars = f->f_localsplus + f->f_code->co_nlocals;
4263 PyObject *c = freevars[PEEKARG()];
4264 if (PyCell_GET(c) == v)
4265 PyCell_Set(c, NULL);
4266 break;
4267 }
4268 case STORE_NAME:
4269 {
4270 PyObject *names = f->f_code->co_names;
4271 PyObject *name = GETITEM(names, PEEKARG());
4272 PyObject *locals = f->f_locals;
4273 if (PyDict_CheckExact(locals) &&
4274 PyDict_GetItem(locals, name) == v) {
4275 if (PyDict_DelItem(locals, name) != 0) {
4276 PyErr_Clear();
4277 }
4278 }
4279 break;
4280 }
4281 }
4282 }
4283
4284 if (v->ob_refcnt == 1 && !PyString_CHECK_INTERNED(v)) {
4285 /* Now we own the last reference to 'v', so we can resize it
4286 * in-place.
4287 */
4288 if (_PyString_Resize(&v, new_len) != 0) {
4289 /* XXX if _PyString_Resize() fails, 'v' has been
4290 * deallocated so it cannot be put back into 'variable'.
4291 * The MemoryError is raised when there is no value in
4292 * 'variable', which might (very remotely) be a cause
4293 * of incompatibilities.
4294 */
4295 return NULL;
4296 }
4297 /* copy 'w' into the newly allocated area of 'v' */
4298 memcpy(PyString_AS_STRING(v) + v_len,
4299 PyString_AS_STRING(w), w_len);
4300 return v;
4301 }
4302 else {
4303 /* When in-place resizing is not an option. */
4304 PyString_Concat(&v, w);
4305 return v;
4306 }
4307}
4308
4309#ifdef DYNAMIC_EXECUTION_PROFILE
4310
4311static PyObject *
4312getarray(long a[256])
4313{
4314 int i;
4315 PyObject *l = PyList_New(256);
4316 if (l == NULL) return NULL;
4317 for (i = 0; i < 256; i++) {
4318 PyObject *x = PyInt_FromLong(a[i]);
4319 if (x == NULL) {
4320 Py_DECREF(l);
4321 return NULL;
4322 }
4323 PyList_SetItem(l, i, x);
4324 }
4325 for (i = 0; i < 256; i++)
4326 a[i] = 0;
4327 return l;
4328}
4329
4330PyObject *
4331_Py_GetDXProfile(PyObject *self, PyObject *args)
4332{
4333#ifndef DXPAIRS
4334 return getarray(dxp);
4335#else
4336 int i;
4337 PyObject *l = PyList_New(257);
4338 if (l == NULL) return NULL;
4339 for (i = 0; i < 257; i++) {
4340 PyObject *x = getarray(dxpairs[i]);
4341 if (x == NULL) {
4342 Py_DECREF(l);
4343 return NULL;
4344 }
4345 PyList_SetItem(l, i, x);
4346 }
4347 return l;
4348#endif
4349}
4350
4351#endif