History

add hg and python

cinap_lenrek committed 15 years ago

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

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

Unified · Split

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