source: trunk/essentials/dev-lang/python/Python/ceval.c

Last change on this file was 3225, checked in by bird, 18 years ago

Python 2.5
File size: 104.0 KB
Line 
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("iiiiiiiiii",
190 pcall[0], pcall[1], pcall[2], pcall[3],
191 pcall[4], pcall[5], pcall[6], pcall[7],
192 pcall[8], pcall[9]);
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 volatile 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 if (PyErr_ExceptionMatches(PyExc_TypeError))
1772 PyErr_SetString(PyExc_TypeError,
1773 "unpack non-sequence");
1774 why = WHY_EXCEPTION;
1775 }
1776 Py_DECREF(v);
1777 break;
1778
1779 case STORE_ATTR:
1780 w = GETITEM(names, oparg);
1781 v = TOP();
1782 u = SECOND();
1783 STACKADJ(-2);
1784 err = PyObject_SetAttr(v, w, u); /* v.w = u */
1785 Py_DECREF(v);
1786 Py_DECREF(u);
1787 if (err == 0) continue;
1788 break;
1789
1790 case DELETE_ATTR:
1791 w = GETITEM(names, oparg);
1792 v = POP();
1793 err = PyObject_SetAttr(v, w, (PyObject *)NULL);
1794 /* del v.w */
1795 Py_DECREF(v);
1796 break;
1797
1798 case STORE_GLOBAL:
1799 w = GETITEM(names, oparg);
1800 v = POP();
1801 err = PyDict_SetItem(f->f_globals, w, v);
1802 Py_DECREF(v);
1803 if (err == 0) continue;
1804 break;
1805
1806 case DELETE_GLOBAL:
1807 w = GETITEM(names, oparg);
1808 if ((err = PyDict_DelItem(f->f_globals, w)) != 0)
1809 format_exc_check_arg(
1810 PyExc_NameError, GLOBAL_NAME_ERROR_MSG, w);
1811 break;
1812
1813 case LOAD_NAME:
1814 w = GETITEM(names, oparg);
1815 if ((v = f->f_locals) == NULL) {
1816 PyErr_Format(PyExc_SystemError,
1817 "no locals when loading %s",
1818 PyObject_REPR(w));
1819 break;
1820 }
1821 if (PyDict_CheckExact(v)) {
1822 x = PyDict_GetItem(v, w);
1823 Py_XINCREF(x);
1824 }
1825 else {
1826 x = PyObject_GetItem(v, w);
1827 if (x == NULL && PyErr_Occurred()) {
1828 if (!PyErr_ExceptionMatches(PyExc_KeyError))
1829 break;
1830 PyErr_Clear();
1831 }
1832 }
1833 if (x == NULL) {
1834 x = PyDict_GetItem(f->f_globals, w);
1835 if (x == NULL) {
1836 x = PyDict_GetItem(f->f_builtins, w);
1837 if (x == NULL) {
1838 format_exc_check_arg(
1839 PyExc_NameError,
1840 NAME_ERROR_MSG ,w);
1841 break;
1842 }
1843 }
1844 Py_INCREF(x);
1845 }
1846 PUSH(x);
1847 continue;
1848
1849 case LOAD_GLOBAL:
1850 w = GETITEM(names, oparg);
1851 if (PyString_CheckExact(w)) {
1852 /* Inline the PyDict_GetItem() calls.
1853 WARNING: this is an extreme speed hack.
1854 Do not try this at home. */
1855 long hash = ((PyStringObject *)w)->ob_shash;
1856 if (hash != -1) {
1857 PyDictObject *d;
1858 PyDictEntry *e;
1859 d = (PyDictObject *)(f->f_globals);
1860 e = d->ma_lookup(d, w, hash);
1861 if (e == NULL) {
1862 x = NULL;
1863 break;
1864 }
1865 x = e->me_value;
1866 if (x != NULL) {
1867 Py_INCREF(x);
1868 PUSH(x);
1869 continue;
1870 }
1871 d = (PyDictObject *)(f->f_builtins);
1872 e = d->ma_lookup(d, w, hash);
1873 if (e == NULL) {
1874 x = NULL;
1875 break;
1876 }
1877 x = e->me_value;
1878 if (x != NULL) {
1879 Py_INCREF(x);
1880 PUSH(x);
1881 continue;
1882 }
1883 goto load_global_error;
1884 }
1885 }
1886 /* This is the un-inlined version of the code above */
1887 x = PyDict_GetItem(f->f_globals, w);
1888 if (x == NULL) {
1889 x = PyDict_GetItem(f->f_builtins, w);
1890 if (x == NULL) {
1891 load_global_error:
1892 format_exc_check_arg(
1893 PyExc_NameError,
1894 GLOBAL_NAME_ERROR_MSG, w);
1895 break;
1896 }
1897 }
1898 Py_INCREF(x);
1899 PUSH(x);
1900 continue;
1901
1902 case DELETE_FAST:
1903 x = GETLOCAL(oparg);
1904 if (x != NULL) {
1905 SETLOCAL(oparg, NULL);
1906 continue;
1907 }
1908 format_exc_check_arg(
1909 PyExc_UnboundLocalError,
1910 UNBOUNDLOCAL_ERROR_MSG,
1911 PyTuple_GetItem(co->co_varnames, oparg)
1912 );
1913 break;
1914
1915 case LOAD_CLOSURE:
1916 x = freevars[oparg];
1917 Py_INCREF(x);
1918 PUSH(x);
1919 if (x != NULL) continue;
1920 break;
1921
1922 case LOAD_DEREF:
1923 x = freevars[oparg];
1924 w = PyCell_Get(x);
1925 if (w != NULL) {
1926 PUSH(w);
1927 continue;
1928 }
1929 err = -1;
1930 /* Don't stomp existing exception */
1931 if (PyErr_Occurred())
1932 break;
1933 if (oparg < PyTuple_GET_SIZE(co->co_cellvars)) {
1934 v = PyTuple_GET_ITEM(co->co_cellvars,
1935 oparg);
1936 format_exc_check_arg(
1937 PyExc_UnboundLocalError,
1938 UNBOUNDLOCAL_ERROR_MSG,
1939 v);
1940 } else {
1941 v = PyTuple_GET_ITEM(
1942 co->co_freevars,
1943 oparg - PyTuple_GET_SIZE(co->co_cellvars));
1944 format_exc_check_arg(
1945 PyExc_NameError,
1946 UNBOUNDFREE_ERROR_MSG,
1947 v);
1948 }
1949 break;
1950
1951 case STORE_DEREF:
1952 w = POP();
1953 x = freevars[oparg];
1954 PyCell_Set(x, w);
1955 Py_DECREF(w);
1956 continue;
1957
1958 case BUILD_TUPLE:
1959 x = PyTuple_New(oparg);
1960 if (x != NULL) {
1961 for (; --oparg >= 0;) {
1962 w = POP();
1963 PyTuple_SET_ITEM(x, oparg, w);
1964 }
1965 PUSH(x);
1966 continue;
1967 }
1968 break;
1969
1970 case BUILD_LIST:
1971 x = PyList_New(oparg);
1972 if (x != NULL) {
1973 for (; --oparg >= 0;) {
1974 w = POP();
1975 PyList_SET_ITEM(x, oparg, w);
1976 }
1977 PUSH(x);
1978 continue;
1979 }
1980 break;
1981
1982 case BUILD_MAP:
1983 x = PyDict_New();
1984 PUSH(x);
1985 if (x != NULL) continue;
1986 break;
1987
1988 case LOAD_ATTR:
1989 w = GETITEM(names, oparg);
1990 v = TOP();
1991 x = PyObject_GetAttr(v, w);
1992 Py_DECREF(v);
1993 SET_TOP(x);
1994 if (x != NULL) continue;
1995 break;
1996
1997 case COMPARE_OP:
1998 w = POP();
1999 v = TOP();
2000 if (PyInt_CheckExact(w) && PyInt_CheckExact(v)) {
2001 /* INLINE: cmp(int, int) */
2002 register long a, b;
2003 register int res;
2004 a = PyInt_AS_LONG(v);
2005 b = PyInt_AS_LONG(w);
2006 switch (oparg) {
2007 case PyCmp_LT: res = a < b; break;
2008 case PyCmp_LE: res = a <= b; break;
2009 case PyCmp_EQ: res = a == b; break;
2010 case PyCmp_NE: res = a != b; break;
2011 case PyCmp_GT: res = a > b; break;
2012 case PyCmp_GE: res = a >= b; break;
2013 case PyCmp_IS: res = v == w; break;
2014 case PyCmp_IS_NOT: res = v != w; break;
2015 default: goto slow_compare;
2016 }
2017 x = res ? Py_True : Py_False;
2018 Py_INCREF(x);
2019 }
2020 else {
2021 slow_compare:
2022 x = cmp_outcome(oparg, v, w);
2023 }
2024 Py_DECREF(v);
2025 Py_DECREF(w);
2026 SET_TOP(x);
2027 if (x == NULL) break;
2028 PREDICT(JUMP_IF_FALSE);
2029 PREDICT(JUMP_IF_TRUE);
2030 continue;
2031
2032 case IMPORT_NAME:
2033 w = GETITEM(names, oparg);
2034 x = PyDict_GetItemString(f->f_builtins, "__import__");
2035 if (x == NULL) {
2036 PyErr_SetString(PyExc_ImportError,
2037 "__import__ not found");
2038 break;
2039 }
2040 v = POP();
2041 u = TOP();
2042 if (PyInt_AsLong(u) != -1 || PyErr_Occurred())
2043 w = PyTuple_Pack(5,
2044 w,
2045 f->f_globals,
2046 f->f_locals == NULL ?
2047 Py_None : f->f_locals,
2048 v,
2049 u);
2050 else
2051 w = PyTuple_Pack(4,
2052 w,
2053 f->f_globals,
2054 f->f_locals == NULL ?
2055 Py_None : f->f_locals,
2056 v);
2057 Py_DECREF(v);
2058 Py_DECREF(u);
2059 if (w == NULL) {
2060 u = POP();
2061 x = NULL;
2062 break;
2063 }
2064 READ_TIMESTAMP(intr0);
2065 x = PyEval_CallObject(x, w);
2066 READ_TIMESTAMP(intr1);
2067 Py_DECREF(w);
2068 SET_TOP(x);
2069 if (x != NULL) continue;
2070 break;
2071
2072 case IMPORT_STAR:
2073 v = POP();
2074 PyFrame_FastToLocals(f);
2075 if ((x = f->f_locals) == NULL) {
2076 PyErr_SetString(PyExc_SystemError,
2077 "no locals found during 'import *'");
2078 break;
2079 }
2080 READ_TIMESTAMP(intr0);
2081 err = import_all_from(x, v);
2082 READ_TIMESTAMP(intr1);
2083 PyFrame_LocalsToFast(f, 0);
2084 Py_DECREF(v);
2085 if (err == 0) continue;
2086 break;
2087
2088 case IMPORT_FROM:
2089 w = GETITEM(names, oparg);
2090 v = TOP();
2091 READ_TIMESTAMP(intr0);
2092 x = import_from(v, w);
2093 READ_TIMESTAMP(intr1);
2094 PUSH(x);
2095 if (x != NULL) continue;
2096 break;
2097
2098 case JUMP_FORWARD:
2099 JUMPBY(oparg);
2100 goto fast_next_opcode;
2101
2102 PREDICTED_WITH_ARG(JUMP_IF_FALSE);
2103 case JUMP_IF_FALSE:
2104 w = TOP();
2105 if (w == Py_True) {
2106 PREDICT(POP_TOP);
2107 goto fast_next_opcode;
2108 }
2109 if (w == Py_False) {
2110 JUMPBY(oparg);
2111 goto fast_next_opcode;
2112 }
2113 err = PyObject_IsTrue(w);
2114 if (err > 0)
2115 err = 0;
2116 else if (err == 0)
2117 JUMPBY(oparg);
2118 else
2119 break;
2120 continue;
2121
2122 PREDICTED_WITH_ARG(JUMP_IF_TRUE);
2123 case JUMP_IF_TRUE:
2124 w = TOP();
2125 if (w == Py_False) {
2126 PREDICT(POP_TOP);
2127 goto fast_next_opcode;
2128 }
2129 if (w == Py_True) {
2130 JUMPBY(oparg);
2131 goto fast_next_opcode;
2132 }
2133 err = PyObject_IsTrue(w);
2134 if (err > 0) {
2135 err = 0;
2136 JUMPBY(oparg);
2137 }
2138 else if (err == 0)
2139 ;
2140 else
2141 break;
2142 continue;
2143
2144 PREDICTED_WITH_ARG(JUMP_ABSOLUTE);
2145 case JUMP_ABSOLUTE:
2146 JUMPTO(oparg);
2147 continue;
2148
2149 case GET_ITER:
2150 /* before: [obj]; after [getiter(obj)] */
2151 v = TOP();
2152 x = PyObject_GetIter(v);
2153 Py_DECREF(v);
2154 if (x != NULL) {
2155 SET_TOP(x);
2156 PREDICT(FOR_ITER);
2157 continue;
2158 }
2159 STACKADJ(-1);
2160 break;
2161
2162 PREDICTED_WITH_ARG(FOR_ITER);
2163 case FOR_ITER:
2164 /* before: [iter]; after: [iter, iter()] *or* [] */
2165 v = TOP();
2166 x = (*v->ob_type->tp_iternext)(v);
2167 if (x != NULL) {
2168 PUSH(x);
2169 PREDICT(STORE_FAST);
2170 PREDICT(UNPACK_SEQUENCE);
2171 continue;
2172 }
2173 if (PyErr_Occurred()) {
2174 if (!PyErr_ExceptionMatches(PyExc_StopIteration))
2175 break;
2176 PyErr_Clear();
2177 }
2178 /* iterator ended normally */
2179 x = v = POP();
2180 Py_DECREF(v);
2181 JUMPBY(oparg);
2182 continue;
2183
2184 case BREAK_LOOP:
2185 why = WHY_BREAK;
2186 goto fast_block_end;
2187
2188 case CONTINUE_LOOP:
2189 retval = PyInt_FromLong(oparg);
2190 if (!retval) {
2191 x = NULL;
2192 break;
2193 }
2194 why = WHY_CONTINUE;
2195 goto fast_block_end;
2196
2197 case SETUP_LOOP:
2198 case SETUP_EXCEPT:
2199 case SETUP_FINALLY:
2200 /* NOTE: If you add any new block-setup opcodes that are not try/except/finally
2201 handlers, you may need to update the PyGen_NeedsFinalizing() function. */
2202
2203 PyFrame_BlockSetup(f, opcode, INSTR_OFFSET() + oparg,
2204 STACK_LEVEL());
2205 continue;
2206
2207 case WITH_CLEANUP:
2208 {
2209 /* TOP is the context.__exit__ bound method.
2210 Below that are 1-3 values indicating how/why
2211 we entered the finally clause:
2212 - SECOND = None
2213 - (SECOND, THIRD) = (WHY_{RETURN,CONTINUE}), retval
2214 - SECOND = WHY_*; no retval below it
2215 - (SECOND, THIRD, FOURTH) = exc_info()
2216 In the last case, we must call
2217 TOP(SECOND, THIRD, FOURTH)
2218 otherwise we must call
2219 TOP(None, None, None)
2220
2221 In addition, if the stack represents an exception,
2222 *and* the function call returns a 'true' value, we
2223 "zap" this information, to prevent END_FINALLY from
2224 re-raising the exception. (But non-local gotos
2225 should still be resumed.)
2226 */
2227
2228 x = TOP();
2229 u = SECOND();
2230 if (PyInt_Check(u) || u == Py_None) {
2231 u = v = w = Py_None;
2232 }
2233 else {
2234 v = THIRD();
2235 w = FOURTH();
2236 }
2237 /* XXX Not the fastest way to call it... */
2238 x = PyObject_CallFunctionObjArgs(x, u, v, w, NULL);
2239 if (x == NULL)
2240 break; /* Go to error exit */
2241 if (u != Py_None && PyObject_IsTrue(x)) {
2242 /* There was an exception and a true return */
2243 Py_DECREF(x);
2244 x = TOP(); /* Again */
2245 STACKADJ(-3);
2246 Py_INCREF(Py_None);
2247 SET_TOP(Py_None);
2248 Py_DECREF(x);
2249 Py_DECREF(u);
2250 Py_DECREF(v);
2251 Py_DECREF(w);
2252 } else {
2253 /* Let END_FINALLY do its thing */
2254 Py_DECREF(x);
2255 x = POP();
2256 Py_DECREF(x);
2257 }
2258 break;
2259 }
2260
2261 case CALL_FUNCTION:
2262 {
2263 PyObject **sp;
2264 PCALL(PCALL_ALL);
2265 sp = stack_pointer;
2266#ifdef WITH_TSC
2267 x = call_function(&sp, oparg, &intr0, &intr1);
2268#else
2269 x = call_function(&sp, oparg);
2270#endif
2271 stack_pointer = sp;
2272 PUSH(x);
2273 if (x != NULL)
2274 continue;
2275 break;
2276 }
2277
2278 case CALL_FUNCTION_VAR:
2279 case CALL_FUNCTION_KW:
2280 case CALL_FUNCTION_VAR_KW:
2281 {
2282 int na = oparg & 0xff;
2283 int nk = (oparg>>8) & 0xff;
2284 int flags = (opcode - CALL_FUNCTION) & 3;
2285 int n = na + 2 * nk;
2286 PyObject **pfunc, *func, **sp;
2287 PCALL(PCALL_ALL);
2288 if (flags & CALL_FLAG_VAR)
2289 n++;
2290 if (flags & CALL_FLAG_KW)
2291 n++;
2292 pfunc = stack_pointer - n - 1;
2293 func = *pfunc;
2294
2295 if (PyMethod_Check(func)
2296 && PyMethod_GET_SELF(func) != NULL) {
2297 PyObject *self = PyMethod_GET_SELF(func);
2298 Py_INCREF(self);
2299 func = PyMethod_GET_FUNCTION(func);
2300 Py_INCREF(func);
2301 Py_DECREF(*pfunc);
2302 *pfunc = self;
2303 na++;
2304 n++;
2305 } else
2306 Py_INCREF(func);
2307 sp = stack_pointer;
2308 READ_TIMESTAMP(intr0);
2309 x = ext_do_call(func, &sp, flags, na, nk);
2310 READ_TIMESTAMP(intr1);
2311 stack_pointer = sp;
2312 Py_DECREF(func);
2313
2314 while (stack_pointer > pfunc) {
2315 w = POP();
2316 Py_DECREF(w);
2317 }
2318 PUSH(x);
2319 if (x != NULL)
2320 continue;
2321 break;
2322 }
2323
2324 case MAKE_FUNCTION:
2325 v = POP(); /* code object */
2326 x = PyFunction_New(v, f->f_globals);
2327 Py_DECREF(v);
2328 /* XXX Maybe this should be a separate opcode? */
2329 if (x != NULL && oparg > 0) {
2330 v = PyTuple_New(oparg);
2331 if (v == NULL) {
2332 Py_DECREF(x);
2333 x = NULL;
2334 break;
2335 }
2336 while (--oparg >= 0) {
2337 w = POP();
2338 PyTuple_SET_ITEM(v, oparg, w);
2339 }
2340 err = PyFunction_SetDefaults(x, v);
2341 Py_DECREF(v);
2342 }
2343 PUSH(x);
2344 break;
2345
2346 case MAKE_CLOSURE:
2347 {
2348 v = POP(); /* code object */
2349 x = PyFunction_New(v, f->f_globals);
2350 Py_DECREF(v);
2351 if (x != NULL) {
2352 v = POP();
2353 err = PyFunction_SetClosure(x, v);
2354 Py_DECREF(v);
2355 }
2356 if (x != NULL && oparg > 0) {
2357 v = PyTuple_New(oparg);
2358 if (v == NULL) {
2359 Py_DECREF(x);
2360 x = NULL;
2361 break;
2362 }
2363 while (--oparg >= 0) {
2364 w = POP();
2365 PyTuple_SET_ITEM(v, oparg, w);
2366 }
2367 err = PyFunction_SetDefaults(x, v);
2368 Py_DECREF(v);
2369 }
2370 PUSH(x);
2371 break;
2372 }
2373
2374 case BUILD_SLICE:
2375 if (oparg == 3)
2376 w = POP();
2377 else
2378 w = NULL;
2379 v = POP();
2380 u = TOP();
2381 x = PySlice_New(u, v, w);
2382 Py_DECREF(u);
2383 Py_DECREF(v);
2384 Py_XDECREF(w);
2385 SET_TOP(x);
2386 if (x != NULL) continue;
2387 break;
2388
2389 case EXTENDED_ARG:
2390 opcode = NEXTOP();
2391 oparg = oparg<<16 | NEXTARG();
2392 goto dispatch_opcode;
2393
2394 default:
2395 fprintf(stderr,
2396 "XXX lineno: %d, opcode: %d\n",
2397 PyCode_Addr2Line(f->f_code, f->f_lasti),
2398 opcode);
2399 PyErr_SetString(PyExc_SystemError, "unknown opcode");
2400 why = WHY_EXCEPTION;
2401 break;
2402
2403#ifdef CASE_TOO_BIG
2404 }
2405#endif
2406
2407 } /* switch */
2408
2409 on_error:
2410
2411 READ_TIMESTAMP(inst1);
2412
2413 /* Quickly continue if no error occurred */
2414
2415 if (why == WHY_NOT) {
2416 if (err == 0 && x != NULL) {
2417#ifdef CHECKEXC
2418 /* This check is expensive! */
2419 if (PyErr_Occurred())
2420 fprintf(stderr,
2421 "XXX undetected error\n");
2422 else {
2423#endif
2424 READ_TIMESTAMP(loop1);
2425 continue; /* Normal, fast path */
2426#ifdef CHECKEXC
2427 }
2428#endif
2429 }
2430 why = WHY_EXCEPTION;
2431 x = Py_None;
2432 err = 0;
2433 }
2434
2435 /* Double-check exception status */
2436
2437 if (why == WHY_EXCEPTION || why == WHY_RERAISE) {
2438 if (!PyErr_Occurred()) {
2439 PyErr_SetString(PyExc_SystemError,
2440 "error return without exception set");
2441 why = WHY_EXCEPTION;
2442 }
2443 }
2444#ifdef CHECKEXC
2445 else {
2446 /* This check is expensive! */
2447 if (PyErr_Occurred()) {
2448 char buf[1024];
2449 sprintf(buf, "Stack unwind with exception "
2450 "set and why=%d", why);
2451 Py_FatalError(buf);
2452 }
2453 }
2454#endif
2455
2456 /* Log traceback info if this is a real exception */
2457
2458 if (why == WHY_EXCEPTION) {
2459 PyTraceBack_Here(f);
2460
2461 if (tstate->c_tracefunc != NULL)
2462 call_exc_trace(tstate->c_tracefunc,
2463 tstate->c_traceobj, f);
2464 }
2465
2466 /* For the rest, treat WHY_RERAISE as WHY_EXCEPTION */
2467
2468 if (why == WHY_RERAISE)
2469 why = WHY_EXCEPTION;
2470
2471 /* Unwind stacks if a (pseudo) exception occurred */
2472
2473fast_block_end:
2474 while (why != WHY_NOT && f->f_iblock > 0) {
2475 PyTryBlock *b = PyFrame_BlockPop(f);
2476
2477 assert(why != WHY_YIELD);
2478 if (b->b_type == SETUP_LOOP && why == WHY_CONTINUE) {
2479 /* For a continue inside a try block,
2480 don't pop the block for the loop. */
2481 PyFrame_BlockSetup(f, b->b_type, b->b_handler,
2482 b->b_level);
2483 why = WHY_NOT;
2484 JUMPTO(PyInt_AS_LONG(retval));
2485 Py_DECREF(retval);
2486 break;
2487 }
2488
2489 while (STACK_LEVEL() > b->b_level) {
2490 v = POP();
2491 Py_XDECREF(v);
2492 }
2493 if (b->b_type == SETUP_LOOP && why == WHY_BREAK) {
2494 why = WHY_NOT;
2495 JUMPTO(b->b_handler);
2496 break;
2497 }
2498 if (b->b_type == SETUP_FINALLY ||
2499 (b->b_type == SETUP_EXCEPT &&
2500 why == WHY_EXCEPTION)) {
2501 if (why == WHY_EXCEPTION) {
2502 PyObject *exc, *val, *tb;
2503 PyErr_Fetch(&exc, &val, &tb);
2504 if (val == NULL) {
2505 val = Py_None;
2506 Py_INCREF(val);
2507 }
2508 /* Make the raw exception data
2509 available to the handler,
2510 so a program can emulate the
2511 Python main loop. Don't do
2512 this for 'finally'. */
2513 if (b->b_type == SETUP_EXCEPT) {
2514 PyErr_NormalizeException(
2515 &exc, &val, &tb);
2516 set_exc_info(tstate,
2517 exc, val, tb);
2518 }
2519 if (tb == NULL) {
2520 Py_INCREF(Py_None);
2521 PUSH(Py_None);
2522 } else
2523 PUSH(tb);
2524 PUSH(val);
2525 PUSH(exc);
2526 }
2527 else {
2528 if (why & (WHY_RETURN | WHY_CONTINUE))
2529 PUSH(retval);
2530 v = PyInt_FromLong((long)why);
2531 PUSH(v);
2532 }
2533 why = WHY_NOT;
2534 JUMPTO(b->b_handler);
2535 break;
2536 }
2537 } /* unwind stack */
2538
2539 /* End the loop if we still have an error (or return) */
2540
2541 if (why != WHY_NOT)
2542 break;
2543 READ_TIMESTAMP(loop1);
2544
2545 } /* main loop */
2546
2547 assert(why != WHY_YIELD);
2548 /* Pop remaining stack entries. */
2549 while (!EMPTY()) {
2550 v = POP();
2551 Py_XDECREF(v);
2552 }
2553
2554 if (why != WHY_RETURN)
2555 retval = NULL;
2556
2557fast_yield:
2558 if (tstate->use_tracing) {
2559 if (tstate->c_tracefunc) {
2560 if (why == WHY_RETURN || why == WHY_YIELD) {
2561 if (call_trace(tstate->c_tracefunc,
2562 tstate->c_traceobj, f,
2563 PyTrace_RETURN, retval)) {
2564 Py_XDECREF(retval);
2565 retval = NULL;
2566 why = WHY_EXCEPTION;
2567 }
2568 }
2569 else if (why == WHY_EXCEPTION) {
2570 call_trace_protected(tstate->c_tracefunc,
2571 tstate->c_traceobj, f,
2572 PyTrace_RETURN, NULL);
2573 }
2574 }
2575 if (tstate->c_profilefunc) {
2576 if (why == WHY_EXCEPTION)
2577 call_trace_protected(tstate->c_profilefunc,
2578 tstate->c_profileobj, f,
2579 PyTrace_RETURN, NULL);
2580 else if (call_trace(tstate->c_profilefunc,
2581 tstate->c_profileobj, f,
2582 PyTrace_RETURN, retval)) {
2583 Py_XDECREF(retval);
2584 retval = NULL;
2585 why = WHY_EXCEPTION;
2586 }
2587 }
2588 }
2589
2590 if (tstate->frame->f_exc_type != NULL)
2591 reset_exc_info(tstate);
2592 else {
2593 assert(tstate->frame->f_exc_value == NULL);
2594 assert(tstate->frame->f_exc_traceback == NULL);
2595 }
2596
2597 /* pop frame */
2598 exit_eval_frame:
2599 Py_LeaveRecursiveCall();
2600 tstate->frame = f->f_back;
2601
2602 return retval;
2603}
2604
2605/* This is gonna seem *real weird*, but if you put some other code between
2606 PyEval_EvalFrame() and PyEval_EvalCodeEx() you will need to adjust
2607 the test in the if statements in Misc/gdbinit (pystack and pystackv). */
2608
2609PyObject *
2610PyEval_EvalCodeEx(PyCodeObject *co, PyObject *globals, PyObject *locals,
2611 PyObject **args, int argcount, PyObject **kws, int kwcount,
2612 PyObject **defs, int defcount, PyObject *closure)
2613{
2614 register PyFrameObject *f;
2615 register PyObject *retval = NULL;
2616 register PyObject **fastlocals, **freevars;
2617 PyThreadState *tstate = PyThreadState_GET();
2618 PyObject *x, *u;
2619
2620 if (globals == NULL) {
2621 PyErr_SetString(PyExc_SystemError,
2622 "PyEval_EvalCodeEx: NULL globals");
2623 return NULL;
2624 }
2625
2626 assert(tstate != NULL);
2627 assert(globals != NULL);
2628 f = PyFrame_New(tstate, co, globals, locals);
2629 if (f == NULL)
2630 return NULL;
2631
2632 fastlocals = f->f_localsplus;
2633 freevars = f->f_localsplus + co->co_nlocals;
2634
2635 if (co->co_argcount > 0 ||
2636 co->co_flags & (CO_VARARGS | CO_VARKEYWORDS)) {
2637 int i;
2638 int n = argcount;
2639 PyObject *kwdict = NULL;
2640 if (co->co_flags & CO_VARKEYWORDS) {
2641 kwdict = PyDict_New();
2642 if (kwdict == NULL)
2643 goto fail;
2644 i = co->co_argcount;
2645 if (co->co_flags & CO_VARARGS)
2646 i++;
2647 SETLOCAL(i, kwdict);
2648 }
2649 if (argcount > co->co_argcount) {
2650 if (!(co->co_flags & CO_VARARGS)) {
2651 PyErr_Format(PyExc_TypeError,
2652 "%.200s() takes %s %d "
2653 "%sargument%s (%d given)",
2654 PyString_AsString(co->co_name),
2655 defcount ? "at most" : "exactly",
2656 co->co_argcount,
2657 kwcount ? "non-keyword " : "",
2658 co->co_argcount == 1 ? "" : "s",
2659 argcount);
2660 goto fail;
2661 }
2662 n = co->co_argcount;
2663 }
2664 for (i = 0; i < n; i++) {
2665 x = args[i];
2666 Py_INCREF(x);
2667 SETLOCAL(i, x);
2668 }
2669 if (co->co_flags & CO_VARARGS) {
2670 u = PyTuple_New(argcount - n);
2671 if (u == NULL)
2672 goto fail;
2673 SETLOCAL(co->co_argcount, u);
2674 for (i = n; i < argcount; i++) {
2675 x = args[i];
2676 Py_INCREF(x);
2677 PyTuple_SET_ITEM(u, i-n, x);
2678 }
2679 }
2680 for (i = 0; i < kwcount; i++) {
2681 PyObject *keyword = kws[2*i];
2682 PyObject *value = kws[2*i + 1];
2683 int j;
2684 if (keyword == NULL || !PyString_Check(keyword)) {
2685 PyErr_Format(PyExc_TypeError,
2686 "%.200s() keywords must be strings",
2687 PyString_AsString(co->co_name));
2688 goto fail;
2689 }
2690 /* XXX slow -- speed up using dictionary? */
2691 for (j = 0; j < co->co_argcount; j++) {
2692 PyObject *nm = PyTuple_GET_ITEM(
2693 co->co_varnames, j);
2694 int cmp = PyObject_RichCompareBool(
2695 keyword, nm, Py_EQ);
2696 if (cmp > 0)
2697 break;
2698 else if (cmp < 0)
2699 goto fail;
2700 }
2701 /* Check errors from Compare */
2702 if (PyErr_Occurred())
2703 goto fail;
2704 if (j >= co->co_argcount) {
2705 if (kwdict == NULL) {
2706 PyErr_Format(PyExc_TypeError,
2707 "%.200s() got an unexpected "
2708 "keyword argument '%.400s'",
2709 PyString_AsString(co->co_name),
2710 PyString_AsString(keyword));
2711 goto fail;
2712 }
2713 PyDict_SetItem(kwdict, keyword, value);
2714 }
2715 else {
2716 if (GETLOCAL(j) != NULL) {
2717 PyErr_Format(PyExc_TypeError,
2718 "%.200s() got multiple "
2719 "values for keyword "
2720 "argument '%.400s'",
2721 PyString_AsString(co->co_name),
2722 PyString_AsString(keyword));
2723 goto fail;
2724 }
2725 Py_INCREF(value);
2726 SETLOCAL(j, value);
2727 }
2728 }
2729 if (argcount < co->co_argcount) {
2730 int m = co->co_argcount - defcount;
2731 for (i = argcount; i < m; i++) {
2732 if (GETLOCAL(i) == NULL) {
2733 PyErr_Format(PyExc_TypeError,
2734 "%.200s() takes %s %d "
2735 "%sargument%s (%d given)",
2736 PyString_AsString(co->co_name),
2737 ((co->co_flags & CO_VARARGS) ||
2738 defcount) ? "at least"
2739 : "exactly",
2740 m, kwcount ? "non-keyword " : "",
2741 m == 1 ? "" : "s", i);
2742 goto fail;
2743 }
2744 }
2745 if (n > m)
2746 i = n - m;
2747 else
2748 i = 0;
2749 for (; i < defcount; i++) {
2750 if (GETLOCAL(m+i) == NULL) {
2751 PyObject *def = defs[i];
2752 Py_INCREF(def);
2753 SETLOCAL(m+i, def);
2754 }
2755 }
2756 }
2757 }
2758 else {
2759 if (argcount > 0 || kwcount > 0) {
2760 PyErr_Format(PyExc_TypeError,
2761 "%.200s() takes no arguments (%d given)",
2762 PyString_AsString(co->co_name),
2763 argcount + kwcount);
2764 goto fail;
2765 }
2766 }
2767 /* Allocate and initialize storage for cell vars, and copy free
2768 vars into frame. This isn't too efficient right now. */
2769 if (PyTuple_GET_SIZE(co->co_cellvars)) {
2770 int i, j, nargs, found;
2771 char *cellname, *argname;
2772 PyObject *c;
2773
2774 nargs = co->co_argcount;
2775 if (co->co_flags & CO_VARARGS)
2776 nargs++;
2777 if (co->co_flags & CO_VARKEYWORDS)
2778 nargs++;
2779
2780 /* Initialize each cell var, taking into account
2781 cell vars that are initialized from arguments.
2782
2783 Should arrange for the compiler to put cellvars
2784 that are arguments at the beginning of the cellvars
2785 list so that we can march over it more efficiently?
2786 */
2787 for (i = 0; i < PyTuple_GET_SIZE(co->co_cellvars); ++i) {
2788 cellname = PyString_AS_STRING(
2789 PyTuple_GET_ITEM(co->co_cellvars, i));
2790 found = 0;
2791 for (j = 0; j < nargs; j++) {
2792 argname = PyString_AS_STRING(
2793 PyTuple_GET_ITEM(co->co_varnames, j));
2794 if (strcmp(cellname, argname) == 0) {
2795 c = PyCell_New(GETLOCAL(j));
2796 if (c == NULL)
2797 goto fail;
2798 GETLOCAL(co->co_nlocals + i) = c;
2799 found = 1;
2800 break;
2801 }
2802 }
2803 if (found == 0) {
2804 c = PyCell_New(NULL);
2805 if (c == NULL)
2806 goto fail;
2807 SETLOCAL(co->co_nlocals + i, c);
2808 }
2809 }
2810 }
2811 if (PyTuple_GET_SIZE(co->co_freevars)) {
2812 int i;
2813 for (i = 0; i < PyTuple_GET_SIZE(co->co_freevars); ++i) {
2814 PyObject *o = PyTuple_GET_ITEM(closure, i);
2815 Py_INCREF(o);
2816 freevars[PyTuple_GET_SIZE(co->co_cellvars) + i] = o;
2817 }
2818 }
2819
2820 if (co->co_flags & CO_GENERATOR) {
2821 /* Don't need to keep the reference to f_back, it will be set
2822 * when the generator is resumed. */
2823 Py_XDECREF(f->f_back);
2824 f->f_back = NULL;
2825
2826 PCALL(PCALL_GENERATOR);
2827
2828 /* Create a new generator that owns the ready to run frame
2829 * and return that as the value. */
2830 return PyGen_New(f);
2831 }
2832
2833 retval = PyEval_EvalFrameEx(f,0);
2834
2835 fail: /* Jump here from prelude on failure */
2836
2837 /* decref'ing the frame can cause __del__ methods to get invoked,
2838 which can call back into Python. While we're done with the
2839 current Python frame (f), the associated C stack is still in use,
2840 so recursion_depth must be boosted for the duration.
2841 */
2842 assert(tstate != NULL);
2843 ++tstate->recursion_depth;
2844 Py_DECREF(f);
2845 --tstate->recursion_depth;
2846 return retval;
2847}
2848
2849
2850/* Implementation notes for set_exc_info() and reset_exc_info():
2851
2852- Below, 'exc_ZZZ' stands for 'exc_type', 'exc_value' and
2853 'exc_traceback'. These always travel together.
2854
2855- tstate->curexc_ZZZ is the "hot" exception that is set by
2856 PyErr_SetString(), cleared by PyErr_Clear(), and so on.
2857
2858- Once an exception is caught by an except clause, it is transferred
2859 from tstate->curexc_ZZZ to tstate->exc_ZZZ, from which sys.exc_info()
2860 can pick it up. This is the primary task of set_exc_info().
2861 XXX That can't be right: set_exc_info() doesn't look at tstate->curexc_ZZZ.
2862
2863- Now let me explain the complicated dance with frame->f_exc_ZZZ.
2864
2865 Long ago, when none of this existed, there were just a few globals:
2866 one set corresponding to the "hot" exception, and one set
2867 corresponding to sys.exc_ZZZ. (Actually, the latter weren't C
2868 globals; they were simply stored as sys.exc_ZZZ. For backwards
2869 compatibility, they still are!) The problem was that in code like
2870 this:
2871
2872 try:
2873 "something that may fail"
2874 except "some exception":
2875 "do something else first"
2876 "print the exception from sys.exc_ZZZ."
2877
2878 if "do something else first" invoked something that raised and caught
2879 an exception, sys.exc_ZZZ were overwritten. That was a frequent
2880 cause of subtle bugs. I fixed this by changing the semantics as
2881 follows:
2882
2883 - Within one frame, sys.exc_ZZZ will hold the last exception caught
2884 *in that frame*.
2885
2886 - But initially, and as long as no exception is caught in a given
2887 frame, sys.exc_ZZZ will hold the last exception caught in the
2888 previous frame (or the frame before that, etc.).
2889
2890 The first bullet fixed the bug in the above example. The second
2891 bullet was for backwards compatibility: it was (and is) common to
2892 have a function that is called when an exception is caught, and to
2893 have that function access the caught exception via sys.exc_ZZZ.
2894 (Example: traceback.print_exc()).
2895
2896 At the same time I fixed the problem that sys.exc_ZZZ weren't
2897 thread-safe, by introducing sys.exc_info() which gets it from tstate;
2898 but that's really a separate improvement.
2899
2900 The reset_exc_info() function in ceval.c restores the tstate->exc_ZZZ
2901 variables to what they were before the current frame was called. The
2902 set_exc_info() function saves them on the frame so that
2903 reset_exc_info() can restore them. The invariant is that
2904 frame->f_exc_ZZZ is NULL iff the current frame never caught an
2905 exception (where "catching" an exception applies only to successful
2906 except clauses); and if the current frame ever caught an exception,
2907 frame->f_exc_ZZZ is the exception that was stored in tstate->exc_ZZZ
2908 at the start of the current frame.
2909
2910*/
2911
2912static void
2913set_exc_info(PyThreadState *tstate,
2914 PyObject *type, PyObject *value, PyObject *tb)
2915{
2916 PyFrameObject *frame = tstate->frame;
2917 PyObject *tmp_type, *tmp_value, *tmp_tb;
2918
2919 assert(type != NULL);
2920 assert(frame != NULL);
2921 if (frame->f_exc_type == NULL) {
2922 assert(frame->f_exc_value == NULL);
2923 assert(frame->f_exc_traceback == NULL);
2924 /* This frame didn't catch an exception before. */
2925 /* Save previous exception of this thread in this frame. */
2926 if (tstate->exc_type == NULL) {
2927 /* XXX Why is this set to Py_None? */
2928 Py_INCREF(Py_None);
2929 tstate->exc_type = Py_None;
2930 }
2931 Py_INCREF(tstate->exc_type);
2932 Py_XINCREF(tstate->exc_value);
2933 Py_XINCREF(tstate->exc_traceback);
2934 frame->f_exc_type = tstate->exc_type;
2935 frame->f_exc_value = tstate->exc_value;
2936 frame->f_exc_traceback = tstate->exc_traceback;
2937 }
2938 /* Set new exception for this thread. */
2939 tmp_type = tstate->exc_type;
2940 tmp_value = tstate->exc_value;
2941 tmp_tb = tstate->exc_traceback;
2942 Py_INCREF(type);
2943 Py_XINCREF(value);
2944 Py_XINCREF(tb);
2945 tstate->exc_type = type;
2946 tstate->exc_value = value;
2947 tstate->exc_traceback = tb;
2948 Py_XDECREF(tmp_type);
2949 Py_XDECREF(tmp_value);
2950 Py_XDECREF(tmp_tb);
2951 /* For b/w compatibility */
2952 PySys_SetObject("exc_type", type);
2953 PySys_SetObject("exc_value", value);
2954 PySys_SetObject("exc_traceback", tb);
2955}
2956
2957static void
2958reset_exc_info(PyThreadState *tstate)
2959{
2960 PyFrameObject *frame;
2961 PyObject *tmp_type, *tmp_value, *tmp_tb;
2962
2963 /* It's a precondition that the thread state's frame caught an
2964 * exception -- verify in a debug build.
2965 */
2966 assert(tstate != NULL);
2967 frame = tstate->frame;
2968 assert(frame != NULL);
2969 assert(frame->f_exc_type != NULL);
2970
2971 /* Copy the frame's exception info back to the thread state. */
2972 tmp_type = tstate->exc_type;
2973 tmp_value = tstate->exc_value;
2974 tmp_tb = tstate->exc_traceback;
2975 Py_INCREF(frame->f_exc_type);
2976 Py_XINCREF(frame->f_exc_value);
2977 Py_XINCREF(frame->f_exc_traceback);
2978 tstate->exc_type = frame->f_exc_type;
2979 tstate->exc_value = frame->f_exc_value;
2980 tstate->exc_traceback = frame->f_exc_traceback;
2981 Py_XDECREF(tmp_type);
2982 Py_XDECREF(tmp_value);
2983 Py_XDECREF(tmp_tb);
2984
2985 /* For b/w compatibility */
2986 PySys_SetObject("exc_type", frame->f_exc_type);
2987 PySys_SetObject("exc_value", frame->f_exc_value);
2988 PySys_SetObject("exc_traceback", frame->f_exc_traceback);
2989
2990 /* Clear the frame's exception info. */
2991 tmp_type = frame->f_exc_type;
2992 tmp_value = frame->f_exc_value;
2993 tmp_tb = frame->f_exc_traceback;
2994 frame->f_exc_type = NULL;
2995 frame->f_exc_value = NULL;
2996 frame->f_exc_traceback = NULL;
2997 Py_DECREF(tmp_type);
2998 Py_XDECREF(tmp_value);
2999 Py_XDECREF(tmp_tb);
3000}
3001
3002/* Logic for the raise statement (too complicated for inlining).
3003 This *consumes* a reference count to each of its arguments. */
3004static enum why_code
3005do_raise(PyObject *type, PyObject *value, PyObject *tb)
3006{
3007 if (type == NULL) {
3008 /* Reraise */
3009 PyThreadState *tstate = PyThreadState_GET();
3010 type = tstate->exc_type == NULL ? Py_None : tstate->exc_type;
3011 value = tstate->exc_value;
3012 tb = tstate->exc_traceback;
3013 Py_XINCREF(type);
3014 Py_XINCREF(value);
3015 Py_XINCREF(tb);
3016 }
3017
3018 /* We support the following forms of raise:
3019 raise <class>, <classinstance>
3020 raise <class>, <argument tuple>
3021 raise <class>, None
3022 raise <class>, <argument>
3023 raise <classinstance>, None
3024 raise <string>, <object>
3025 raise <string>, None
3026
3027 An omitted second argument is the same as None.
3028
3029 In addition, raise <tuple>, <anything> is the same as
3030 raising the tuple's first item (and it better have one!);
3031 this rule is applied recursively.
3032
3033 Finally, an optional third argument can be supplied, which
3034 gives the traceback to be substituted (useful when
3035 re-raising an exception after examining it). */
3036
3037 /* First, check the traceback argument, replacing None with
3038 NULL. */
3039 if (tb == Py_None) {
3040 Py_DECREF(tb);
3041 tb = NULL;
3042 }
3043 else if (tb != NULL && !PyTraceBack_Check(tb)) {
3044 PyErr_SetString(PyExc_TypeError,
3045 "raise: arg 3 must be a traceback or None");
3046 goto raise_error;
3047 }
3048
3049 /* Next, replace a missing value with None */
3050 if (value == NULL) {
3051 value = Py_None;
3052 Py_INCREF(value);
3053 }
3054
3055 /* Next, repeatedly, replace a tuple exception with its first item */
3056 while (PyTuple_Check(type) && PyTuple_Size(type) > 0) {
3057 PyObject *tmp = type;
3058 type = PyTuple_GET_ITEM(type, 0);
3059 Py_INCREF(type);
3060 Py_DECREF(tmp);
3061 }
3062
3063 if (PyString_CheckExact(type)) {
3064 /* Raising builtin string is deprecated but still allowed --
3065 * do nothing. Raising an instance of a new-style str
3066 * subclass is right out. */
3067 if (PyErr_Warn(PyExc_DeprecationWarning,
3068 "raising a string exception is deprecated"))
3069 goto raise_error;
3070 }
3071 else if (PyExceptionClass_Check(type))
3072 PyErr_NormalizeException(&type, &value, &tb);
3073
3074 else if (PyExceptionInstance_Check(type)) {
3075 /* Raising an instance. The value should be a dummy. */
3076 if (value != Py_None) {
3077 PyErr_SetString(PyExc_TypeError,
3078 "instance exception may not have a separate value");
3079 goto raise_error;
3080 }
3081 else {
3082 /* Normalize to raise <class>, <instance> */
3083 Py_DECREF(value);
3084 value = type;
3085 type = PyExceptionInstance_Class(type);
3086 Py_INCREF(type);
3087 }
3088 }
3089 else {
3090 /* Not something you can raise. You get an exception
3091 anyway, just not what you specified :-) */
3092 PyErr_Format(PyExc_TypeError,
3093 "exceptions must be classes, instances, or "
3094 "strings (deprecated), not %s",
3095 type->ob_type->tp_name);
3096 goto raise_error;
3097 }
3098 PyErr_Restore(type, value, tb);
3099 if (tb == NULL)
3100 return WHY_EXCEPTION;
3101 else
3102 return WHY_RERAISE;
3103 raise_error:
3104 Py_XDECREF(value);
3105 Py_XDECREF(type);
3106 Py_XDECREF(tb);
3107 return WHY_EXCEPTION;
3108}
3109
3110/* Iterate v argcnt times and store the results on the stack (via decreasing
3111 sp). Return 1 for success, 0 if error. */
3112
3113static int
3114unpack_iterable(PyObject *v, int argcnt, PyObject **sp)
3115{
3116 int i = 0;
3117 PyObject *it; /* iter(v) */
3118 PyObject *w;
3119
3120 assert(v != NULL);
3121
3122 it = PyObject_GetIter(v);
3123 if (it == NULL)
3124 goto Error;
3125
3126 for (; i < argcnt; i++) {
3127 w = PyIter_Next(it);
3128 if (w == NULL) {
3129 /* Iterator done, via error or exhaustion. */
3130 if (!PyErr_Occurred()) {
3131 PyErr_Format(PyExc_ValueError,
3132 "need more than %d value%s to unpack",
3133 i, i == 1 ? "" : "s");
3134 }
3135 goto Error;
3136 }
3137 *--sp = w;
3138 }
3139
3140 /* We better have exhausted the iterator now. */
3141 w = PyIter_Next(it);
3142 if (w == NULL) {
3143 if (PyErr_Occurred())
3144 goto Error;
3145 Py_DECREF(it);
3146 return 1;
3147 }
3148 Py_DECREF(w);
3149 PyErr_SetString(PyExc_ValueError, "too many values to unpack");
3150 /* fall through */
3151Error:
3152 for (; i > 0; i--, sp++)
3153 Py_DECREF(*sp);
3154 Py_XDECREF(it);
3155 return 0;
3156}
3157
3158
3159#ifdef LLTRACE
3160static int
3161prtrace(PyObject *v, char *str)
3162{
3163 printf("%s ", str);
3164 if (PyObject_Print(v, stdout, 0) != 0)
3165 PyErr_Clear(); /* Don't know what else to do */
3166 printf("\n");
3167 return 1;
3168}
3169#endif
3170
3171static void
3172call_exc_trace(Py_tracefunc func, PyObject *self, PyFrameObject *f)
3173{
3174 PyObject *type, *value, *traceback, *arg;
3175 int err;
3176 PyErr_Fetch(&type, &value, &traceback);
3177 if (value == NULL) {
3178 value = Py_None;
3179 Py_INCREF(value);
3180 }
3181 arg = PyTuple_Pack(3, type, value, traceback);
3182 if (arg == NULL) {
3183 PyErr_Restore(type, value, traceback);
3184 return;
3185 }
3186 err = call_trace(func, self, f, PyTrace_EXCEPTION, arg);
3187 Py_DECREF(arg);
3188 if (err == 0)
3189 PyErr_Restore(type, value, traceback);
3190 else {
3191 Py_XDECREF(type);
3192 Py_XDECREF(value);
3193 Py_XDECREF(traceback);
3194 }
3195}
3196
3197static void
3198call_trace_protected(Py_tracefunc func, PyObject *obj, PyFrameObject *frame,
3199 int what, PyObject *arg)
3200{
3201 PyObject *type, *value, *traceback;
3202 int err;
3203 PyErr_Fetch(&type, &value, &traceback);
3204 err = call_trace(func, obj, frame, what, arg);
3205 if (err == 0)
3206 PyErr_Restore(type, value, traceback);
3207 else {
3208 Py_XDECREF(type);
3209 Py_XDECREF(value);
3210 Py_XDECREF(traceback);
3211 }
3212}
3213
3214static int
3215call_trace(Py_tracefunc func, PyObject *obj, PyFrameObject *frame,
3216 int what, PyObject *arg)
3217{
3218 register PyThreadState *tstate = frame->f_tstate;
3219 int result;
3220 if (tstate->tracing)
3221 return 0;
3222 tstate->tracing++;
3223 tstate->use_tracing = 0;
3224 result = func(obj, frame, what, arg);
3225 tstate->use_tracing = ((tstate->c_tracefunc != NULL)
3226 || (tstate->c_profilefunc != NULL));
3227 tstate->tracing--;
3228 return result;
3229}
3230
3231PyObject *
3232_PyEval_CallTracing(PyObject *func, PyObject *args)
3233{
3234 PyFrameObject *frame = PyEval_GetFrame();
3235 PyThreadState *tstate = frame->f_tstate;
3236 int save_tracing = tstate->tracing;
3237 int save_use_tracing = tstate->use_tracing;
3238 PyObject *result;
3239
3240 tstate->tracing = 0;
3241 tstate->use_tracing = ((tstate->c_tracefunc != NULL)
3242 || (tstate->c_profilefunc != NULL));
3243 result = PyObject_Call(func, args, NULL);
3244 tstate->tracing = save_tracing;
3245 tstate->use_tracing = save_use_tracing;
3246 return result;
3247}
3248
3249static int
3250maybe_call_line_trace(Py_tracefunc func, PyObject *obj,
3251 PyFrameObject *frame, int *instr_lb, int *instr_ub,
3252 int *instr_prev)
3253{
3254 int result = 0;
3255
3256 /* If the last instruction executed isn't in the current
3257 instruction window, reset the window. If the last
3258 instruction happens to fall at the start of a line or if it
3259 represents a jump backwards, call the trace function.
3260 */
3261 if ((frame->f_lasti < *instr_lb || frame->f_lasti >= *instr_ub)) {
3262 int line;
3263 PyAddrPair bounds;
3264
3265 line = PyCode_CheckLineNumber(frame->f_code, frame->f_lasti,
3266 &bounds);
3267 if (line >= 0) {
3268 frame->f_lineno = line;
3269 result = call_trace(func, obj, frame,
3270 PyTrace_LINE, Py_None);
3271 }
3272 *instr_lb = bounds.ap_lower;
3273 *instr_ub = bounds.ap_upper;
3274 }
3275 else if (frame->f_lasti <= *instr_prev) {
3276 result = call_trace(func, obj, frame, PyTrace_LINE, Py_None);
3277 }
3278 *instr_prev = frame->f_lasti;
3279 return result;
3280}
3281
3282void
3283PyEval_SetProfile(Py_tracefunc func, PyObject *arg)
3284{
3285 PyThreadState *tstate = PyThreadState_GET();
3286 PyObject *temp = tstate->c_profileobj;
3287 Py_XINCREF(arg);
3288 tstate->c_profilefunc = NULL;
3289 tstate->c_profileobj = NULL;
3290 /* Must make sure that tracing is not ignored if 'temp' is freed */
3291 tstate->use_tracing = tstate->c_tracefunc != NULL;
3292 Py_XDECREF(temp);
3293 tstate->c_profilefunc = func;
3294 tstate->c_profileobj = arg;
3295 /* Flag that tracing or profiling is turned on */
3296 tstate->use_tracing = (func != NULL) || (tstate->c_tracefunc != NULL);
3297}
3298
3299void
3300PyEval_SetTrace(Py_tracefunc func, PyObject *arg)
3301{
3302 PyThreadState *tstate = PyThreadState_GET();
3303 PyObject *temp = tstate->c_traceobj;
3304 Py_XINCREF(arg);
3305 tstate->c_tracefunc = NULL;
3306 tstate->c_traceobj = NULL;
3307 /* Must make sure that profiling is not ignored if 'temp' is freed */
3308 tstate->use_tracing = tstate->c_profilefunc != NULL;
3309 Py_XDECREF(temp);
3310 tstate->c_tracefunc = func;
3311 tstate->c_traceobj = arg;
3312 /* Flag that tracing or profiling is turned on */
3313 tstate->use_tracing = ((func != NULL)
3314 || (tstate->c_profilefunc != NULL));
3315}
3316
3317PyObject *
3318PyEval_GetBuiltins(void)
3319{
3320 PyFrameObject *current_frame = PyEval_GetFrame();
3321 if (current_frame == NULL)
3322 return PyThreadState_GET()->interp->builtins;
3323 else
3324 return current_frame->f_builtins;
3325}
3326
3327PyObject *
3328PyEval_GetLocals(void)
3329{
3330 PyFrameObject *current_frame = PyEval_GetFrame();
3331 if (current_frame == NULL)
3332 return NULL;
3333 PyFrame_FastToLocals(current_frame);
3334 return current_frame->f_locals;
3335}
3336
3337PyObject *
3338PyEval_GetGlobals(void)
3339{
3340 PyFrameObject *current_frame = PyEval_GetFrame();
3341 if (current_frame == NULL)
3342 return NULL;
3343 else
3344 return current_frame->f_globals;
3345}
3346
3347PyFrameObject *
3348PyEval_GetFrame(void)
3349{
3350 PyThreadState *tstate = PyThreadState_GET();
3351 return _PyThreadState_GetFrame(tstate);
3352}
3353
3354int
3355PyEval_GetRestricted(void)
3356{
3357 PyFrameObject *current_frame = PyEval_GetFrame();
3358 return current_frame == NULL ? 0 : PyFrame_IsRestricted(current_frame);
3359}
3360
3361int
3362PyEval_MergeCompilerFlags(PyCompilerFlags *cf)
3363{
3364 PyFrameObject *current_frame = PyEval_GetFrame();
3365 int result = cf->cf_flags != 0;
3366
3367 if (current_frame != NULL) {
3368 const int codeflags = current_frame->f_code->co_flags;
3369 const int compilerflags = codeflags & PyCF_MASK;
3370 if (compilerflags) {
3371 result = 1;
3372 cf->cf_flags |= compilerflags;
3373 }
3374#if 0 /* future keyword */
3375 if (codeflags & CO_GENERATOR_ALLOWED) {
3376 result = 1;
3377 cf->cf_flags |= CO_GENERATOR_ALLOWED;
3378 }
3379#endif
3380 }
3381 return result;
3382}
3383
3384int
3385Py_FlushLine(void)
3386{
3387 PyObject *f = PySys_GetObject("stdout");
3388 if (f == NULL)
3389 return 0;
3390 if (!PyFile_SoftSpace(f, 0))
3391 return 0;
3392 return PyFile_WriteString("\n", f);
3393}
3394
3395
3396/* External interface to call any callable object.
3397 The arg must be a tuple or NULL. */
3398
3399#undef PyEval_CallObject
3400/* for backward compatibility: export this interface */
3401
3402PyObject *
3403PyEval_CallObject(PyObject *func, PyObject *arg)
3404{
3405 return PyEval_CallObjectWithKeywords(func, arg, (PyObject *)NULL);
3406}
3407#define PyEval_CallObject(func,arg) \
3408 PyEval_CallObjectWithKeywords(func, arg, (PyObject *)NULL)
3409
3410PyObject *
3411PyEval_CallObjectWithKeywords(PyObject *func, PyObject *arg, PyObject *kw)
3412{
3413 PyObject *result;
3414
3415 if (arg == NULL) {
3416 arg = PyTuple_New(0);
3417 if (arg == NULL)
3418 return NULL;
3419 }
3420 else if (!PyTuple_Check(arg)) {
3421 PyErr_SetString(PyExc_TypeError,
3422 "argument list must be a tuple");
3423 return NULL;
3424 }
3425 else
3426 Py_INCREF(arg);
3427
3428 if (kw != NULL && !PyDict_Check(kw)) {
3429 PyErr_SetString(PyExc_TypeError,
3430 "keyword list must be a dictionary");
3431 Py_DECREF(arg);
3432 return NULL;
3433 }
3434
3435 result = PyObject_Call(func, arg, kw);
3436 Py_DECREF(arg);
3437 return result;
3438}
3439
3440const char *
3441PyEval_GetFuncName(PyObject *func)
3442{
3443 if (PyMethod_Check(func))
3444 return PyEval_GetFuncName(PyMethod_GET_FUNCTION(func));
3445 else if (PyFunction_Check(func))
3446 return PyString_AsString(((PyFunctionObject*)func)->func_name);
3447 else if (PyCFunction_Check(func))
3448 return ((PyCFunctionObject*)func)->m_ml->ml_name;
3449 else if (PyClass_Check(func))
3450 return PyString_AsString(((PyClassObject*)func)->cl_name);
3451 else if (PyInstance_Check(func)) {
3452 return PyString_AsString(
3453 ((PyInstanceObject*)func)->in_class->cl_name);
3454 } else {
3455 return func->ob_type->tp_name;
3456 }
3457}
3458
3459const char *
3460PyEval_GetFuncDesc(PyObject *func)
3461{
3462 if (PyMethod_Check(func))
3463 return "()";
3464 else if (PyFunction_Check(func))
3465 return "()";
3466 else if (PyCFunction_Check(func))
3467 return "()";
3468 else if (PyClass_Check(func))
3469 return " constructor";
3470 else if (PyInstance_Check(func)) {
3471 return " instance";
3472 } else {
3473 return " object";
3474 }
3475}
3476
3477static void
3478err_args(PyObject *func, int flags, int nargs)
3479{
3480 if (flags & METH_NOARGS)
3481 PyErr_Format(PyExc_TypeError,
3482 "%.200s() takes no arguments (%d given)",
3483 ((PyCFunctionObject *)func)->m_ml->ml_name,
3484 nargs);
3485 else
3486 PyErr_Format(PyExc_TypeError,
3487 "%.200s() takes exactly one argument (%d given)",
3488 ((PyCFunctionObject *)func)->m_ml->ml_name,
3489 nargs);
3490}
3491
3492#define C_TRACE(x, call) \
3493if (tstate->use_tracing && tstate->c_profilefunc) { \
3494 if (call_trace(tstate->c_profilefunc, \
3495 tstate->c_profileobj, \
3496 tstate->frame, PyTrace_C_CALL, \
3497 func)) { \
3498 x = NULL; \
3499 } \
3500 else { \
3501 x = call; \
3502 if (tstate->c_profilefunc != NULL) { \
3503 if (x == NULL) { \
3504 call_trace_protected(tstate->c_profilefunc, \
3505 tstate->c_profileobj, \
3506 tstate->frame, PyTrace_C_EXCEPTION, \
3507 func); \
3508 /* XXX should pass (type, value, tb) */ \
3509 } else { \
3510 if (call_trace(tstate->c_profilefunc, \
3511 tstate->c_profileobj, \
3512 tstate->frame, PyTrace_C_RETURN, \
3513 func)) { \
3514 Py_DECREF(x); \
3515 x = NULL; \
3516 } \
3517 } \
3518 } \
3519 } \
3520} else { \
3521 x = call; \
3522 }
3523
3524static PyObject *
3525call_function(PyObject ***pp_stack, int oparg
3526#ifdef WITH_TSC
3527 , uint64* pintr0, uint64* pintr1
3528#endif
3529 )
3530{
3531 int na = oparg & 0xff;
3532 int nk = (oparg>>8) & 0xff;
3533 int n = na + 2 * nk;
3534 PyObject **pfunc = (*pp_stack) - n - 1;
3535 PyObject *func = *pfunc;
3536 PyObject *x, *w;
3537
3538 /* Always dispatch PyCFunction first, because these are
3539 presumed to be the most frequent callable object.
3540 */
3541 if (PyCFunction_Check(func) && nk == 0) {
3542 int flags = PyCFunction_GET_FLAGS(func);
3543 PyThreadState *tstate = PyThreadState_GET();
3544
3545 PCALL(PCALL_CFUNCTION);
3546 if (flags & (METH_NOARGS | METH_O)) {
3547 PyCFunction meth = PyCFunction_GET_FUNCTION(func);
3548 PyObject *self = PyCFunction_GET_SELF(func);
3549 if (flags & METH_NOARGS && na == 0) {
3550 C_TRACE(x, (*meth)(self,NULL));
3551 }
3552 else if (flags & METH_O && na == 1) {
3553 PyObject *arg = EXT_POP(*pp_stack);
3554 C_TRACE(x, (*meth)(self,arg));
3555 Py_DECREF(arg);
3556 }
3557 else {
3558 err_args(func, flags, na);
3559 x = NULL;
3560 }
3561 }
3562 else {
3563 PyObject *callargs;
3564 callargs = load_args(pp_stack, na);
3565 READ_TIMESTAMP(*pintr0);
3566 C_TRACE(x, PyCFunction_Call(func,callargs,NULL));
3567 READ_TIMESTAMP(*pintr1);
3568 Py_XDECREF(callargs);
3569 }
3570 } else {
3571 if (PyMethod_Check(func) && PyMethod_GET_SELF(func) != NULL) {
3572 /* optimize access to bound methods */
3573 PyObject *self = PyMethod_GET_SELF(func);
3574 PCALL(PCALL_METHOD);
3575 PCALL(PCALL_BOUND_METHOD);
3576 Py_INCREF(self);
3577 func = PyMethod_GET_FUNCTION(func);
3578 Py_INCREF(func);
3579 Py_DECREF(*pfunc);
3580 *pfunc = self;
3581 na++;
3582 n++;
3583 } else
3584 Py_INCREF(func);
3585 READ_TIMESTAMP(*pintr0);
3586 if (PyFunction_Check(func))
3587 x = fast_function(func, pp_stack, n, na, nk);
3588 else
3589 x = do_call(func, pp_stack, na, nk);
3590 READ_TIMESTAMP(*pintr1);
3591 Py_DECREF(func);
3592 }
3593
3594 /* Clear the stack of the function object. Also removes
3595 the arguments in case they weren't consumed already
3596 (fast_function() and err_args() leave them on the stack).
3597 */
3598 while ((*pp_stack) > pfunc) {
3599 w = EXT_POP(*pp_stack);
3600 Py_DECREF(w);
3601 PCALL(PCALL_POP);
3602 }
3603 return x;
3604}
3605
3606/* The fast_function() function optimize calls for which no argument
3607 tuple is necessary; the objects are passed directly from the stack.
3608 For the simplest case -- a function that takes only positional
3609 arguments and is called with only positional arguments -- it
3610 inlines the most primitive frame setup code from
3611 PyEval_EvalCodeEx(), which vastly reduces the checks that must be
3612 done before evaluating the frame.
3613*/
3614
3615static PyObject *
3616fast_function(PyObject *func, PyObject ***pp_stack, int n, int na, int nk)
3617{
3618 PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
3619 PyObject *globals = PyFunction_GET_GLOBALS(func);
3620 PyObject *argdefs = PyFunction_GET_DEFAULTS(func);
3621 PyObject **d = NULL;
3622 int nd = 0;
3623
3624 PCALL(PCALL_FUNCTION);
3625 PCALL(PCALL_FAST_FUNCTION);
3626 if (argdefs == NULL && co->co_argcount == n && nk==0 &&
3627 co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) {
3628 PyFrameObject *f;
3629 PyObject *retval = NULL;
3630 PyThreadState *tstate = PyThreadState_GET();
3631 PyObject **fastlocals, **stack;
3632 int i;
3633
3634 PCALL(PCALL_FASTER_FUNCTION);
3635 assert(globals != NULL);
3636 /* XXX Perhaps we should create a specialized
3637 PyFrame_New() that doesn't take locals, but does
3638 take builtins without sanity checking them.
3639 */
3640 assert(tstate != NULL);
3641 f = PyFrame_New(tstate, co, globals, NULL);
3642 if (f == NULL)
3643 return NULL;
3644
3645 fastlocals = f->f_localsplus;
3646 stack = (*pp_stack) - n;
3647
3648 for (i = 0; i < n; i++) {
3649 Py_INCREF(*stack);
3650 fastlocals[i] = *stack++;
3651 }
3652 retval = PyEval_EvalFrameEx(f,0);
3653 ++tstate->recursion_depth;
3654 Py_DECREF(f);
3655 --tstate->recursion_depth;
3656 return retval;
3657 }
3658 if (argdefs != NULL) {
3659 d = &PyTuple_GET_ITEM(argdefs, 0);
3660 nd = ((PyTupleObject *)argdefs)->ob_size;
3661 }
3662 return PyEval_EvalCodeEx(co, globals,
3663 (PyObject *)NULL, (*pp_stack)-n, na,
3664 (*pp_stack)-2*nk, nk, d, nd,
3665 PyFunction_GET_CLOSURE(func));
3666}
3667
3668static PyObject *
3669update_keyword_args(PyObject *orig_kwdict, int nk, PyObject ***pp_stack,
3670 PyObject *func)
3671{
3672 PyObject *kwdict = NULL;
3673 if (orig_kwdict == NULL)
3674 kwdict = PyDict_New();
3675 else {
3676 kwdict = PyDict_Copy(orig_kwdict);
3677 Py_DECREF(orig_kwdict);
3678 }
3679 if (kwdict == NULL)
3680 return NULL;
3681 while (--nk >= 0) {
3682 int err;
3683 PyObject *value = EXT_POP(*pp_stack);
3684 PyObject *key = EXT_POP(*pp_stack);
3685 if (PyDict_GetItem(kwdict, key) != NULL) {
3686 PyErr_Format(PyExc_TypeError,
3687 "%.200s%s got multiple values "
3688 "for keyword argument '%.200s'",
3689 PyEval_GetFuncName(func),
3690 PyEval_GetFuncDesc(func),
3691 PyString_AsString(key));
3692 Py_DECREF(key);
3693 Py_DECREF(value);
3694 Py_DECREF(kwdict);
3695 return NULL;
3696 }
3697 err = PyDict_SetItem(kwdict, key, value);
3698 Py_DECREF(key);
3699 Py_DECREF(value);
3700 if (err) {
3701 Py_DECREF(kwdict);
3702 return NULL;
3703 }
3704 }
3705 return kwdict;
3706}
3707
3708static PyObject *
3709update_star_args(int nstack, int nstar, PyObject *stararg,
3710 PyObject ***pp_stack)
3711{
3712 PyObject *callargs, *w;
3713
3714 callargs = PyTuple_New(nstack + nstar);
3715 if (callargs == NULL) {
3716 return NULL;
3717 }
3718 if (nstar) {
3719 int i;
3720 for (i = 0; i < nstar; i++) {
3721 PyObject *a = PyTuple_GET_ITEM(stararg, i);
3722 Py_INCREF(a);
3723 PyTuple_SET_ITEM(callargs, nstack + i, a);
3724 }
3725 }
3726 while (--nstack >= 0) {
3727 w = EXT_POP(*pp_stack);
3728 PyTuple_SET_ITEM(callargs, nstack, w);
3729 }
3730 return callargs;
3731}
3732
3733static PyObject *
3734load_args(PyObject ***pp_stack, int na)
3735{
3736 PyObject *args = PyTuple_New(na);
3737 PyObject *w;
3738
3739 if (args == NULL)
3740 return NULL;
3741 while (--na >= 0) {
3742 w = EXT_POP(*pp_stack);
3743 PyTuple_SET_ITEM(args, na, w);
3744 }
3745 return args;
3746}
3747
3748static PyObject *
3749do_call(PyObject *func, PyObject ***pp_stack, int na, int nk)
3750{
3751 PyObject *callargs = NULL;
3752 PyObject *kwdict = NULL;
3753 PyObject *result = NULL;
3754
3755 if (nk > 0) {
3756 kwdict = update_keyword_args(NULL, nk, pp_stack, func);
3757 if (kwdict == NULL)
3758 goto call_fail;
3759 }
3760 callargs = load_args(pp_stack, na);
3761 if (callargs == NULL)
3762 goto call_fail;
3763#ifdef CALL_PROFILE
3764 /* At this point, we have to look at the type of func to
3765 update the call stats properly. Do it here so as to avoid
3766 exposing the call stats machinery outside ceval.c
3767 */
3768 if (PyFunction_Check(func))
3769 PCALL(PCALL_FUNCTION);
3770 else if (PyMethod_Check(func))
3771 PCALL(PCALL_METHOD);
3772 else if (PyType_Check(func))
3773 PCALL(PCALL_TYPE);
3774 else
3775 PCALL(PCALL_OTHER);
3776#endif
3777 result = PyObject_Call(func, callargs, kwdict);
3778 call_fail:
3779 Py_XDECREF(callargs);
3780 Py_XDECREF(kwdict);
3781 return result;
3782}
3783
3784static PyObject *
3785ext_do_call(PyObject *func, PyObject ***pp_stack, int flags, int na, int nk)
3786{
3787 int nstar = 0;
3788 PyObject *callargs = NULL;
3789 PyObject *stararg = NULL;
3790 PyObject *kwdict = NULL;
3791 PyObject *result = NULL;
3792
3793 if (flags & CALL_FLAG_KW) {
3794 kwdict = EXT_POP(*pp_stack);
3795 if (!(kwdict && PyDict_Check(kwdict))) {
3796 PyErr_Format(PyExc_TypeError,
3797 "%s%s argument after ** "
3798 "must be a dictionary",
3799 PyEval_GetFuncName(func),
3800 PyEval_GetFuncDesc(func));
3801 goto ext_call_fail;
3802 }
3803 }
3804 if (flags & CALL_FLAG_VAR) {
3805 stararg = EXT_POP(*pp_stack);
3806 if (!PyTuple_Check(stararg)) {
3807 PyObject *t = NULL;
3808 t = PySequence_Tuple(stararg);
3809 if (t == NULL) {
3810 if (PyErr_ExceptionMatches(PyExc_TypeError)) {
3811 PyErr_Format(PyExc_TypeError,
3812 "%s%s argument after * "
3813 "must be a sequence",
3814 PyEval_GetFuncName(func),
3815 PyEval_GetFuncDesc(func));
3816 }
3817 goto ext_call_fail;
3818 }
3819 Py_DECREF(stararg);
3820 stararg = t;
3821 }
3822 nstar = PyTuple_GET_SIZE(stararg);
3823 }
3824 if (nk > 0) {
3825 kwdict = update_keyword_args(kwdict, nk, pp_stack, func);
3826 if (kwdict == NULL)
3827 goto ext_call_fail;
3828 }
3829 callargs = update_star_args(na, nstar, stararg, pp_stack);
3830 if (callargs == NULL)
3831 goto ext_call_fail;
3832#ifdef CALL_PROFILE
3833 /* At this point, we have to look at the type of func to
3834 update the call stats properly. Do it here so as to avoid
3835 exposing the call stats machinery outside ceval.c
3836 */
3837 if (PyFunction_Check(func))
3838 PCALL(PCALL_FUNCTION);
3839 else if (PyMethod_Check(func))
3840 PCALL(PCALL_METHOD);
3841 else if (PyType_Check(func))
3842 PCALL(PCALL_TYPE);
3843 else
3844 PCALL(PCALL_OTHER);
3845#endif
3846 result = PyObject_Call(func, callargs, kwdict);
3847 ext_call_fail:
3848 Py_XDECREF(callargs);
3849 Py_XDECREF(kwdict);
3850 Py_XDECREF(stararg);
3851 return result;
3852}
3853
3854/* Extract a slice index from a PyInt or PyLong or an object with the
3855 nb_index slot defined, and store in *pi.
3856 Silently reduce values larger than PY_SSIZE_T_MAX to PY_SSIZE_T_MAX,
3857 and silently boost values less than -PY_SSIZE_T_MAX-1 to -PY_SSIZE_T_MAX-1.
3858 Return 0 on error, 1 on success.
3859*/
3860/* Note: If v is NULL, return success without storing into *pi. This
3861 is because_PyEval_SliceIndex() is called by apply_slice(), which can be
3862 called by the SLICE opcode with v and/or w equal to NULL.
3863*/
3864int
3865_PyEval_SliceIndex(PyObject *v, Py_ssize_t *pi)
3866{
3867 if (v != NULL) {
3868 Py_ssize_t x;
3869 if (PyInt_Check(v)) {
3870 /* XXX(nnorwitz): I think PyInt_AS_LONG is correct,
3871 however, it looks like it should be AsSsize_t.
3872 There should be a comment here explaining why.
3873 */
3874 x = PyInt_AS_LONG(v);
3875 }
3876 else if (PyIndex_Check(v)) {
3877 x = PyNumber_AsSsize_t(v, NULL);
3878 if (x == -1 && PyErr_Occurred())
3879 return 0;
3880 }
3881 else {
3882 PyErr_SetString(PyExc_TypeError,
3883 "slice indices must be integers or "
3884 "None or have an __index__ method");
3885 return 0;
3886 }
3887 *pi = x;
3888 }
3889 return 1;
3890}
3891
3892#undef ISINDEX
3893#define ISINDEX(x) ((x) == NULL || \
3894 PyInt_Check(x) || PyLong_Check(x) || PyIndex_Check(x))
3895
3896static PyObject *
3897apply_slice(PyObject *u, PyObject *v, PyObject *w) /* return u[v:w] */
3898{
3899 PyTypeObject *tp = u->ob_type;
3900 PySequenceMethods *sq = tp->tp_as_sequence;
3901
3902 if (sq && sq->sq_slice && ISINDEX(v) && ISINDEX(w)) {
3903 Py_ssize_t ilow = 0, ihigh = PY_SSIZE_T_MAX;
3904 if (!_PyEval_SliceIndex(v, &ilow))
3905 return NULL;
3906 if (!_PyEval_SliceIndex(w, &ihigh))
3907 return NULL;
3908 return PySequence_GetSlice(u, ilow, ihigh);
3909 }
3910 else {
3911 PyObject *slice = PySlice_New(v, w, NULL);
3912 if (slice != NULL) {
3913 PyObject *res = PyObject_GetItem(u, slice);
3914 Py_DECREF(slice);
3915 return res;
3916 }
3917 else
3918 return NULL;
3919 }
3920}
3921
3922static int
3923assign_slice(PyObject *u, PyObject *v, PyObject *w, PyObject *x)
3924 /* u[v:w] = x */
3925{
3926 PyTypeObject *tp = u->ob_type;
3927 PySequenceMethods *sq = tp->tp_as_sequence;
3928
3929 if (sq && sq->sq_slice && ISINDEX(v) && ISINDEX(w)) {
3930 Py_ssize_t ilow = 0, ihigh = PY_SSIZE_T_MAX;
3931 if (!_PyEval_SliceIndex(v, &ilow))
3932 return -1;
3933 if (!_PyEval_SliceIndex(w, &ihigh))
3934 return -1;
3935 if (x == NULL)
3936 return PySequence_DelSlice(u, ilow, ihigh);
3937 else
3938 return PySequence_SetSlice(u, ilow, ihigh, x);
3939 }
3940 else {
3941 PyObject *slice = PySlice_New(v, w, NULL);
3942 if (slice != NULL) {
3943 int res;
3944 if (x != NULL)
3945 res = PyObject_SetItem(u, slice, x);
3946 else
3947 res = PyObject_DelItem(u, slice);
3948 Py_DECREF(slice);
3949 return res;
3950 }
3951 else
3952 return -1;
3953 }
3954}
3955
3956static PyObject *
3957cmp_outcome(int op, register PyObject *v, register PyObject *w)
3958{
3959 int res = 0;
3960 switch (op) {
3961 case PyCmp_IS:
3962 res = (v == w);
3963 break;
3964 case PyCmp_IS_NOT:
3965 res = (v != w);
3966 break;
3967 case PyCmp_IN:
3968 res = PySequence_Contains(w, v);
3969 if (res < 0)
3970 return NULL;
3971 break;
3972 case PyCmp_NOT_IN:
3973 res = PySequence_Contains(w, v);
3974 if (res < 0)
3975 return NULL;
3976 res = !res;
3977 break;
3978 case PyCmp_EXC_MATCH:
3979 res = PyErr_GivenExceptionMatches(v, w);
3980 break;
3981 default:
3982 return PyObject_RichCompare(v, w, op);
3983 }
3984 v = res ? Py_True : Py_False;
3985 Py_INCREF(v);
3986 return v;
3987}
3988
3989static PyObject *
3990import_from(PyObject *v, PyObject *name)
3991{
3992 PyObject *x;
3993
3994 x = PyObject_GetAttr(v, name);
3995 if (x == NULL && PyErr_ExceptionMatches(PyExc_AttributeError)) {
3996 PyErr_Format(PyExc_ImportError,
3997 "cannot import name %.230s",
3998 PyString_AsString(name));
3999 }
4000 return x;
4001}
4002
4003static int
4004import_all_from(PyObject *locals, PyObject *v)
4005{
4006 PyObject *all = PyObject_GetAttrString(v, "__all__");
4007 PyObject *dict, *name, *value;
4008 int skip_leading_underscores = 0;
4009 int pos, err;
4010
4011 if (all == NULL) {
4012 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
4013 return -1; /* Unexpected error */
4014 PyErr_Clear();
4015 dict = PyObject_GetAttrString(v, "__dict__");
4016 if (dict == NULL) {
4017 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
4018 return -1;
4019 PyErr_SetString(PyExc_ImportError,
4020 "from-import-* object has no __dict__ and no __all__");
4021 return -1;
4022 }
4023 all = PyMapping_Keys(dict);
4024 Py_DECREF(dict);
4025 if (all == NULL)
4026 return -1;
4027 skip_leading_underscores = 1;
4028 }
4029
4030 for (pos = 0, err = 0; ; pos++) {
4031 name = PySequence_GetItem(all, pos);
4032 if (name == NULL) {
4033 if (!PyErr_ExceptionMatches(PyExc_IndexError))
4034 err = -1;
4035 else
4036 PyErr_Clear();
4037 break;
4038 }
4039 if (skip_leading_underscores &&
4040 PyString_Check(name) &&
4041 PyString_AS_STRING(name)[0] == '_')
4042 {
4043 Py_DECREF(name);
4044 continue;
4045 }
4046 value = PyObject_GetAttr(v, name);
4047 if (value == NULL)
4048 err = -1;
4049 else
4050 err = PyDict_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 cf.cf_flags = 0;
4175 if (PyEval_MergeCompilerFlags(&cf))
4176 v = PyRun_FileFlags(fp, name, Py_file_input, globals,
4177 locals, &cf);
4178 else
4179 v = PyRun_File(fp, name, Py_file_input, globals,
4180 locals);
4181 }
4182 else {
4183 PyObject *tmp = NULL;
4184 char *str;
4185 PyCompilerFlags cf;
4186 cf.cf_flags = 0;
4187#ifdef Py_USING_UNICODE
4188 if (PyUnicode_Check(prog)) {
4189 tmp = PyUnicode_AsUTF8String(prog);
4190 if (tmp == NULL)
4191 return -1;
4192 prog = tmp;
4193 cf.cf_flags |= PyCF_SOURCE_IS_UTF8;
4194 }
4195#endif
4196 if (PyString_AsStringAndSize(prog, &str, NULL))
4197 return -1;
4198 if (PyEval_MergeCompilerFlags(&cf))
4199 v = PyRun_StringFlags(str, Py_file_input, globals,
4200 locals, &cf);
4201 else
4202 v = PyRun_String(str, Py_file_input, globals, locals);
4203 Py_XDECREF(tmp);
4204 }
4205 if (plain)
4206 PyFrame_LocalsToFast(f, 0);
4207 if (v == NULL)
4208 return -1;
4209 Py_DECREF(v);
4210 return 0;
4211}
4212
4213static void
4214format_exc_check_arg(PyObject *exc, char *format_str, PyObject *obj)
4215{
4216 char *obj_str;
4217
4218 if (!obj)
4219 return;
4220
4221 obj_str = PyString_AsString(obj);
4222 if (!obj_str)
4223 return;
4224
4225 PyErr_Format(exc, format_str, obj_str);
4226}
4227
4228static PyObject *
4229string_concatenate(PyObject *v, PyObject *w,
4230 PyFrameObject *f, unsigned char *next_instr)
4231{
4232 /* This function implements 'variable += expr' when both arguments
4233 are strings. */
4234 Py_ssize_t v_len = PyString_GET_SIZE(v);
4235 Py_ssize_t w_len = PyString_GET_SIZE(w);
4236 Py_ssize_t new_len = v_len + w_len;
4237 if (new_len < 0) {
4238 PyErr_SetString(PyExc_OverflowError,
4239 "strings are too large to concat");
4240 return NULL;
4241 }
4242
4243 if (v->ob_refcnt == 2) {
4244 /* In the common case, there are 2 references to the value
4245 * stored in 'variable' when the += is performed: one on the
4246 * value stack (in 'v') and one still stored in the 'variable'.
4247 * We try to delete the variable now to reduce the refcnt to 1.
4248 */
4249 switch (*next_instr) {
4250 case STORE_FAST:
4251 {
4252 int oparg = PEEKARG();
4253 PyObject **fastlocals = f->f_localsplus;
4254 if (GETLOCAL(oparg) == v)
4255 SETLOCAL(oparg, NULL);
4256 break;
4257 }
4258 case STORE_DEREF:
4259 {
4260 PyObject **freevars = f->f_localsplus + f->f_code->co_nlocals;
4261 PyObject *c = freevars[PEEKARG()];
4262 if (PyCell_GET(c) == v)
4263 PyCell_Set(c, NULL);
4264 break;
4265 }
4266 case STORE_NAME:
4267 {
4268 PyObject *names = f->f_code->co_names;
4269 PyObject *name = GETITEM(names, PEEKARG());
4270 PyObject *locals = f->f_locals;
4271 if (PyDict_CheckExact(locals) &&
4272 PyDict_GetItem(locals, name) == v) {
4273 if (PyDict_DelItem(locals, name) != 0) {
4274 PyErr_Clear();
4275 }
4276 }
4277 break;
4278 }
4279 }
4280 }
4281
4282 if (v->ob_refcnt == 1 && !PyString_CHECK_INTERNED(v)) {
4283 /* Now we own the last reference to 'v', so we can resize it
4284 * in-place.
4285 */
4286 if (_PyString_Resize(&v, new_len) != 0) {
4287 /* XXX if _PyString_Resize() fails, 'v' has been
4288 * deallocated so it cannot be put back into 'variable'.
4289 * The MemoryError is raised when there is no value in
4290 * 'variable', which might (very remotely) be a cause
4291 * of incompatibilities.
4292 */
4293 return NULL;
4294 }
4295 /* copy 'w' into the newly allocated area of 'v' */
4296 memcpy(PyString_AS_STRING(v) + v_len,
4297 PyString_AS_STRING(w), w_len);
4298 return v;
4299 }
4300 else {
4301 /* When in-place resizing is not an option. */
4302 PyString_Concat(&v, w);
4303 return v;
4304 }
4305}
4306
4307#ifdef DYNAMIC_EXECUTION_PROFILE
4308
4309static PyObject *
4310getarray(long a[256])
4311{
4312 int i;
4313 PyObject *l = PyList_New(256);
4314 if (l == NULL) return NULL;
4315 for (i = 0; i < 256; i++) {
4316 PyObject *x = PyInt_FromLong(a[i]);
4317 if (x == NULL) {
4318 Py_DECREF(l);
4319 return NULL;
4320 }
4321 PyList_SetItem(l, i, x);
4322 }
4323 for (i = 0; i < 256; i++)
4324 a[i] = 0;
4325 return l;
4326}
4327
4328PyObject *
4329_Py_GetDXProfile(PyObject *self, PyObject *args)
4330{
4331#ifndef DXPAIRS
4332 return getarray(dxp);
4333#else
4334 int i;
4335 PyObject *l = PyList_New(257);
4336 if (l == NULL) return NULL;
4337 for (i = 0; i < 257; i++) {
4338 PyObject *x = getarray(dxpairs[i]);
4339 if (x == NULL) {
4340 Py_DECREF(l);
4341 return NULL;
4342 }
4343 PyList_SetItem(l, i, x);
4344 }
4345 return l;
4346#endif
4347}
4348
4349#endif
Note: See TracBrowser for help on using the repository browser.