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