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