14710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 24710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Execute compiled code */ 34710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 44710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* XXX TO DO: 54710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm XXX speed up searching for keywords by using a dictionary 64710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm XXX document it! 74710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 84710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 94710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* enable more aggressive intra-module optimizations, where available */ 104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define PY_LOCAL_AGGRESSIVE 114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#include "Python.h" 134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#include "code.h" 154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#include "frameobject.h" 164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#include "eval.h" 174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#include "opcode.h" 184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#include "structmember.h" 194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#include <ctype.h> 214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifndef WITH_TSC 234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define READ_TIMESTAMP(var) 254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#else 274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmtypedef unsigned long long uint64; 294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* PowerPC support. 314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "__ppc__" appears to be the preprocessor definition to detect on OS X, whereas 324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "__powerpc__" appears to be the correct one for Linux with GCC 334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm*/ 344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#if defined(__ppc__) || defined (__powerpc__) 354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define READ_TIMESTAMP(var) ppc_getcounter(&var) 374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic void 394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmppc_getcounter(uint64 *v) 404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm register unsigned long tbu, tb, tbu2; 424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm loop: 444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm asm volatile ("mftbu %0" : "=r" (tbu) ); 454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm asm volatile ("mftb %0" : "=r" (tb) ); 464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm asm volatile ("mftbu %0" : "=r" (tbu2)); 474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (__builtin_expect(tbu != tbu2, 0)) goto loop; 484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* The slightly peculiar way of writing the next lines is 504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm compiled better by GCC than any other way I tried. */ 514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ((long*)(v))[0] = tbu; 524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ((long*)(v))[1] = tb; 534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#elif defined(__i386__) 564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* this is for linux/x86 (and probably any other GCC/x86 combo) */ 584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define READ_TIMESTAMP(val) \ 604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm __asm__ __volatile__("rdtsc" : "=A" (val)) 614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#elif defined(__x86_64__) 634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* for gcc/x86_64, the "A" constraint in DI mode means *either* rax *or* rdx; 654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm not edx:eax as it does for i386. Since rdtsc puts its result in edx:eax 664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm even in 64-bit mode, we need to use "a" and "d" for the lower and upper 674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 32-bit pieces of the result. */ 684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define READ_TIMESTAMP(val) \ 704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm __asm__ __volatile__("rdtsc" : \ 714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "=a" (((int*)&(val))[0]), "=d" (((int*)&(val))[1])); 724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#else 754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#error "Don't know how to implement timestamp counter for this architecture" 774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmvoid dump_tsc(int opcode, int ticked, uint64 inst0, uint64 inst1, 814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm uint64 loop0, uint64 loop1, uint64 intr0, uint64 intr1) 824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm uint64 intr, inst, loop; 844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyThreadState *tstate = PyThreadState_Get(); 854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!tstate->interp->tscdump) 864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return; 874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm intr = intr1 - intr0; 884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm inst = inst1 - inst0 - intr; 894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm loop = loop1 - loop0 - intr; 904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fprintf(stderr, "opcode=%03d t=%d inst=%06lld loop=%06lld\n", 914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm opcode, ticked, inst, loop); 924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Turn this on if your compiler chokes on the big switch: */ 974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* #define CASE_TOO_BIG 1 */ 984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef Py_DEBUG 1004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* For debugging the interpreter: */ 1014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define LLTRACE 1 /* Low-level trace feature */ 1024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define CHECKEXC 1 /* Double-check exception checking */ 1034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 1044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmtypedef PyObject *(*callproc)(PyObject *, PyObject *, PyObject *); 1064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Forward declarations */ 1084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef WITH_TSC 1094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * call_function(PyObject ***, int, uint64*, uint64*); 1104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#else 1114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * call_function(PyObject ***, int); 1124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 1134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * fast_function(PyObject *, PyObject ***, int, int, int); 1144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * do_call(PyObject *, PyObject ***, int, int); 1154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * ext_do_call(PyObject *, PyObject ***, int, int, int); 1164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * update_keyword_args(PyObject *, int, PyObject ***, 1174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *); 1184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * update_star_args(int, int, PyObject *, PyObject ***); 1194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * load_args(PyObject ***, int); 1204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define CALL_FLAG_VAR 1 1214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define CALL_FLAG_KW 2 1224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef LLTRACE 1244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int lltrace; 1254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int prtrace(PyObject *, char *); 1264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 1274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int call_trace(Py_tracefunc, PyObject *, PyFrameObject *, 1284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int, PyObject *); 1294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int call_trace_protected(Py_tracefunc, PyObject *, 1304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFrameObject *, int, PyObject *); 1314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic void call_exc_trace(Py_tracefunc, PyObject *, PyFrameObject *); 1324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int maybe_call_line_trace(Py_tracefunc, PyObject *, 1334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFrameObject *, int *, int *, int *); 1344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * apply_slice(PyObject *, PyObject *, PyObject *); 1364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int assign_slice(PyObject *, PyObject *, 1374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *, PyObject *); 1384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * cmp_outcome(int, PyObject *, PyObject *); 1394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * import_from(PyObject *, PyObject *); 1404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int import_all_from(PyObject *, PyObject *); 1414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * build_class(PyObject *, PyObject *, PyObject *); 1424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int exec_statement(PyFrameObject *, 1434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *, PyObject *, PyObject *); 1444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic void set_exc_info(PyThreadState *, PyObject *, PyObject *, PyObject *); 1454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic void reset_exc_info(PyThreadState *); 1464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic void format_exc_check_arg(PyObject *, char *, PyObject *); 1474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * string_concatenate(PyObject *, PyObject *, 1484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFrameObject *, unsigned char *); 1494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * kwd_as_string(PyObject *); 1504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * special_lookup(PyObject *, char *, PyObject **); 1514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define NAME_ERROR_MSG \ 1534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "name '%.200s' is not defined" 1544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define GLOBAL_NAME_ERROR_MSG \ 1554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "global name '%.200s' is not defined" 1564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define UNBOUNDLOCAL_ERROR_MSG \ 1574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "local variable '%.200s' referenced before assignment" 1584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define UNBOUNDFREE_ERROR_MSG \ 1594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "free variable '%.200s' referenced before assignment" \ 1604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm " in enclosing scope" 1614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Dynamic execution profile */ 1634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef DYNAMIC_EXECUTION_PROFILE 1644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef DXPAIRS 1654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic long dxpairs[257][256]; 1664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define dxp dxpairs[256] 1674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#else 1684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic long dxp[256]; 1694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 1704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 1714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Function call profile */ 1734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef CALL_PROFILE 1744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define PCALL_NUM 11 1754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int pcall[PCALL_NUM]; 1764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define PCALL_ALL 0 1784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define PCALL_FUNCTION 1 1794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define PCALL_FAST_FUNCTION 2 1804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define PCALL_FASTER_FUNCTION 3 1814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define PCALL_METHOD 4 1824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define PCALL_BOUND_METHOD 5 1834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define PCALL_CFUNCTION 6 1844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define PCALL_TYPE 7 1854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define PCALL_GENERATOR 8 1864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define PCALL_OTHER 9 1874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define PCALL_POP 10 1884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Notes about the statistics 1904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PCALL_FAST stats 1924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FAST_FUNCTION means no argument tuple needs to be created. 1944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FASTER_FUNCTION means that the fast-path frame setup code is used. 1954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm If there is a method call where the call can be optimized by changing 1974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm the argument tuple and calling the function directly, it gets recorded 1984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm twice. 1994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm As a result, the relationship among the statistics appears to be 2014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PCALL_ALL == PCALL_FUNCTION + PCALL_METHOD - PCALL_BOUND_METHOD + 2024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PCALL_CFUNCTION + PCALL_TYPE + PCALL_GENERATOR + PCALL_OTHER 2034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PCALL_FUNCTION > PCALL_FAST_FUNCTION > PCALL_FASTER_FUNCTION 2044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PCALL_METHOD > PCALL_BOUND_METHOD 2054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm*/ 2064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define PCALL(POS) pcall[POS]++ 2084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyObject * 2104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyEval_GetCallStats(PyObject *self) 2114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 2124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return Py_BuildValue("iiiiiiiiiii", 2134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pcall[0], pcall[1], pcall[2], pcall[3], 2144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pcall[4], pcall[5], pcall[6], pcall[7], 2154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pcall[8], pcall[9], pcall[10]); 2164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 2174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#else 2184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define PCALL(O) 2194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyObject * 2214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyEval_GetCallStats(PyObject *self) 2224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 2234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(Py_None); 2244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return Py_None; 2254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 2264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 2274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef WITH_THREAD 2304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef HAVE_ERRNO_H 2324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#include <errno.h> 2334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 2344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#include "pythread.h" 2354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyThread_type_lock interpreter_lock = 0; /* This is the GIL */ 2374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyThread_type_lock pending_lock = 0; /* for pending calls */ 2384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic long main_thread = 0; 2394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmint 2414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyEval_ThreadsInitialized(void) 2424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 2434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return interpreter_lock != 0; 2444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 2454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmvoid 2474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyEval_InitThreads(void) 2484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 2494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (interpreter_lock) 2504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return; 2514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm interpreter_lock = PyThread_allocate_lock(); 2524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyThread_acquire_lock(interpreter_lock, 1); 2534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm main_thread = PyThread_get_thread_ident(); 2544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 2554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmvoid 2574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyEval_AcquireLock(void) 2584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 2594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyThread_acquire_lock(interpreter_lock, 1); 2604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 2614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmvoid 2634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyEval_ReleaseLock(void) 2644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 2654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyThread_release_lock(interpreter_lock); 2664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 2674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmvoid 2694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyEval_AcquireThread(PyThreadState *tstate) 2704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 2714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (tstate == NULL) 2724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_FatalError("PyEval_AcquireThread: NULL new thread state"); 2734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Check someone has called PyEval_InitThreads() to create the lock */ 2744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(interpreter_lock); 2754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyThread_acquire_lock(interpreter_lock, 1); 2764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyThreadState_Swap(tstate) != NULL) 2774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_FatalError( 2784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "PyEval_AcquireThread: non-NULL old thread state"); 2794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 2804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmvoid 2824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyEval_ReleaseThread(PyThreadState *tstate) 2834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 2844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (tstate == NULL) 2854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_FatalError("PyEval_ReleaseThread: NULL thread state"); 2864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyThreadState_Swap(NULL) != tstate) 2874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_FatalError("PyEval_ReleaseThread: wrong thread state"); 2884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyThread_release_lock(interpreter_lock); 2894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 2904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* This function is called from PyOS_AfterFork to ensure that newly 2924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm created child processes don't hold locks referring to threads which 2934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm are not running in the child process. (This could also be done using 2944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pthread_atfork mechanism, at least for the pthreads implementation.) */ 2954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmvoid 2974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyEval_ReInitThreads(void) 2984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 2994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *threading, *result; 3004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyThreadState *tstate; 3014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!interpreter_lock) 3034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return; 3044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /*XXX Can't use PyThread_free_lock here because it does too 3054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm much error-checking. Doing this cleanly would require 3064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm adding a new function to each thread_*.h. Instead, just 3074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm create a new lock and waste a little bit of memory */ 3084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm interpreter_lock = PyThread_allocate_lock(); 3094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pending_lock = PyThread_allocate_lock(); 3104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyThread_acquire_lock(interpreter_lock, 1); 3114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm main_thread = PyThread_get_thread_ident(); 3124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Update the threading module with the new state. 3144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 3154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate = PyThreadState_GET(); 3164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm threading = PyMapping_GetItemString(tstate->interp->modules, 3174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "threading"); 3184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (threading == NULL) { 3194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* threading not imported */ 3204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Clear(); 3214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return; 3224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 3234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = PyObject_CallMethod(threading, "_after_fork", NULL); 3244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (result == NULL) 3254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_WriteUnraisable(threading); 3264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 3274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(result); 3284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(threading); 3294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 3304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 3314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Functions save_thread and restore_thread are always defined so 3334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm dynamically loaded modules needn't be compiled separately for use 3344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm with and without threads: */ 3354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyThreadState * 3374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyEval_SaveThread(void) 3384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 3394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyThreadState *tstate = PyThreadState_Swap(NULL); 3404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (tstate == NULL) 3414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_FatalError("PyEval_SaveThread: NULL tstate"); 3424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef WITH_THREAD 3434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (interpreter_lock) 3444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyThread_release_lock(interpreter_lock); 3454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 3464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return tstate; 3474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 3484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmvoid 3504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyEval_RestoreThread(PyThreadState *tstate) 3514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 3524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (tstate == NULL) 3534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_FatalError("PyEval_RestoreThread: NULL tstate"); 3544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef WITH_THREAD 3554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (interpreter_lock) { 3564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int err = errno; 3574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyThread_acquire_lock(interpreter_lock, 1); 3584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm errno = err; 3594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 3604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 3614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyThreadState_Swap(tstate); 3624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 3634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Mechanism whereby asynchronously executing callbacks (e.g. UNIX 3664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm signal handlers or Mac I/O completion routines) can schedule calls 3674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm to a function to be called synchronously. 3684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm The synchronous function is called with one void* argument. 3694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm It should return 0 for success or -1 for failure -- failure should 3704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm be accompanied by an exception. 3714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm If registry succeeds, the registry function returns 0; if it fails 3734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (e.g. due to too many pending calls) it returns -1 (without setting 3744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm an exception condition). 3754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Note that because registry may occur from within signal handlers, 3774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm or other asynchronous events, calling malloc() is unsafe! 3784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef WITH_THREAD 3804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Any thread can schedule pending calls, but only the main thread 3814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm will execute them. 3824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm There is no facility to schedule calls to a particular thread, but 3834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm that should be easy to change, should that ever be required. In 3844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm that case, the static variables here should go into the python 3854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm threadstate. 3864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 3874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm*/ 3884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef WITH_THREAD 3904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* The WITH_THREAD implementation is thread-safe. It allows 3924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm scheduling to be made from any thread, and even from an executing 3934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm callback. 3944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 3954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define NPENDINGCALLS 32 3974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic struct { 3984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int (*func)(void *); 3994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm void *arg; 4004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} pendingcalls[NPENDINGCALLS]; 4014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int pendingfirst = 0; 4024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int pendinglast = 0; 4034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic volatile int pendingcalls_to_do = 1; /* trigger initialization of lock */ 4044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic char pendingbusy = 0; 4054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmint 4074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPy_AddPendingCall(int (*func)(void *), void *arg) 4084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 4094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int i, j, result=0; 4104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyThread_type_lock lock = pending_lock; 4114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* try a few times for the lock. Since this mechanism is used 4134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * for signal handling (on the main thread), there is a (slim) 4144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * chance that a signal is delivered on the same thread while we 4154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * hold the lock during the Py_MakePendingCalls() function. 4164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * This avoids a deadlock in that case. 4174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * Note that signals can be delivered on any thread. In particular, 4184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * on Windows, a SIGINT is delivered on a system-created worker 4194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * thread. 4204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * We also check for lock being NULL, in the unlikely case that 4214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * this function is called before any bytecode evaluation takes place. 4224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 4234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (lock != NULL) { 4244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 0; i<100; i++) { 4254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyThread_acquire_lock(lock, NOWAIT_LOCK)) 4264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 4274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 4284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (i == 100) 4294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 4304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 4314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = pendinglast; 4334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm j = (i + 1) % NPENDINGCALLS; 4344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (j == pendingfirst) { 4354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = -1; /* Queue full */ 4364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } else { 4374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pendingcalls[i].func = func; 4384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pendingcalls[i].arg = arg; 4394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pendinglast = j; 4404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 4414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* signal main loop */ 4424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm _Py_Ticker = 0; 4434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pendingcalls_to_do = 1; 4444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (lock != NULL) 4454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyThread_release_lock(lock); 4464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return result; 4474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 4484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmint 4504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPy_MakePendingCalls(void) 4514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 4524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int i; 4534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int r = 0; 4544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!pending_lock) { 4564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* initial allocation of the lock */ 4574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pending_lock = PyThread_allocate_lock(); 4584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (pending_lock == NULL) 4594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 4604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 4614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* only service pending calls on main thread */ 4634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (main_thread && PyThread_get_thread_ident() != main_thread) 4644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 4654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* don't perform recursive pending calls */ 4664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (pendingbusy) 4674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 4684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pendingbusy = 1; 4694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* perform a bounded number of calls, in case of recursion */ 4704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i=0; i<NPENDINGCALLS; i++) { 4714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int j; 4724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int (*func)(void *); 4734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm void *arg = NULL; 4744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* pop one item off the queue while holding the lock */ 4764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyThread_acquire_lock(pending_lock, WAIT_LOCK); 4774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm j = pendingfirst; 4784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (j == pendinglast) { 4794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm func = NULL; /* Queue empty */ 4804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } else { 4814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm func = pendingcalls[j].func; 4824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm arg = pendingcalls[j].arg; 4834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pendingfirst = (j + 1) % NPENDINGCALLS; 4844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 4854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pendingcalls_to_do = pendingfirst != pendinglast; 4864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyThread_release_lock(pending_lock); 4874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* having released the lock, perform the callback */ 4884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (func == NULL) 4894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 4904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm r = func(arg); 4914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (r) 4924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 4934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 4944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pendingbusy = 0; 4954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return r; 4964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 4974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#else /* if ! defined WITH_THREAD */ 4994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* 5014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm WARNING! ASYNCHRONOUSLY EXECUTING CODE! 5024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm This code is used for signal handling in python that isn't built 5034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm with WITH_THREAD. 5044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Don't use this implementation when Py_AddPendingCalls() can happen 5054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm on a different thread! 5064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm There are two possible race conditions: 5084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (1) nested asynchronous calls to Py_AddPendingCall() 5094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (2) AddPendingCall() calls made while pending calls are being processed. 5104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (1) is very unlikely because typically signal delivery 5124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm is blocked during signal handling. So it should be impossible. 5134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (2) is a real possibility. 5144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm The current code is safe against (2), but not against (1). 5154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm The safety against (2) is derived from the fact that only one 5164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm thread is present, interrupted by signals, and that the critical 5174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm section is protected with the "busy" variable. On Windows, which 5184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm delivers SIGINT on a system thread, this does not hold and therefore 5194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Windows really shouldn't use this version. 5204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm The two threads could theoretically wiggle around the "busy" variable. 5214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm*/ 5224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define NPENDINGCALLS 32 5244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic struct { 5254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int (*func)(void *); 5264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm void *arg; 5274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} pendingcalls[NPENDINGCALLS]; 5284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic volatile int pendingfirst = 0; 5294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic volatile int pendinglast = 0; 5304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic volatile int pendingcalls_to_do = 0; 5314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmint 5334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPy_AddPendingCall(int (*func)(void *), void *arg) 5344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 5354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm static volatile int busy = 0; 5364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int i, j; 5374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* XXX Begin critical section */ 5384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (busy) 5394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 5404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm busy = 1; 5414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = pendinglast; 5424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm j = (i + 1) % NPENDINGCALLS; 5434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (j == pendingfirst) { 5444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm busy = 0; 5454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; /* Queue full */ 5464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 5474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pendingcalls[i].func = func; 5484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pendingcalls[i].arg = arg; 5494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pendinglast = j; 5504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm _Py_Ticker = 0; 5524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pendingcalls_to_do = 1; /* Signal main loop */ 5534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm busy = 0; 5544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* XXX End critical section */ 5554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 5564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 5574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmint 5594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPy_MakePendingCalls(void) 5604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 5614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm static int busy = 0; 5624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (busy) 5634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 5644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm busy = 1; 5654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pendingcalls_to_do = 0; 5664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (;;) { 5674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int i; 5684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int (*func)(void *); 5694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm void *arg; 5704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = pendingfirst; 5714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (i == pendinglast) 5724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; /* Queue empty */ 5734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm func = pendingcalls[i].func; 5744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm arg = pendingcalls[i].arg; 5754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pendingfirst = (i + 1) % NPENDINGCALLS; 5764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (func(arg) < 0) { 5774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm busy = 0; 5784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pendingcalls_to_do = 1; /* We're not done yet */ 5794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 5804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 5814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 5824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm busy = 0; 5834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 5844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 5854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif /* WITH_THREAD */ 5874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* The interpreter's recursion limit */ 5904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifndef Py_DEFAULT_RECURSION_LIMIT 5924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define Py_DEFAULT_RECURSION_LIMIT 1000 5934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 5944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int recursion_limit = Py_DEFAULT_RECURSION_LIMIT; 5954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmint _Py_CheckRecursionLimit = Py_DEFAULT_RECURSION_LIMIT; 5964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmint 5984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPy_GetRecursionLimit(void) 5994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 6004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return recursion_limit; 6014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 6024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmvoid 6044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPy_SetRecursionLimit(int new_limit) 6054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 6064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm recursion_limit = new_limit; 6074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm _Py_CheckRecursionLimit = recursion_limit; 6084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 6094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* the macro Py_EnterRecursiveCall() only calls _Py_CheckRecursiveCall() 6114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if the recursion_depth reaches _Py_CheckRecursionLimit. 6124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm If USE_STACKCHECK, the macro decrements _Py_CheckRecursionLimit 6134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm to guarantee that _Py_CheckRecursiveCall() is regularly called. 6144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Without USE_STACKCHECK, there is no need for this. */ 6154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmint 6164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm_Py_CheckRecursiveCall(char *where) 6174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 6184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyThreadState *tstate = PyThreadState_GET(); 6194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef USE_STACKCHECK 6214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyOS_CheckStack()) { 6224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm --tstate->recursion_depth; 6234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_MemoryError, "Stack overflow"); 6244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 6254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 6264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 6274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (tstate->recursion_depth > recursion_limit) { 6284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm --tstate->recursion_depth; 6294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Format(PyExc_RuntimeError, 6304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "maximum recursion depth exceeded%s", 6314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm where); 6324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 6334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 6344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm _Py_CheckRecursionLimit = recursion_limit; 6354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 6364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 6374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Status code for main loop (reason for stack unwind) */ 6394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmenum why_code { 6404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm WHY_NOT = 0x0001, /* No error */ 6414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm WHY_EXCEPTION = 0x0002, /* Exception occurred */ 6424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm WHY_RERAISE = 0x0004, /* Exception re-raised by 'finally' */ 6434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm WHY_RETURN = 0x0008, /* 'return' statement */ 6444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm WHY_BREAK = 0x0010, /* 'break' statement */ 6454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm WHY_CONTINUE = 0x0020, /* 'continue' statement */ 6464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm WHY_YIELD = 0x0040 /* 'yield' operator */ 6474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm}; 6484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic enum why_code do_raise(PyObject *, PyObject *, PyObject *); 6504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int unpack_iterable(PyObject *, int, PyObject **); 6514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Records whether tracing is on for any thread. Counts the number of 6534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm threads for which tstate->c_tracefunc is non-NULL, so if the value 6544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm is 0, we know we don't have to check this thread's c_tracefunc. 6554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm This speeds up the if statement in PyEval_EvalFrameEx() after 6564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fast_next_opcode*/ 6574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int _Py_TracingPossible = 0; 6584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* for manipulating the thread switch and periodic "stuff" - used to be 6604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm per thread, now just a pair o' globals */ 6614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmint _Py_CheckInterval = 100; 6624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmvolatile int _Py_Ticker = 0; /* so that we hit a "tick" first thing */ 6634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyObject * 6654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyEval_EvalCode(PyCodeObject *co, PyObject *globals, PyObject *locals) 6664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 6674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyEval_EvalCodeEx(co, 6684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm globals, locals, 6694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (PyObject **)NULL, 0, 6704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (PyObject **)NULL, 0, 6714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (PyObject **)NULL, 0, 6724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm NULL); 6734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 6744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Interpreter main loop */ 6774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyObject * 6794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyEval_EvalFrame(PyFrameObject *f) { 6804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* This is for backward compatibility with extension modules that 6814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm used this API; core interpreter code should call 6824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyEval_EvalFrameEx() */ 6834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyEval_EvalFrameEx(f, 0); 6844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 6854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyObject * 6874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyEval_EvalFrameEx(PyFrameObject *f, int throwflag) 6884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 6894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef DXPAIRS 6904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int lastopcode = 0; 6914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 6924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm register PyObject **stack_pointer; /* Next free slot in value stack */ 6934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm register unsigned char *next_instr; 6944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm register int opcode; /* Current opcode */ 6954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm register int oparg; /* Current opcode argument, if any */ 6964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm register enum why_code why; /* Reason for block stack unwind */ 6974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm register int err; /* Error status -- nonzero if error */ 6984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm register PyObject *x; /* Result object -- NULL if error */ 6994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm register PyObject *v; /* Temporary objects popped off stack */ 7004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm register PyObject *w; 7014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm register PyObject *u; 7024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm register PyObject *t; 7034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm register PyObject *stream = NULL; /* for PRINT opcodes */ 7044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm register PyObject **fastlocals, **freevars; 7054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *retval = NULL; /* Return value */ 7064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyThreadState *tstate = PyThreadState_GET(); 7074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyCodeObject *co; 7084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* when tracing we set things up so that 7104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm not (instr_lb <= current_bytecode_offset < instr_ub) 7124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm is true when the line being executed has changed. The 7144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm initial values are such as to make this false the first 7154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm time it is tested. */ 7164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int instr_ub = -1, instr_lb = 0, instr_prev = -1; 7174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unsigned char *first_instr; 7194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *names; 7204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *consts; 7214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#if defined(Py_DEBUG) || defined(LLTRACE) 7224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Make it easier to find out where we are with a debugger */ 7234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char *filename; 7244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 7254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Tuple access macros */ 7274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifndef Py_DEBUG 7294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define GETITEM(v, i) PyTuple_GET_ITEM((PyTupleObject *)(v), (i)) 7304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#else 7314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define GETITEM(v, i) PyTuple_GetItem((v), (i)) 7324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 7334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef WITH_TSC 7354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Use Pentium timestamp counter to mark certain events: 7364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm inst0 -- beginning of switch statement for opcode dispatch 7374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm inst1 -- end of switch statement (may be skipped) 7384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm loop0 -- the top of the mainloop 7394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm loop1 -- place where control returns again to top of mainloop 7404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (may be skipped) 7414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm intr1 -- beginning of long interruption 7424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm intr2 -- end of long interruption 7434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Many opcodes call out to helper C functions. In some cases, the 7454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm time in those functions should be counted towards the time for the 7464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm opcode, but not in all cases. For example, a CALL_FUNCTION opcode 7474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm calls another Python function; there's no point in charge all the 7484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm bytecode executed by the called function to the caller. 7494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm It's hard to make a useful judgement statically. In the presence 7514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm of operator overloading, it's impossible to tell if a call will 7524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm execute new Python code or not. 7534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm It's a case-by-case judgement. I'll use intr1 for the following 7554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm cases: 7564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm EXEC_STMT 7584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm IMPORT_STAR 7594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm IMPORT_FROM 7604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm CALL_FUNCTION (and friends) 7614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 7634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm uint64 inst0, inst1, loop0, loop1, intr0 = 0, intr1 = 0; 7644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int ticked = 0; 7654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm READ_TIMESTAMP(inst0); 7674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm READ_TIMESTAMP(inst1); 7684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm READ_TIMESTAMP(loop0); 7694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm READ_TIMESTAMP(loop1); 7704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* shut up the compiler */ 7724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm opcode = 0; 7734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 7744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Code access macros */ 7764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define INSTR_OFFSET() ((int)(next_instr - first_instr)) 7784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define NEXTOP() (*next_instr++) 7794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define NEXTARG() (next_instr += 2, (next_instr[-1]<<8) + next_instr[-2]) 7804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define PEEKARG() ((next_instr[2]<<8) + next_instr[1]) 7814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define JUMPTO(x) (next_instr = first_instr + (x)) 7824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define JUMPBY(x) (next_instr += (x)) 7834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* OpCode prediction macros 7854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Some opcodes tend to come in pairs thus making it possible to 7864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm predict the second code when the first is run. For example, 7874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm GET_ITER is often followed by FOR_ITER. And FOR_ITER is often 7884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm followed by STORE_FAST or UNPACK_SEQUENCE. 7894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Verifying the prediction costs a single high-speed test of a register 7914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm variable against a constant. If the pairing was good, then the 7924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm processor's own internal branch predication has a high likelihood of 7934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm success, resulting in a nearly zero-overhead transition to the 7944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm next opcode. A successful prediction saves a trip through the eval-loop 7954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm including its two unpredictable branches, the HAS_ARG test and the 7964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm switch-case. Combined with the processor's internal branch prediction, 7974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a successful PREDICT has the effect of making the two opcodes run as if 7984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm they were a single new opcode with the bodies combined. 7994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm If collecting opcode statistics, your choices are to either keep the 8014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm predictions turned-on and interpret the results as if some opcodes 8024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm had been combined or turn-off predictions so that the opcode frequency 8034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm counter updates for both opcodes. 8044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm*/ 8054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef DYNAMIC_EXECUTION_PROFILE 8074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define PREDICT(op) if (0) goto PRED_##op 8084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#else 8094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define PREDICT(op) if (*next_instr == op) goto PRED_##op 8104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 8114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define PREDICTED(op) PRED_##op: next_instr++ 8134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define PREDICTED_WITH_ARG(op) PRED_##op: oparg = PEEKARG(); next_instr += 3 8144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Stack manipulation macros */ 8164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* The stack can grow at most MAXINT deep, as co_nlocals and 8184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm co_stacksize are ints. */ 8194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define STACK_LEVEL() ((int)(stack_pointer - f->f_valuestack)) 8204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define EMPTY() (STACK_LEVEL() == 0) 8214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define TOP() (stack_pointer[-1]) 8224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define SECOND() (stack_pointer[-2]) 8234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define THIRD() (stack_pointer[-3]) 8244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define FOURTH() (stack_pointer[-4]) 8254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define PEEK(n) (stack_pointer[-(n)]) 8264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define SET_TOP(v) (stack_pointer[-1] = (v)) 8274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define SET_SECOND(v) (stack_pointer[-2] = (v)) 8284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define SET_THIRD(v) (stack_pointer[-3] = (v)) 8294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define SET_FOURTH(v) (stack_pointer[-4] = (v)) 8304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define SET_VALUE(n, v) (stack_pointer[-(n)] = (v)) 8314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define BASIC_STACKADJ(n) (stack_pointer += n) 8324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define BASIC_PUSH(v) (*stack_pointer++ = (v)) 8334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define BASIC_POP() (*--stack_pointer) 8344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef LLTRACE 8364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define PUSH(v) { (void)(BASIC_PUSH(v), \ 8374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm lltrace && prtrace(TOP(), "push")); \ 8384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(STACK_LEVEL() <= co->co_stacksize); } 8394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define POP() ((void)(lltrace && prtrace(TOP(), "pop")), \ 8404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm BASIC_POP()) 8414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define STACKADJ(n) { (void)(BASIC_STACKADJ(n), \ 8424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm lltrace && prtrace(TOP(), "stackadj")); \ 8434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(STACK_LEVEL() <= co->co_stacksize); } 8444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define EXT_POP(STACK_POINTER) ((void)(lltrace && \ 8454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm prtrace((STACK_POINTER)[-1], "ext_pop")), \ 8464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *--(STACK_POINTER)) 8474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#else 8484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define PUSH(v) BASIC_PUSH(v) 8494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define POP() BASIC_POP() 8504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define STACKADJ(n) BASIC_STACKADJ(n) 8514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define EXT_POP(STACK_POINTER) (*--(STACK_POINTER)) 8524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 8534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Local variable macros */ 8554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define GETLOCAL(i) (fastlocals[i]) 8574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* The SETLOCAL() macro must not DECREF the local variable in-place and 8594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm then store the new value; it must copy the old value to a temporary 8604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm value, then store the new value, and then DECREF the temporary value. 8614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm This is because it is possible that during the DECREF the frame is 8624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm accessed by other code (e.g. a __del__ method or gc.collect()) and the 8634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm variable would be pointing to already-freed memory. */ 8644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define SETLOCAL(i, value) do { PyObject *tmp = GETLOCAL(i); \ 8654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm GETLOCAL(i) = value; \ 8664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(tmp); } while (0) 8674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Start of code */ 8694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f == NULL) 8714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 8724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* push frame */ 8744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (Py_EnterRecursiveCall("")) 8754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 8764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->frame = f; 8784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (tstate->use_tracing) { 8804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (tstate->c_tracefunc != NULL) { 8814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* tstate->c_tracefunc, if defined, is a 8824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm function that will be called on *every* entry 8834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm to a code block. Its return value, if not 8844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm None, is a function that will be called at 8854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm the start of each executed line of code. 8864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (Actually, the function must return itself 8874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm in order to continue tracing.) The trace 8884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm functions are called with three arguments: 8894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a pointer to the current frame, a string 8904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm indicating why the function is called, and 8914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm an argument which depends on the situation. 8924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm The global trace function is also called 8934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm whenever an exception is detected. */ 8944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (call_trace_protected(tstate->c_tracefunc, 8954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->c_traceobj, 8964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f, PyTrace_CALL, Py_None)) { 8974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Trace function raised an error */ 8984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto exit_eval_frame; 8994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 9004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 9014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (tstate->c_profilefunc != NULL) { 9024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Similar for c_profilefunc, except it needn't 9034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return itself and isn't called for "line" events */ 9044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (call_trace_protected(tstate->c_profilefunc, 9054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->c_profileobj, 9064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f, PyTrace_CALL, Py_None)) { 9074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Profile function raised an error */ 9084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto exit_eval_frame; 9094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 9104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 9114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 9124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm co = f->f_code; 9144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm names = co->co_names; 9154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm consts = co->co_consts; 9164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fastlocals = f->f_localsplus; 9174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm freevars = f->f_localsplus + co->co_nlocals; 9184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm first_instr = (unsigned char*) PyString_AS_STRING(co->co_code); 9194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* An explanation is in order for the next line. 9204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_lasti now refers to the index of the last instruction 9224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm executed. You might think this was obvious from the name, but 9234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm this wasn't always true before 2.3! PyFrame_New now sets 9244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_lasti to -1 (i.e. the index *before* the first instruction) 9254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm and YIELD_VALUE doesn't fiddle with f_lasti any more. So this 9264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm does work. Promise. 9274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm When the PREDICT() macros are enabled, some opcode pairs follow in 9294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm direct succession without updating f->f_lasti. A successful 9304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm prediction effectively links the two codes together as if they 9314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm were a single new opcode; accordingly,f->f_lasti will point to 9324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm the first code in the pair (for instance, GET_ITER followed by 9334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FOR_ITER is effectively a single opcode and f->f_lasti will point 9344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm at to the beginning of the combined pair.) 9354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 9364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm next_instr = first_instr + f->f_lasti + 1; 9374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm stack_pointer = f->f_stacktop; 9384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(stack_pointer != NULL); 9394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_stacktop = NULL; /* remains NULL unless yield suspends frame */ 9404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef LLTRACE 9424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm lltrace = PyDict_GetItemString(f->f_globals, "__lltrace__") != NULL; 9434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 9444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#if defined(Py_DEBUG) || defined(LLTRACE) 9454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm filename = PyString_AsString(co->co_filename); 9464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 9474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm why = WHY_NOT; 9494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = 0; 9504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = Py_None; /* Not a reference, just anything non-NULL */ 9514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = NULL; 9524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (throwflag) { /* support for generator.throw() */ 9544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm why = WHY_EXCEPTION; 9554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto on_error; 9564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 9574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (;;) { 9594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef WITH_TSC 9604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (inst1 == 0) { 9614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Almost surely, the opcode executed a break 9624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm or a continue, preventing inst1 from being set 9634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm on the way out of the loop. 9644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 9654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm READ_TIMESTAMP(inst1); 9664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm loop1 = inst1; 9674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 9684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm dump_tsc(opcode, ticked, inst0, inst1, loop0, loop1, 9694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm intr0, intr1); 9704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ticked = 0; 9714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm inst1 = 0; 9724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm intr0 = 0; 9734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm intr1 = 0; 9744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm READ_TIMESTAMP(loop0); 9754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 9764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(stack_pointer >= f->f_valuestack); /* else underflow */ 9774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(STACK_LEVEL() <= co->co_stacksize); /* else overflow */ 9784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Do periodic things. Doing this every time through 9804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm the loop would add too much overhead, so we do it 9814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm only every Nth instruction. We also do it if 9824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ``pendingcalls_to_do'' is set, i.e. when an asynchronous 9834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm event needs attention (e.g. a signal handler or 9844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm async I/O handler); see Py_AddPendingCall() and 9854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_MakePendingCalls() above. */ 9864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (--_Py_Ticker < 0) { 9884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (*next_instr == SETUP_FINALLY) { 9894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Make the last opcode before 9904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a try: finally: block uninterruptible. */ 9914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fast_next_opcode; 9924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 9934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm _Py_Ticker = _Py_CheckInterval; 9944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->tick_counter++; 9954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef WITH_TSC 9964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ticked = 1; 9974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 9984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (pendingcalls_to_do) { 9994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (Py_MakePendingCalls() < 0) { 10004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm why = WHY_EXCEPTION; 10014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto on_error; 10024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 10034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (pendingcalls_to_do) 10044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* MakePendingCalls() didn't succeed. 10054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Force early re-execution of this 10064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "periodic" code, possibly after 10074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a thread switch */ 10084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm _Py_Ticker = 0; 10094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 10104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef WITH_THREAD 10114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (interpreter_lock) { 10124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Give another thread a chance */ 10134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyThreadState_Swap(NULL) != tstate) 10154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_FatalError("ceval: tstate mix-up"); 10164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyThread_release_lock(interpreter_lock); 10174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Other threads may run now */ 10194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyThread_acquire_lock(interpreter_lock, 1); 10214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyThreadState_Swap(tstate) != NULL) 10224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_FatalError("ceval: orphan tstate"); 10234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Check for thread interrupts */ 10254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (tstate->async_exc != NULL) { 10274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = tstate->async_exc; 10284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->async_exc = NULL; 10294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetNone(x); 10304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(x); 10314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm why = WHY_EXCEPTION; 10324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto on_error; 10334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 10344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 10354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 10364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 10374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fast_next_opcode: 10394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_lasti = INSTR_OFFSET(); 10404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* line-by-line tracing support */ 10424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (_Py_TracingPossible && 10444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->c_tracefunc != NULL && !tstate->tracing) { 10454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* see maybe_call_line_trace 10464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for expository comments */ 10474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_stacktop = stack_pointer; 10484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = maybe_call_line_trace(tstate->c_tracefunc, 10504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->c_traceobj, 10514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f, &instr_lb, &instr_ub, 10524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm &instr_prev); 10534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Reload possibly changed frame fields */ 10544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm JUMPTO(f->f_lasti); 10554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f->f_stacktop != NULL) { 10564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm stack_pointer = f->f_stacktop; 10574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_stacktop = NULL; 10584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 10594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (err) { 10604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* trace function raised an exception */ 10614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto on_error; 10624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 10634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 10644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Extract opcode and argument */ 10664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm opcode = NEXTOP(); 10684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm oparg = 0; /* allows oparg to be stored in a register because 10694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm it doesn't have to be remembered across a full loop */ 10704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (HAS_ARG(opcode)) 10714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm oparg = NEXTARG(); 10724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm dispatch_opcode: 10734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef DYNAMIC_EXECUTION_PROFILE 10744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef DXPAIRS 10754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm dxpairs[lastopcode][opcode]++; 10764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm lastopcode = opcode; 10774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 10784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm dxp[opcode]++; 10794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 10804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef LLTRACE 10824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Instruction tracing */ 10834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (lltrace) { 10854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (HAS_ARG(opcode)) { 10864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm printf("%d: %d, %d\n", 10874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_lasti, opcode, oparg); 10884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 10894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 10904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm printf("%d: %d\n", 10914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_lasti, opcode); 10924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 10934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 10944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 10954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Main switch on opcode */ 10974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm READ_TIMESTAMP(inst0); 10984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm switch (opcode) { 11004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* BEWARE! 11024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm It is essential that any operation that fails sets either 11034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x to NULL, err to nonzero, or why to anything but WHY_NOT, 11044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm and that no operation that succeeds does this! */ 11054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* case STOP_CODE: this is an error! */ 11074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case NOP: 11094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fast_next_opcode; 11104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case LOAD_FAST: 11124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = GETLOCAL(oparg); 11134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) { 11144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(x); 11154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PUSH(x); 11164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fast_next_opcode; 11174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 11184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm format_exc_check_arg(PyExc_UnboundLocalError, 11194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm UNBOUNDLOCAL_ERROR_MSG, 11204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyTuple_GetItem(co->co_varnames, oparg)); 11214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 11224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case LOAD_CONST: 11244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = GETITEM(consts, oparg); 11254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(x); 11264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PUSH(x); 11274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fast_next_opcode; 11284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PREDICTED_WITH_ARG(STORE_FAST); 11304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case STORE_FAST: 11314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = POP(); 11324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SETLOCAL(oparg, v); 11334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fast_next_opcode; 11344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case POP_TOP: 11364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = POP(); 11374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 11384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fast_next_opcode; 11394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case ROT_TWO: 11414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 11424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = SECOND(); 11434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(w); 11444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_SECOND(v); 11454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fast_next_opcode; 11464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case ROT_THREE: 11484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 11494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = SECOND(); 11504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = THIRD(); 11514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(w); 11524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_SECOND(x); 11534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_THIRD(v); 11544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fast_next_opcode; 11554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case ROT_FOUR: 11574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm u = TOP(); 11584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = SECOND(); 11594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = THIRD(); 11604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = FOURTH(); 11614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(v); 11624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_SECOND(w); 11634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_THIRD(x); 11644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_FOURTH(u); 11654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fast_next_opcode; 11664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case DUP_TOP: 11684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 11694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(v); 11704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PUSH(v); 11714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fast_next_opcode; 11724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case DUP_TOPX: 11744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (oparg == 2) { 11754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = TOP(); 11764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(x); 11774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = SECOND(); 11784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(w); 11794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm STACKADJ(2); 11804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 11814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_SECOND(w); 11824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fast_next_opcode; 11834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } else if (oparg == 3) { 11844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = TOP(); 11854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(x); 11864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = SECOND(); 11874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(w); 11884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = THIRD(); 11894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(v); 11904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm STACKADJ(3); 11914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 11924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_SECOND(w); 11934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_THIRD(v); 11944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fast_next_opcode; 11954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 11964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_FatalError("invalid argument to DUP_TOPX" 11974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm " (bytecode corruption?)"); 11984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Never returns, so don't bother to set why. */ 11994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 12004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case UNARY_POSITIVE: 12024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 12034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyNumber_Positive(v); 12044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 12054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 12064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 12074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 12084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case UNARY_NEGATIVE: 12104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 12114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyNumber_Negative(v); 12124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 12134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 12144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 12154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 12164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case UNARY_NOT: 12184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 12194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = PyObject_IsTrue(v); 12204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 12214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (err == 0) { 12224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(Py_True); 12234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(Py_True); 12244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 12254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 12264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (err > 0) { 12274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(Py_False); 12284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(Py_False); 12294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = 0; 12304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 12314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 12324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm STACKADJ(-1); 12334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 12344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case UNARY_CONVERT: 12364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 12374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyObject_Repr(v); 12384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 12394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 12404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 12414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 12424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case UNARY_INVERT: 12444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 12454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyNumber_Invert(v); 12464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 12474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 12484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 12494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 12504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case BINARY_POWER: 12524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 12534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 12544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyNumber_Power(v, w, Py_None); 12554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 12564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 12574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 12584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 12594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 12604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case BINARY_MULTIPLY: 12624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 12634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 12644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyNumber_Multiply(v, w); 12654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 12664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 12674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 12684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 12694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 12704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case BINARY_DIVIDE: 12724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!_Py_QnewFlag) { 12734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 12744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 12754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyNumber_Divide(v, w); 12764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 12774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 12784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 12794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 12804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 12814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 12824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* -Qnew is in effect: fall through to 12834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm BINARY_TRUE_DIVIDE */ 12844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case BINARY_TRUE_DIVIDE: 12854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 12864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 12874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyNumber_TrueDivide(v, w); 12884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 12894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 12904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 12914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 12924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 12934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case BINARY_FLOOR_DIVIDE: 12954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 12964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 12974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyNumber_FloorDivide(v, w); 12984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 12994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 13004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 13014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 13024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 13034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case BINARY_MODULO: 13054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 13064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 13074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyString_CheckExact(v)) 13084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyString_Format(v, w); 13094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 13104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyNumber_Remainder(v, w); 13114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 13124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 13134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 13144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 13154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 13164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case BINARY_ADD: 13184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 13194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 13204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) { 13214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* INLINE: int + int */ 13224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm register long a, b, i; 13234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = PyInt_AS_LONG(v); 13244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = PyInt_AS_LONG(w); 13254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* cast to avoid undefined behaviour 13264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm on overflow */ 13274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = (long)((unsigned long)a + b); 13284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((i^a) < 0 && (i^b) < 0) 13294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto slow_add; 13304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyInt_FromLong(i); 13314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 13324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyString_CheckExact(v) && 13334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyString_CheckExact(w)) { 13344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = string_concatenate(v, w, f, next_instr); 13354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* string_concatenate consumed the ref to v */ 13364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto skip_decref_vx; 13374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 13384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 13394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm slow_add: 13404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyNumber_Add(v, w); 13414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 13424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 13434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm skip_decref_vx: 13444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 13454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 13464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 13474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 13484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case BINARY_SUBTRACT: 13504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 13514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 13524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) { 13534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* INLINE: int - int */ 13544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm register long a, b, i; 13554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = PyInt_AS_LONG(v); 13564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = PyInt_AS_LONG(w); 13574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* cast to avoid undefined behaviour 13584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm on overflow */ 13594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = (long)((unsigned long)a - b); 13604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((i^a) < 0 && (i^~b) < 0) 13614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto slow_sub; 13624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyInt_FromLong(i); 13634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 13644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 13654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm slow_sub: 13664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyNumber_Subtract(v, w); 13674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 13684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 13694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 13704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 13714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 13724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 13734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case BINARY_SUBSCR: 13754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 13764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 13774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyList_CheckExact(v) && PyInt_CheckExact(w)) { 13784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* INLINE: list[int] */ 13794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t i = PyInt_AsSsize_t(w); 13804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (i < 0) 13814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i += PyList_GET_SIZE(v); 13824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (i >= 0 && i < PyList_GET_SIZE(v)) { 13834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyList_GET_ITEM(v, i); 13844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(x); 13854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 13864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 13874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto slow_get; 13884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 13894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 13904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm slow_get: 13914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyObject_GetItem(v, w); 13924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 13934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 13944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 13954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 13964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 13974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case BINARY_LSHIFT: 13994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 14004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 14014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyNumber_Lshift(v, w); 14024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 14034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 14044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 14054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 14064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 14074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case BINARY_RSHIFT: 14094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 14104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 14114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyNumber_Rshift(v, w); 14124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 14134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 14144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 14154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 14164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 14174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case BINARY_AND: 14194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 14204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 14214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyNumber_And(v, w); 14224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 14234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 14244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 14254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 14264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 14274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case BINARY_XOR: 14294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 14304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 14314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyNumber_Xor(v, w); 14324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 14334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 14344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 14354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 14364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 14374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case BINARY_OR: 14394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 14404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 14414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyNumber_Or(v, w); 14424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 14434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 14444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 14454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 14464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 14474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case LIST_APPEND: 14494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 14504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = PEEK(oparg); 14514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = PyList_Append(v, w); 14524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 14534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (err == 0) { 14544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PREDICT(JUMP_ABSOLUTE); 14554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 14564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 14574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 14584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case SET_ADD: 14604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 14614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = stack_pointer[-oparg]; 14624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = PySet_Add(v, w); 14634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 14644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (err == 0) { 14654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PREDICT(JUMP_ABSOLUTE); 14664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 14674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 14684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 14694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case INPLACE_POWER: 14714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 14724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 14734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyNumber_InPlacePower(v, w, Py_None); 14744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 14754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 14764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 14774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 14784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 14794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case INPLACE_MULTIPLY: 14814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 14824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 14834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyNumber_InPlaceMultiply(v, w); 14844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 14854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 14864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 14874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 14884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 14894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case INPLACE_DIVIDE: 14914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!_Py_QnewFlag) { 14924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 14934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 14944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyNumber_InPlaceDivide(v, w); 14954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 14964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 14974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 14984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 14994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 15004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 15014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* -Qnew is in effect: fall through to 15024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm INPLACE_TRUE_DIVIDE */ 15034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case INPLACE_TRUE_DIVIDE: 15044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 15054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 15064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyNumber_InPlaceTrueDivide(v, w); 15074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 15084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 15094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 15104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 15114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 15124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case INPLACE_FLOOR_DIVIDE: 15144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 15154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 15164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyNumber_InPlaceFloorDivide(v, w); 15174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 15184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 15194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 15204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 15214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 15224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case INPLACE_MODULO: 15244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 15254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 15264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyNumber_InPlaceRemainder(v, w); 15274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 15284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 15294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 15304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 15314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 15324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case INPLACE_ADD: 15344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 15354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 15364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) { 15374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* INLINE: int + int */ 15384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm register long a, b, i; 15394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = PyInt_AS_LONG(v); 15404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = PyInt_AS_LONG(w); 15414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = a + b; 15424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((i^a) < 0 && (i^b) < 0) 15434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto slow_iadd; 15444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyInt_FromLong(i); 15454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 15464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyString_CheckExact(v) && 15474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyString_CheckExact(w)) { 15484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = string_concatenate(v, w, f, next_instr); 15494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* string_concatenate consumed the ref to v */ 15504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto skip_decref_v; 15514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 15524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 15534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm slow_iadd: 15544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyNumber_InPlaceAdd(v, w); 15554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 15564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 15574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm skip_decref_v: 15584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 15594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 15604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 15614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 15624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case INPLACE_SUBTRACT: 15644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 15654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 15664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) { 15674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* INLINE: int - int */ 15684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm register long a, b, i; 15694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = PyInt_AS_LONG(v); 15704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = PyInt_AS_LONG(w); 15714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = a - b; 15724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((i^a) < 0 && (i^~b) < 0) 15734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto slow_isub; 15744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyInt_FromLong(i); 15754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 15764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 15774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm slow_isub: 15784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyNumber_InPlaceSubtract(v, w); 15794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 15804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 15814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 15824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 15834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 15844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 15854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case INPLACE_LSHIFT: 15874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 15884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 15894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyNumber_InPlaceLshift(v, w); 15904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 15914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 15924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 15934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 15944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 15954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case INPLACE_RSHIFT: 15974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 15984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 15994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyNumber_InPlaceRshift(v, w); 16004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 16014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 16024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 16034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 16044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 16054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case INPLACE_AND: 16074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 16084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 16094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyNumber_InPlaceAnd(v, w); 16104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 16114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 16124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 16134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 16144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 16154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case INPLACE_XOR: 16174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 16184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 16194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyNumber_InPlaceXor(v, w); 16204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 16214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 16224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 16234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 16244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 16254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case INPLACE_OR: 16274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 16284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 16294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyNumber_InPlaceOr(v, w); 16304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 16314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 16324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 16334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 16344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 16354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case SLICE+0: 16374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case SLICE+1: 16384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case SLICE+2: 16394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case SLICE+3: 16404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((opcode-SLICE) & 2) 16414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 16424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 16434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = NULL; 16444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((opcode-SLICE) & 1) 16454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = POP(); 16464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 16474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = NULL; 16484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm u = TOP(); 16494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = apply_slice(u, v, w); 16504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(u); 16514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(v); 16524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(w); 16534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 16544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 16554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 16564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case STORE_SLICE+0: 16584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case STORE_SLICE+1: 16594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case STORE_SLICE+2: 16604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case STORE_SLICE+3: 16614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((opcode-STORE_SLICE) & 2) 16624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 16634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 16644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = NULL; 16654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((opcode-STORE_SLICE) & 1) 16664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = POP(); 16674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 16684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = NULL; 16694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm u = POP(); 16704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm t = POP(); 16714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = assign_slice(u, v, w, t); /* u[v:w] = t */ 16724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(t); 16734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(u); 16744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(v); 16754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(w); 16764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (err == 0) continue; 16774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 16784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case DELETE_SLICE+0: 16804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case DELETE_SLICE+1: 16814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case DELETE_SLICE+2: 16824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case DELETE_SLICE+3: 16834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((opcode-DELETE_SLICE) & 2) 16844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 16854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 16864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = NULL; 16874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((opcode-DELETE_SLICE) & 1) 16884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = POP(); 16894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 16904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = NULL; 16914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm u = POP(); 16924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = assign_slice(u, v, w, (PyObject *)NULL); 16934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* del u[v:w] */ 16944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(u); 16954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(v); 16964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(w); 16974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (err == 0) continue; 16984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 16994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 17004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case STORE_SUBSCR: 17014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = TOP(); 17024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = SECOND(); 17034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm u = THIRD(); 17044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm STACKADJ(-3); 17054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* v[w] = u */ 17064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = PyObject_SetItem(v, w, u); 17074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(u); 17084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 17094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 17104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (err == 0) continue; 17114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 17124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 17134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case DELETE_SUBSCR: 17144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = TOP(); 17154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = SECOND(); 17164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm STACKADJ(-2); 17174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* del v[w] */ 17184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = PyObject_DelItem(v, w); 17194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 17204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 17214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (err == 0) continue; 17224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 17234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 17244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case PRINT_EXPR: 17254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = POP(); 17264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = PySys_GetObject("displayhook"); 17274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (w == NULL) { 17284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_RuntimeError, 17294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "lost sys.displayhook"); 17304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = -1; 17314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = NULL; 17324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 17334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (err == 0) { 17344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyTuple_Pack(1, v); 17354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x == NULL) 17364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = -1; 17374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 17384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (err == 0) { 17394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = PyEval_CallObject(w, x); 17404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(w); 17414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (w == NULL) 17424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = -1; 17434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 17444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 17454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(x); 17464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 17474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 17484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case PRINT_ITEM_TO: 17494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = stream = POP(); 17504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* fall through to PRINT_ITEM */ 17514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 17524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case PRINT_ITEM: 17534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = POP(); 17544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (stream == NULL || stream == Py_None) { 17554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = PySys_GetObject("stdout"); 17564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (w == NULL) { 17574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_RuntimeError, 17584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "lost sys.stdout"); 17594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = -1; 17604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 17614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 17624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* PyFile_SoftSpace() can exececute arbitrary code 17634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if sys.stdout is an instance with a __getattr__. 17644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm If __getattr__ raises an exception, w will 17654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm be freed, so we need to prevent that temporarily. */ 17664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XINCREF(w); 17674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (w != NULL && PyFile_SoftSpace(w, 0)) 17684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = PyFile_WriteString(" ", w); 17694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (err == 0) 17704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = PyFile_WriteObject(v, w, Py_PRINT_RAW); 17714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (err == 0) { 17724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* XXX move into writeobject() ? */ 17734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyString_Check(v)) { 17744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char *s = PyString_AS_STRING(v); 17754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t len = PyString_GET_SIZE(v); 17764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (len == 0 || 17774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm !isspace(Py_CHARMASK(s[len-1])) || 17784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm s[len-1] == ' ') 17794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFile_SoftSpace(w, 1); 17804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 17814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef Py_USING_UNICODE 17824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyUnicode_Check(v)) { 17834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_UNICODE *s = PyUnicode_AS_UNICODE(v); 17844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t len = PyUnicode_GET_SIZE(v); 17854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (len == 0 || 17864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm !Py_UNICODE_ISSPACE(s[len-1]) || 17874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm s[len-1] == ' ') 17884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFile_SoftSpace(w, 1); 17894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 17904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 17914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 17924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFile_SoftSpace(w, 1); 17934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 17944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(w); 17954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 17964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(stream); 17974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm stream = NULL; 17984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (err == 0) 17994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 18004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 18014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 18024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case PRINT_NEWLINE_TO: 18034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = stream = POP(); 18044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* fall through to PRINT_NEWLINE */ 18054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 18064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case PRINT_NEWLINE: 18074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (stream == NULL || stream == Py_None) { 18084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = PySys_GetObject("stdout"); 18094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (w == NULL) { 18104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_RuntimeError, 18114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "lost sys.stdout"); 18124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm why = WHY_EXCEPTION; 18134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 18144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 18154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (w != NULL) { 18164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* w.write() may replace sys.stdout, so we 18174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * have to keep our reference to it */ 18184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(w); 18194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = PyFile_WriteString("\n", w); 18204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (err == 0) 18214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFile_SoftSpace(w, 0); 18224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 18234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 18244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(stream); 18254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm stream = NULL; 18264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 18274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 18284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 18294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef CASE_TOO_BIG 18304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm default: switch (opcode) { 18314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 18324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case RAISE_VARARGS: 18334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm u = v = w = NULL; 18344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm switch (oparg) { 18354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case 3: 18364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm u = POP(); /* traceback */ 18374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Fallthrough */ 18384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case 2: 18394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = POP(); /* value */ 18404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Fallthrough */ 18414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case 1: 18424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); /* exc */ 18434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case 0: /* Fallthrough */ 18444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm why = do_raise(w, v, u); 18454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 18464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm default: 18474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_SystemError, 18484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "bad RAISE_VARARGS oparg"); 18494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm why = WHY_EXCEPTION; 18504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 18514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 18524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 18534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 18544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case LOAD_LOCALS: 18554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((x = f->f_locals) != NULL) { 18564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(x); 18574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PUSH(x); 18584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 18594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 18604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_SystemError, "no locals"); 18614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 18624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 18634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case RETURN_VALUE: 18644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm retval = POP(); 18654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm why = WHY_RETURN; 18664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fast_block_end; 18674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 18684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case YIELD_VALUE: 18694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm retval = POP(); 18704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_stacktop = stack_pointer; 18714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm why = WHY_YIELD; 18724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fast_yield; 18734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 18744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case EXEC_STMT: 18754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = TOP(); 18764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = SECOND(); 18774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm u = THIRD(); 18784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm STACKADJ(-3); 18794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm READ_TIMESTAMP(intr0); 18804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = exec_statement(f, u, v, w); 18814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm READ_TIMESTAMP(intr1); 18824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(u); 18834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 18844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 18854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 18864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 18874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case POP_BLOCK: 18884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm { 18894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyTryBlock *b = PyFrame_BlockPop(f); 18904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (STACK_LEVEL() > b->b_level) { 18914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = POP(); 18924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 18934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 18944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 18954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 18964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 18974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PREDICTED(END_FINALLY); 18984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case END_FINALLY: 18994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = POP(); 19004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyInt_Check(v)) { 19014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm why = (enum why_code) PyInt_AS_LONG(v); 19024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(why != WHY_YIELD); 19034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (why == WHY_RETURN || 19044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm why == WHY_CONTINUE) 19054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm retval = POP(); 19064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 19074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyExceptionClass_Check(v) || 19084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyString_Check(v)) { 19094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 19104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm u = POP(); 19114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Restore(v, w, u); 19124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm why = WHY_RERAISE; 19134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 19144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 19154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (v != Py_None) { 19164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_SystemError, 19174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "'finally' pops bad exception"); 19184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm why = WHY_EXCEPTION; 19194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 19204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 19214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 19224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 19234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case BUILD_CLASS: 19244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm u = TOP(); 19254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = SECOND(); 19264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = THIRD(); 19274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm STACKADJ(-2); 19284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = build_class(u, v, w); 19294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 19304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(u); 19314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 19324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 19334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 19344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 19354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case STORE_NAME: 19364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = GETITEM(names, oparg); 19374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = POP(); 19384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((x = f->f_locals) != NULL) { 19394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyDict_CheckExact(x)) 19404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = PyDict_SetItem(x, w, v); 19414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 19424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = PyObject_SetItem(x, w, v); 19434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 19444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (err == 0) continue; 19454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 19464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 19474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Format(PyExc_SystemError, 19484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "no locals found when storing %s", 19494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject_REPR(w)); 19504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 19514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 19524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case DELETE_NAME: 19534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = GETITEM(names, oparg); 19544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((x = f->f_locals) != NULL) { 19554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((err = PyObject_DelItem(x, w)) != 0) 19564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm format_exc_check_arg(PyExc_NameError, 19574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm NAME_ERROR_MSG, 19584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w); 19594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 19604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 19614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Format(PyExc_SystemError, 19624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "no locals when deleting %s", 19634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject_REPR(w)); 19644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 19654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 19664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PREDICTED_WITH_ARG(UNPACK_SEQUENCE); 19674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case UNPACK_SEQUENCE: 19684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = POP(); 19694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyTuple_CheckExact(v) && 19704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyTuple_GET_SIZE(v) == oparg) { 19714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject **items = \ 19724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ((PyTupleObject *)v)->ob_item; 19734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (oparg--) { 19744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = items[oparg]; 19754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(w); 19764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PUSH(w); 19774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 19784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 19794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 19804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } else if (PyList_CheckExact(v) && 19814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyList_GET_SIZE(v) == oparg) { 19824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject **items = \ 19834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ((PyListObject *)v)->ob_item; 19844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (oparg--) { 19854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = items[oparg]; 19864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(w); 19874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PUSH(w); 19884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 19894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } else if (unpack_iterable(v, oparg, 19904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm stack_pointer + oparg)) { 19914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm STACKADJ(oparg); 19924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } else { 19934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* unpack_iterable() raised an exception */ 19944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm why = WHY_EXCEPTION; 19954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 19964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 19974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 19984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 19994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case STORE_ATTR: 20004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = GETITEM(names, oparg); 20014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 20024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm u = SECOND(); 20034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm STACKADJ(-2); 20044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = PyObject_SetAttr(v, w, u); /* v.w = u */ 20054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 20064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(u); 20074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (err == 0) continue; 20084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 20094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 20104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case DELETE_ATTR: 20114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = GETITEM(names, oparg); 20124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = POP(); 20134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = PyObject_SetAttr(v, w, (PyObject *)NULL); 20144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* del v.w */ 20154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 20164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 20174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 20184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case STORE_GLOBAL: 20194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = GETITEM(names, oparg); 20204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = POP(); 20214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = PyDict_SetItem(f->f_globals, w, v); 20224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 20234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (err == 0) continue; 20244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 20254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 20264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case DELETE_GLOBAL: 20274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = GETITEM(names, oparg); 20284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((err = PyDict_DelItem(f->f_globals, w)) != 0) 20294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm format_exc_check_arg( 20304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyExc_NameError, GLOBAL_NAME_ERROR_MSG, w); 20314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 20324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 20334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case LOAD_NAME: 20344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = GETITEM(names, oparg); 20354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((v = f->f_locals) == NULL) { 20364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Format(PyExc_SystemError, 20374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "no locals when loading %s", 20384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject_REPR(w)); 20394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm why = WHY_EXCEPTION; 20404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 20414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 20424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyDict_CheckExact(v)) { 20434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyDict_GetItem(v, w); 20444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XINCREF(x); 20454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 20464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 20474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyObject_GetItem(v, w); 20484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x == NULL && PyErr_Occurred()) { 20494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!PyErr_ExceptionMatches( 20504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyExc_KeyError)) 20514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 20524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Clear(); 20534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 20544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 20554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x == NULL) { 20564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyDict_GetItem(f->f_globals, w); 20574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x == NULL) { 20584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyDict_GetItem(f->f_builtins, w); 20594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x == NULL) { 20604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm format_exc_check_arg( 20614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyExc_NameError, 20624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm NAME_ERROR_MSG, w); 20634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 20644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 20654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 20664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(x); 20674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 20684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PUSH(x); 20694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 20704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 20714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case LOAD_GLOBAL: 20724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = GETITEM(names, oparg); 20734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyString_CheckExact(w)) { 20744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Inline the PyDict_GetItem() calls. 20754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm WARNING: this is an extreme speed hack. 20764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Do not try this at home. */ 20774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long hash = ((PyStringObject *)w)->ob_shash; 20784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (hash != -1) { 20794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyDictObject *d; 20804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyDictEntry *e; 20814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d = (PyDictObject *)(f->f_globals); 20824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm e = d->ma_lookup(d, w, hash); 20834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (e == NULL) { 20844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = NULL; 20854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 20864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 20874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = e->me_value; 20884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) { 20894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(x); 20904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PUSH(x); 20914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 20924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 20934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d = (PyDictObject *)(f->f_builtins); 20944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm e = d->ma_lookup(d, w, hash); 20954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (e == NULL) { 20964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = NULL; 20974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 20984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 20994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = e->me_value; 21004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) { 21014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(x); 21024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PUSH(x); 21034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 21044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 21054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto load_global_error; 21064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 21074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 21084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* This is the un-inlined version of the code above */ 21094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyDict_GetItem(f->f_globals, w); 21104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x == NULL) { 21114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyDict_GetItem(f->f_builtins, w); 21124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x == NULL) { 21134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm load_global_error: 21144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm format_exc_check_arg( 21154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyExc_NameError, 21164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm GLOBAL_NAME_ERROR_MSG, w); 21174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 21184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 21194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 21204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(x); 21214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PUSH(x); 21224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 21234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 21244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case DELETE_FAST: 21254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = GETLOCAL(oparg); 21264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) { 21274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SETLOCAL(oparg, NULL); 21284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 21294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 21304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm format_exc_check_arg( 21314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyExc_UnboundLocalError, 21324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm UNBOUNDLOCAL_ERROR_MSG, 21334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyTuple_GetItem(co->co_varnames, oparg) 21344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ); 21354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 21364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 21374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case LOAD_CLOSURE: 21384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = freevars[oparg]; 21394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(x); 21404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PUSH(x); 21414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 21424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 21434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 21444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case LOAD_DEREF: 21454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = freevars[oparg]; 21464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = PyCell_Get(x); 21474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (w != NULL) { 21484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PUSH(w); 21494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 21504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 21514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = -1; 21524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Don't stomp existing exception */ 21534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyErr_Occurred()) 21544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 21554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (oparg < PyTuple_GET_SIZE(co->co_cellvars)) { 21564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = PyTuple_GET_ITEM(co->co_cellvars, 21574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm oparg); 21584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm format_exc_check_arg( 21594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyExc_UnboundLocalError, 21604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm UNBOUNDLOCAL_ERROR_MSG, 21614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v); 21624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } else { 21634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = PyTuple_GET_ITEM(co->co_freevars, oparg - 21644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyTuple_GET_SIZE(co->co_cellvars)); 21654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm format_exc_check_arg(PyExc_NameError, 21664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm UNBOUNDFREE_ERROR_MSG, v); 21674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 21684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 21694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 21704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case STORE_DEREF: 21714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 21724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = freevars[oparg]; 21734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyCell_Set(x, w); 21744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 21754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 21764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 21774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case BUILD_TUPLE: 21784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyTuple_New(oparg); 21794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) { 21804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (; --oparg >= 0;) { 21814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 21824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyTuple_SET_ITEM(x, oparg, w); 21834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 21844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PUSH(x); 21854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 21864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 21874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 21884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 21894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case BUILD_LIST: 21904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyList_New(oparg); 21914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) { 21924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (; --oparg >= 0;) { 21934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 21944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyList_SET_ITEM(x, oparg, w); 21954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 21964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PUSH(x); 21974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 21984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 21994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 22004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case BUILD_SET: 22024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PySet_New(NULL); 22034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) { 22044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (; --oparg >= 0;) { 22054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 22064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (err == 0) 22074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = PySet_Add(x, w); 22084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 22094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 22104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (err != 0) { 22114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(x); 22124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 22134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 22144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PUSH(x); 22154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 22164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 22174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 22184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case BUILD_MAP: 22214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = _PyDict_NewPresized((Py_ssize_t)oparg); 22224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PUSH(x); 22234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 22244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 22254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case STORE_MAP: 22274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = TOP(); /* key */ 22284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm u = SECOND(); /* value */ 22294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = THIRD(); /* dict */ 22304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm STACKADJ(-2); 22314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert (PyDict_CheckExact(v)); 22324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = PyDict_SetItem(v, w, u); /* v[w] = u */ 22334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(u); 22344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 22354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (err == 0) continue; 22364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 22374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case MAP_ADD: 22394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = TOP(); /* key */ 22404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm u = SECOND(); /* value */ 22414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm STACKADJ(-2); 22424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = stack_pointer[-oparg]; /* dict */ 22434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert (PyDict_CheckExact(v)); 22444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = PyDict_SetItem(v, w, u); /* v[w] = u */ 22454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(u); 22464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 22474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (err == 0) { 22484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PREDICT(JUMP_ABSOLUTE); 22494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 22504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 22514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 22524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case LOAD_ATTR: 22544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = GETITEM(names, oparg); 22554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 22564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyObject_GetAttr(v, w); 22574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 22584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 22594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 22604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 22614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case COMPARE_OP: 22634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 22644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 22654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyInt_CheckExact(w) && PyInt_CheckExact(v)) { 22664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* INLINE: cmp(int, int) */ 22674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm register long a, b; 22684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm register int res; 22694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = PyInt_AS_LONG(v); 22704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = PyInt_AS_LONG(w); 22714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm switch (oparg) { 22724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case PyCmp_LT: res = a < b; break; 22734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case PyCmp_LE: res = a <= b; break; 22744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case PyCmp_EQ: res = a == b; break; 22754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case PyCmp_NE: res = a != b; break; 22764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case PyCmp_GT: res = a > b; break; 22774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case PyCmp_GE: res = a >= b; break; 22784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case PyCmp_IS: res = v == w; break; 22794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case PyCmp_IS_NOT: res = v != w; break; 22804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm default: goto slow_compare; 22814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 22824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = res ? Py_True : Py_False; 22834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(x); 22844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 22854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 22864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm slow_compare: 22874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = cmp_outcome(oparg, v, w); 22884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 22894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 22904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 22914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 22924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x == NULL) break; 22934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PREDICT(POP_JUMP_IF_FALSE); 22944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PREDICT(POP_JUMP_IF_TRUE); 22954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 22964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case IMPORT_NAME: 22984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = GETITEM(names, oparg); 22994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyDict_GetItemString(f->f_builtins, "__import__"); 23004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x == NULL) { 23014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_ImportError, 23024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "__import__ not found"); 23034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 23044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 23054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(x); 23064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = POP(); 23074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm u = TOP(); 23084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyInt_AsLong(u) != -1 || PyErr_Occurred()) 23094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = PyTuple_Pack(5, 23104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w, 23114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_globals, 23124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_locals == NULL ? 23134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_None : f->f_locals, 23144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v, 23154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm u); 23164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 23174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = PyTuple_Pack(4, 23184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w, 23194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_globals, 23204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_locals == NULL ? 23214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_None : f->f_locals, 23224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v); 23234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 23244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(u); 23254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (w == NULL) { 23264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm u = POP(); 23274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(x); 23284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = NULL; 23294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 23304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 23314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm READ_TIMESTAMP(intr0); 23324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = x; 23334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyEval_CallObject(v, w); 23344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 23354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm READ_TIMESTAMP(intr1); 23364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 23374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 23384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 23394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 23404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 23414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case IMPORT_STAR: 23424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = POP(); 23434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFrame_FastToLocals(f); 23444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((x = f->f_locals) == NULL) { 23454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_SystemError, 23464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "no locals found during 'import *'"); 23474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 23484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 23494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm READ_TIMESTAMP(intr0); 23504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = import_all_from(x, v); 23514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm READ_TIMESTAMP(intr1); 23524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFrame_LocalsToFast(f, 0); 23534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 23544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (err == 0) continue; 23554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 23564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 23574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case IMPORT_FROM: 23584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = GETITEM(names, oparg); 23594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 23604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm READ_TIMESTAMP(intr0); 23614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = import_from(v, w); 23624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm READ_TIMESTAMP(intr1); 23634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PUSH(x); 23644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 23654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 23664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 23674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case JUMP_FORWARD: 23684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm JUMPBY(oparg); 23694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fast_next_opcode; 23704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 23714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PREDICTED_WITH_ARG(POP_JUMP_IF_FALSE); 23724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case POP_JUMP_IF_FALSE: 23734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 23744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (w == Py_True) { 23754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 23764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fast_next_opcode; 23774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 23784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (w == Py_False) { 23794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 23804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm JUMPTO(oparg); 23814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fast_next_opcode; 23824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 23834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = PyObject_IsTrue(w); 23844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 23854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (err > 0) 23864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = 0; 23874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (err == 0) 23884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm JUMPTO(oparg); 23894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 23904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 23914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 23924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 23934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PREDICTED_WITH_ARG(POP_JUMP_IF_TRUE); 23944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case POP_JUMP_IF_TRUE: 23954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 23964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (w == Py_False) { 23974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 23984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fast_next_opcode; 23994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 24004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (w == Py_True) { 24014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 24024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm JUMPTO(oparg); 24034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fast_next_opcode; 24044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 24054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = PyObject_IsTrue(w); 24064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 24074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (err > 0) { 24084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = 0; 24094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm JUMPTO(oparg); 24104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 24114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (err == 0) 24124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ; 24134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 24144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 24154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 24164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 24174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case JUMP_IF_FALSE_OR_POP: 24184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = TOP(); 24194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (w == Py_True) { 24204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm STACKADJ(-1); 24214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 24224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fast_next_opcode; 24234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 24244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (w == Py_False) { 24254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm JUMPTO(oparg); 24264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fast_next_opcode; 24274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 24284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = PyObject_IsTrue(w); 24294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (err > 0) { 24304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm STACKADJ(-1); 24314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 24324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = 0; 24334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 24344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (err == 0) 24354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm JUMPTO(oparg); 24364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 24374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 24384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 24394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 24404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case JUMP_IF_TRUE_OR_POP: 24414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = TOP(); 24424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (w == Py_False) { 24434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm STACKADJ(-1); 24444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 24454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fast_next_opcode; 24464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 24474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (w == Py_True) { 24484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm JUMPTO(oparg); 24494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fast_next_opcode; 24504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 24514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = PyObject_IsTrue(w); 24524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (err > 0) { 24534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = 0; 24544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm JUMPTO(oparg); 24554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 24564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (err == 0) { 24574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm STACKADJ(-1); 24584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 24594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 24604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 24614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 24624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 24634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 24644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PREDICTED_WITH_ARG(JUMP_ABSOLUTE); 24654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case JUMP_ABSOLUTE: 24664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm JUMPTO(oparg); 24674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#if FAST_LOOPS 24684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Enabling this path speeds-up all while and for-loops by bypassing 24694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm the per-loop checks for signals. By default, this should be turned-off 24704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm because it prevents detection of a control-break in tight loops like 24714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "while 1: pass". Compile with this option turned-on when you need 24724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm the speed-up and do not need break checking inside tight loops (ones 24734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm that contain only instructions ending with goto fast_next_opcode). 24744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 24754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fast_next_opcode; 24764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#else 24774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 24784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 24794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 24804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case GET_ITER: 24814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* before: [obj]; after [getiter(obj)] */ 24824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 24834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyObject_GetIter(v); 24844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 24854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) { 24864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 24874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PREDICT(FOR_ITER); 24884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 24894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 24904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm STACKADJ(-1); 24914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 24924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 24934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PREDICTED_WITH_ARG(FOR_ITER); 24944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case FOR_ITER: 24954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* before: [iter]; after: [iter, iter()] *or* [] */ 24964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 24974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = (*v->ob_type->tp_iternext)(v); 24984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) { 24994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PUSH(x); 25004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PREDICT(STORE_FAST); 25014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PREDICT(UNPACK_SEQUENCE); 25024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 25034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 25044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyErr_Occurred()) { 25054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!PyErr_ExceptionMatches( 25064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyExc_StopIteration)) 25074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 25084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Clear(); 25094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 25104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* iterator ended normally */ 25114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = v = POP(); 25124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 25134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm JUMPBY(oparg); 25144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 25154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 25164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case BREAK_LOOP: 25174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm why = WHY_BREAK; 25184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fast_block_end; 25194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 25204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case CONTINUE_LOOP: 25214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm retval = PyInt_FromLong(oparg); 25224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!retval) { 25234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = NULL; 25244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 25254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 25264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm why = WHY_CONTINUE; 25274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fast_block_end; 25284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 25294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case SETUP_LOOP: 25304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case SETUP_EXCEPT: 25314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case SETUP_FINALLY: 25324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* NOTE: If you add any new block-setup opcodes that 25334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm are not try/except/finally handlers, you may need 25344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm to update the PyGen_NeedsFinalizing() function. 25354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 25364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 25374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFrame_BlockSetup(f, opcode, INSTR_OFFSET() + oparg, 25384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm STACK_LEVEL()); 25394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 25404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 25414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case SETUP_WITH: 25424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm { 25434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm static PyObject *exit, *enter; 25444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = TOP(); 25454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = special_lookup(w, "__exit__", &exit); 25464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!x) 25474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 25484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 25494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm u = special_lookup(w, "__enter__", &enter); 25504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 25514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!u) { 25524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = NULL; 25534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 25544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 25554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyObject_CallFunctionObjArgs(u, NULL); 25564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(u); 25574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!x) 25584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 25594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Setup a finally block (SETUP_WITH as a block is 25604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm equivalent to SETUP_FINALLY except it normalizes 25614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm the exception) before pushing the result of 25624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm __enter__ on the stack. */ 25634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFrame_BlockSetup(f, SETUP_WITH, INSTR_OFFSET() + oparg, 25644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm STACK_LEVEL()); 25654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 25664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PUSH(x); 25674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 25684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 25694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 25704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case WITH_CLEANUP: 25714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm { 25724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* At the top of the stack are 1-3 values indicating 25734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm how/why we entered the finally clause: 25744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm - TOP = None 25754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm - (TOP, SECOND) = (WHY_{RETURN,CONTINUE}), retval 25764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm - TOP = WHY_*; no retval below it 25774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm - (TOP, SECOND, THIRD) = exc_info() 25784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Below them is EXIT, the context.__exit__ bound method. 25794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm In the last case, we must call 25804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm EXIT(TOP, SECOND, THIRD) 25814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm otherwise we must call 25824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm EXIT(None, None, None) 25834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 25844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm In all cases, we remove EXIT from the stack, leaving 25854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm the rest in the same order. 25864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 25874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm In addition, if the stack represents an exception, 25884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *and* the function call returns a 'true' value, we 25894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "zap" this information, to prevent END_FINALLY from 25904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm re-raising the exception. (But non-local gotos 25914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm should still be resumed.) 25924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 25934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 25944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *exit_func; 25954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 25964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm u = POP(); 25974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (u == Py_None) { 25984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm exit_func = TOP(); 25994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(u); 26004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = w = Py_None; 26014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 26024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyInt_Check(u)) { 26034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm switch(PyInt_AS_LONG(u)) { 26044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case WHY_RETURN: 26054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case WHY_CONTINUE: 26064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Retval in TOP. */ 26074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm exit_func = SECOND(); 26084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_SECOND(TOP()); 26094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(u); 26104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 26114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm default: 26124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm exit_func = TOP(); 26134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(u); 26144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 26154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 26164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm u = v = w = Py_None; 26174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 26184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 26194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = TOP(); 26204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = SECOND(); 26214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm exit_func = THIRD(); 26224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(u); 26234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_SECOND(v); 26244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_THIRD(w); 26254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 26264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* XXX Not the fastest way to call it... */ 26274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyObject_CallFunctionObjArgs(exit_func, u, v, w, 26284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm NULL); 26294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(exit_func); 26304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x == NULL) 26314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; /* Go to error exit */ 26324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 26334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (u != Py_None) 26344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = PyObject_IsTrue(x); 26354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 26364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = 0; 26374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(x); 26384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 26394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (err < 0) 26404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; /* Go to error exit */ 26414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (err > 0) { 26424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = 0; 26434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* There was an exception and a true return */ 26444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm STACKADJ(-2); 26454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(Py_None); 26464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(Py_None); 26474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(u); 26484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 26494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 26504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } else { 26514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* The stack was rearranged to remove EXIT 26524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm above. Let END_FINALLY do its thing */ 26534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 26544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PREDICT(END_FINALLY); 26554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 26564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 26574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 26584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case CALL_FUNCTION: 26594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm { 26604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject **sp; 26614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PCALL(PCALL_ALL); 26624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sp = stack_pointer; 26634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef WITH_TSC 26644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = call_function(&sp, oparg, &intr0, &intr1); 26654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#else 26664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = call_function(&sp, oparg); 26674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 26684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm stack_pointer = sp; 26694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PUSH(x); 26704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) 26714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 26724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 26734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 26744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 26754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case CALL_FUNCTION_VAR: 26764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case CALL_FUNCTION_KW: 26774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case CALL_FUNCTION_VAR_KW: 26784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm { 26794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int na = oparg & 0xff; 26804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int nk = (oparg>>8) & 0xff; 26814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int flags = (opcode - CALL_FUNCTION) & 3; 26824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int n = na + 2 * nk; 26834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject **pfunc, *func, **sp; 26844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PCALL(PCALL_ALL); 26854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (flags & CALL_FLAG_VAR) 26864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n++; 26874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (flags & CALL_FLAG_KW) 26884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n++; 26894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pfunc = stack_pointer - n - 1; 26904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm func = *pfunc; 26914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 26924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyMethod_Check(func) 26934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm && PyMethod_GET_SELF(func) != NULL) { 26944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *self = PyMethod_GET_SELF(func); 26954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(self); 26964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm func = PyMethod_GET_FUNCTION(func); 26974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(func); 26984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(*pfunc); 26994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *pfunc = self; 27004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm na++; 27014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } else 27024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(func); 27034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sp = stack_pointer; 27044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm READ_TIMESTAMP(intr0); 27054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = ext_do_call(func, &sp, flags, na, nk); 27064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm READ_TIMESTAMP(intr1); 27074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm stack_pointer = sp; 27084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(func); 27094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 27104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (stack_pointer > pfunc) { 27114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 27124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 27134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 27144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PUSH(x); 27154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) 27164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 27174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 27184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 27194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 27204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case MAKE_FUNCTION: 27214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = POP(); /* code object */ 27224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyFunction_New(v, f->f_globals); 27234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 27244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* XXX Maybe this should be a separate opcode? */ 27254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL && oparg > 0) { 27264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = PyTuple_New(oparg); 27274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (v == NULL) { 27284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(x); 27294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = NULL; 27304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 27314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 27324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (--oparg >= 0) { 27334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 27344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyTuple_SET_ITEM(v, oparg, w); 27354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 27364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = PyFunction_SetDefaults(x, v); 27374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 27384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 27394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PUSH(x); 27404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 27414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 27424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case MAKE_CLOSURE: 27434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm { 27444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = POP(); /* code object */ 27454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyFunction_New(v, f->f_globals); 27464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 27474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) { 27484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = POP(); 27494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyFunction_SetClosure(x, v) != 0) { 27504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Can't happen unless bytecode is corrupt. */ 27514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm why = WHY_EXCEPTION; 27524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 27534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 27544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 27554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL && oparg > 0) { 27564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = PyTuple_New(oparg); 27574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (v == NULL) { 27584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(x); 27594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = NULL; 27604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 27614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 27624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (--oparg >= 0) { 27634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 27644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyTuple_SET_ITEM(v, oparg, w); 27654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 27664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyFunction_SetDefaults(x, v) != 0) { 27674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Can't happen unless 27684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFunction_SetDefaults changes. */ 27694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm why = WHY_EXCEPTION; 27704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 27714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 27724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 27734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PUSH(x); 27744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 27754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 27764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 27774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case BUILD_SLICE: 27784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (oparg == 3) 27794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = POP(); 27804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 27814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = NULL; 27824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = POP(); 27834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm u = TOP(); 27844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PySlice_New(u, v, w); 27854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(u); 27864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 27874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(w); 27884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SET_TOP(x); 27894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) continue; 27904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 27914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 27924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case EXTENDED_ARG: 27934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm opcode = NEXTOP(); 27944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm oparg = oparg<<16 | NEXTARG(); 27954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto dispatch_opcode; 27964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 27974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm default: 27984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fprintf(stderr, 27994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "XXX lineno: %d, opcode: %d\n", 28004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFrame_GetLineNumber(f), 28014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm opcode); 28024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_SystemError, "unknown opcode"); 28034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm why = WHY_EXCEPTION; 28044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 28054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef CASE_TOO_BIG 28074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 28084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 28094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } /* switch */ 28114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm on_error: 28134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm READ_TIMESTAMP(inst1); 28154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Quickly continue if no error occurred */ 28174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (why == WHY_NOT) { 28194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (err == 0 && x != NULL) { 28204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef CHECKEXC 28214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* This check is expensive! */ 28224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyErr_Occurred()) 28234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fprintf(stderr, 28244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "XXX undetected error\n"); 28254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 28264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 28274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm READ_TIMESTAMP(loop1); 28284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; /* Normal, fast path */ 28294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef CHECKEXC 28304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 28314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 28324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 28334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm why = WHY_EXCEPTION; 28344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = Py_None; 28354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = 0; 28364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 28374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Double-check exception status */ 28394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (why == WHY_EXCEPTION || why == WHY_RERAISE) { 28414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!PyErr_Occurred()) { 28424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_SystemError, 28434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "error return without exception set"); 28444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm why = WHY_EXCEPTION; 28454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 28464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 28474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef CHECKEXC 28484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 28494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* This check is expensive! */ 28504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyErr_Occurred()) { 28514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char buf[128]; 28524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sprintf(buf, "Stack unwind with exception " 28534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "set and why=%d", why); 28544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_FatalError(buf); 28554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 28564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 28574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 28584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Log traceback info if this is a real exception */ 28604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (why == WHY_EXCEPTION) { 28624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyTraceBack_Here(f); 28634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (tstate->c_tracefunc != NULL) 28654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm call_exc_trace(tstate->c_tracefunc, 28664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->c_traceobj, f); 28674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 28684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* For the rest, treat WHY_RERAISE as WHY_EXCEPTION */ 28704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (why == WHY_RERAISE) 28724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm why = WHY_EXCEPTION; 28734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Unwind stacks if a (pseudo) exception occurred */ 28754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfast_block_end: 28774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (why != WHY_NOT && f->f_iblock > 0) { 28784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Peek at the current block. */ 28794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyTryBlock *b = &f->f_blockstack[f->f_iblock - 1]; 28804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(why != WHY_YIELD); 28824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (b->b_type == SETUP_LOOP && why == WHY_CONTINUE) { 28834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm why = WHY_NOT; 28844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm JUMPTO(PyInt_AS_LONG(retval)); 28854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(retval); 28864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 28874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 28884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Now we have to pop the block. */ 28904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_iblock--; 28914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (STACK_LEVEL() > b->b_level) { 28934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = POP(); 28944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(v); 28954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 28964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (b->b_type == SETUP_LOOP && why == WHY_BREAK) { 28974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm why = WHY_NOT; 28984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm JUMPTO(b->b_handler); 28994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 29004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 29014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (b->b_type == SETUP_FINALLY || 29024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (b->b_type == SETUP_EXCEPT && 29034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm why == WHY_EXCEPTION) || 29044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b->b_type == SETUP_WITH) { 29054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (why == WHY_EXCEPTION) { 29064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *exc, *val, *tb; 29074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Fetch(&exc, &val, &tb); 29084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (val == NULL) { 29094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm val = Py_None; 29104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(val); 29114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 29124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Make the raw exception data 29134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm available to the handler, 29144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm so a program can emulate the 29154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Python main loop. Don't do 29164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm this for 'finally'. */ 29174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (b->b_type == SETUP_EXCEPT || 29184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b->b_type == SETUP_WITH) { 29194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_NormalizeException( 29204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm &exc, &val, &tb); 29214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm set_exc_info(tstate, 29224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm exc, val, tb); 29234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 29244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (tb == NULL) { 29254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(Py_None); 29264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PUSH(Py_None); 29274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } else 29284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PUSH(tb); 29294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PUSH(val); 29304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PUSH(exc); 29314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 29324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 29334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (why & (WHY_RETURN | WHY_CONTINUE)) 29344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PUSH(retval); 29354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = PyInt_FromLong((long)why); 29364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PUSH(v); 29374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 29384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm why = WHY_NOT; 29394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm JUMPTO(b->b_handler); 29404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 29414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 29424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } /* unwind stack */ 29434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 29444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* End the loop if we still have an error (or return) */ 29454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 29464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (why != WHY_NOT) 29474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 29484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm READ_TIMESTAMP(loop1); 29494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 29504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } /* main loop */ 29514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 29524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(why != WHY_YIELD); 29534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Pop remaining stack entries. */ 29544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (!EMPTY()) { 29554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = POP(); 29564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(v); 29574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 29584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 29594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (why != WHY_RETURN) 29604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm retval = NULL; 29614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 29624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfast_yield: 29634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (tstate->use_tracing) { 29644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (tstate->c_tracefunc) { 29654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (why == WHY_RETURN || why == WHY_YIELD) { 29664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (call_trace(tstate->c_tracefunc, 29674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->c_traceobj, f, 29684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyTrace_RETURN, retval)) { 29694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(retval); 29704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm retval = NULL; 29714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm why = WHY_EXCEPTION; 29724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 29734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 29744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (why == WHY_EXCEPTION) { 29754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm call_trace_protected(tstate->c_tracefunc, 29764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->c_traceobj, f, 29774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyTrace_RETURN, NULL); 29784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 29794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 29804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (tstate->c_profilefunc) { 29814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (why == WHY_EXCEPTION) 29824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm call_trace_protected(tstate->c_profilefunc, 29834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->c_profileobj, f, 29844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyTrace_RETURN, NULL); 29854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (call_trace(tstate->c_profilefunc, 29864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->c_profileobj, f, 29874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyTrace_RETURN, retval)) { 29884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(retval); 29894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm retval = NULL; 29904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm why = WHY_EXCEPTION; 29914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 29924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 29934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 29944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 29954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (tstate->frame->f_exc_type != NULL) 29964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm reset_exc_info(tstate); 29974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 29984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(tstate->frame->f_exc_value == NULL); 29994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(tstate->frame->f_exc_traceback == NULL); 30004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 30014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 30024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* pop frame */ 30034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmexit_eval_frame: 30044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_LeaveRecursiveCall(); 30054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->frame = f->f_back; 30064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 30074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return retval; 30084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 30094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 30104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* This is gonna seem *real weird*, but if you put some other code between 30114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyEval_EvalFrame() and PyEval_EvalCodeEx() you will need to adjust 30124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm the test in the if statements in Misc/gdbinit (pystack and pystackv). */ 30134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 30144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyObject * 30154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyEval_EvalCodeEx(PyCodeObject *co, PyObject *globals, PyObject *locals, 30164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject **args, int argcount, PyObject **kws, int kwcount, 30174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject **defs, int defcount, PyObject *closure) 30184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 30194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm register PyFrameObject *f; 30204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm register PyObject *retval = NULL; 30214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm register PyObject **fastlocals, **freevars; 30224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyThreadState *tstate = PyThreadState_GET(); 30234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *x, *u; 30244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 30254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (globals == NULL) { 30264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_SystemError, 30274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "PyEval_EvalCodeEx: NULL globals"); 30284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 30294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 30304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 30314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(tstate != NULL); 30324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(globals != NULL); 30334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f = PyFrame_New(tstate, co, globals, locals); 30344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f == NULL) 30354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 30364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 30374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fastlocals = f->f_localsplus; 30384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm freevars = f->f_localsplus + co->co_nlocals; 30394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 30404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (co->co_argcount > 0 || 30414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm co->co_flags & (CO_VARARGS | CO_VARKEYWORDS)) { 30424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int i; 30434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int n = argcount; 30444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *kwdict = NULL; 30454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (co->co_flags & CO_VARKEYWORDS) { 30464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm kwdict = PyDict_New(); 30474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (kwdict == NULL) 30484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fail; 30494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = co->co_argcount; 30504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (co->co_flags & CO_VARARGS) 30514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i++; 30524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SETLOCAL(i, kwdict); 30534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 30544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (argcount > co->co_argcount) { 30554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!(co->co_flags & CO_VARARGS)) { 30564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Format(PyExc_TypeError, 30574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "%.200s() takes %s %d " 30584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "argument%s (%d given)", 30594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyString_AsString(co->co_name), 30604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm defcount ? "at most" : "exactly", 30614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm co->co_argcount, 30624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm co->co_argcount == 1 ? "" : "s", 30634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm argcount + kwcount); 30644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fail; 30654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 30664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n = co->co_argcount; 30674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 30684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 0; i < n; i++) { 30694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = args[i]; 30704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(x); 30714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SETLOCAL(i, x); 30724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 30734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (co->co_flags & CO_VARARGS) { 30744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm u = PyTuple_New(argcount - n); 30754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (u == NULL) 30764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fail; 30774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SETLOCAL(co->co_argcount, u); 30784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = n; i < argcount; i++) { 30794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = args[i]; 30804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(x); 30814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyTuple_SET_ITEM(u, i-n, x); 30824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 30834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 30844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 0; i < kwcount; i++) { 30854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject **co_varnames; 30864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *keyword = kws[2*i]; 30874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *value = kws[2*i + 1]; 30884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int j; 30894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (keyword == NULL || !(PyString_Check(keyword) 30904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef Py_USING_UNICODE 30914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm || PyUnicode_Check(keyword) 30924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 30934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm )) { 30944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Format(PyExc_TypeError, 30954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "%.200s() keywords must be strings", 30964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyString_AsString(co->co_name)); 30974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fail; 30984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 30994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Speed hack: do raw pointer compares. As names are 31004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm normally interned this should almost always hit. */ 31014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm co_varnames = ((PyTupleObject *)(co->co_varnames))->ob_item; 31024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (j = 0; j < co->co_argcount; j++) { 31034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *nm = co_varnames[j]; 31044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (nm == keyword) 31054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto kw_found; 31064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 31074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Slow fallback, just in case */ 31084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (j = 0; j < co->co_argcount; j++) { 31094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *nm = co_varnames[j]; 31104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int cmp = PyObject_RichCompareBool( 31114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm keyword, nm, Py_EQ); 31124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (cmp > 0) 31134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto kw_found; 31144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (cmp < 0) 31154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fail; 31164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 31174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (kwdict == NULL) { 31184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *kwd_str = kwd_as_string(keyword); 31194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (kwd_str) { 31204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Format(PyExc_TypeError, 31214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "%.200s() got an unexpected " 31224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "keyword argument '%.400s'", 31234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyString_AsString(co->co_name), 31244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyString_AsString(kwd_str)); 31254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(kwd_str); 31264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 31274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fail; 31284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 31294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyDict_SetItem(kwdict, keyword, value); 31304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 31314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm kw_found: 31324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (GETLOCAL(j) != NULL) { 31334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *kwd_str = kwd_as_string(keyword); 31344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (kwd_str) { 31354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Format(PyExc_TypeError, 31364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "%.200s() got multiple " 31374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "values for keyword " 31384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "argument '%.400s'", 31394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyString_AsString(co->co_name), 31404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyString_AsString(kwd_str)); 31414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(kwd_str); 31424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 31434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fail; 31444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 31454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(value); 31464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SETLOCAL(j, value); 31474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 31484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (argcount < co->co_argcount) { 31494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int m = co->co_argcount - defcount; 31504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = argcount; i < m; i++) { 31514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (GETLOCAL(i) == NULL) { 31524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int j, given = 0; 31534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (j = 0; j < co->co_argcount; j++) 31544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (GETLOCAL(j)) 31554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm given++; 31564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Format(PyExc_TypeError, 31574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "%.200s() takes %s %d " 31584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "argument%s (%d given)", 31594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyString_AsString(co->co_name), 31604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ((co->co_flags & CO_VARARGS) || 31614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm defcount) ? "at least" 31624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm : "exactly", 31634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm m, m == 1 ? "" : "s", given); 31644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fail; 31654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 31664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 31674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (n > m) 31684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = n - m; 31694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 31704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = 0; 31714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (; i < defcount; i++) { 31724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (GETLOCAL(m+i) == NULL) { 31734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *def = defs[i]; 31744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(def); 31754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SETLOCAL(m+i, def); 31764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 31774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 31784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 31794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 31804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (argcount > 0 || kwcount > 0) { 31814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Format(PyExc_TypeError, 31824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "%.200s() takes no arguments (%d given)", 31834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyString_AsString(co->co_name), 31844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm argcount + kwcount); 31854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fail; 31864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 31874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Allocate and initialize storage for cell vars, and copy free 31884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm vars into frame. This isn't too efficient right now. */ 31894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyTuple_GET_SIZE(co->co_cellvars)) { 31904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int i, j, nargs, found; 31914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char *cellname, *argname; 31924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *c; 31934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 31944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm nargs = co->co_argcount; 31954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (co->co_flags & CO_VARARGS) 31964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm nargs++; 31974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (co->co_flags & CO_VARKEYWORDS) 31984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm nargs++; 31994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 32004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Initialize each cell var, taking into account 32014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm cell vars that are initialized from arguments. 32024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 32034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Should arrange for the compiler to put cellvars 32044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm that are arguments at the beginning of the cellvars 32054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm list so that we can march over it more efficiently? 32064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 32074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 0; i < PyTuple_GET_SIZE(co->co_cellvars); ++i) { 32084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm cellname = PyString_AS_STRING( 32094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyTuple_GET_ITEM(co->co_cellvars, i)); 32104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm found = 0; 32114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (j = 0; j < nargs; j++) { 32124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm argname = PyString_AS_STRING( 32134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyTuple_GET_ITEM(co->co_varnames, j)); 32144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (strcmp(cellname, argname) == 0) { 32154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = PyCell_New(GETLOCAL(j)); 32164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (c == NULL) 32174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fail; 32184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm GETLOCAL(co->co_nlocals + i) = c; 32194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm found = 1; 32204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 32214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 32224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 32234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (found == 0) { 32244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = PyCell_New(NULL); 32254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (c == NULL) 32264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fail; 32274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SETLOCAL(co->co_nlocals + i, c); 32284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 32294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 32304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 32314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyTuple_GET_SIZE(co->co_freevars)) { 32324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int i; 32334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 0; i < PyTuple_GET_SIZE(co->co_freevars); ++i) { 32344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *o = PyTuple_GET_ITEM(closure, i); 32354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(o); 32364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm freevars[PyTuple_GET_SIZE(co->co_cellvars) + i] = o; 32374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 32384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 32394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 32404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (co->co_flags & CO_GENERATOR) { 32414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Don't need to keep the reference to f_back, it will be set 32424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * when the generator is resumed. */ 32434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(f->f_back); 32444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_back = NULL; 32454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 32464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PCALL(PCALL_GENERATOR); 32474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 32484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Create a new generator that owns the ready to run frame 32494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * and return that as the value. */ 32504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyGen_New(f); 32514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 32524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 32534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm retval = PyEval_EvalFrameEx(f,0); 32544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 32554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfail: /* Jump here from prelude on failure */ 32564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 32574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* decref'ing the frame can cause __del__ methods to get invoked, 32584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm which can call back into Python. While we're done with the 32594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm current Python frame (f), the associated C stack is still in use, 32604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm so recursion_depth must be boosted for the duration. 32614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 32624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(tstate != NULL); 32634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ++tstate->recursion_depth; 32644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(f); 32654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm --tstate->recursion_depth; 32664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return retval; 32674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 32684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 32694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 32704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 32714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmspecial_lookup(PyObject *o, char *meth, PyObject **cache) 32724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 32734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *res; 32744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyInstance_Check(o)) { 32754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!*cache) 32764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyObject_GetAttrString(o, meth); 32774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 32784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyObject_GetAttr(o, *cache); 32794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 32804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm res = _PyObject_LookupSpecial(o, meth, cache); 32814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (res == NULL && !PyErr_Occurred()) { 32824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetObject(PyExc_AttributeError, *cache); 32834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 32844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 32854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return res; 32864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 32874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 32884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 32894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 32904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmkwd_as_string(PyObject *kwd) { 32914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef Py_USING_UNICODE 32924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyString_Check(kwd)) { 32934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#else 32944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(PyString_Check(kwd)); 32954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 32964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(kwd); 32974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return kwd; 32984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef Py_USING_UNICODE 32994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 33004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return _PyUnicode_AsDefaultEncodedString(kwd, "replace"); 33014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 33024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 33034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 33044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 33054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Implementation notes for set_exc_info() and reset_exc_info(): 33064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 33074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm- Below, 'exc_ZZZ' stands for 'exc_type', 'exc_value' and 33084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'exc_traceback'. These always travel together. 33094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 33104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm- tstate->curexc_ZZZ is the "hot" exception that is set by 33114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(), cleared by PyErr_Clear(), and so on. 33124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 33134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm- Once an exception is caught by an except clause, it is transferred 33144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm from tstate->curexc_ZZZ to tstate->exc_ZZZ, from which sys.exc_info() 33154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm can pick it up. This is the primary task of set_exc_info(). 33164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm XXX That can't be right: set_exc_info() doesn't look at tstate->curexc_ZZZ. 33174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 33184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm- Now let me explain the complicated dance with frame->f_exc_ZZZ. 33194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 33204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Long ago, when none of this existed, there were just a few globals: 33214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm one set corresponding to the "hot" exception, and one set 33224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm corresponding to sys.exc_ZZZ. (Actually, the latter weren't C 33234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm globals; they were simply stored as sys.exc_ZZZ. For backwards 33244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm compatibility, they still are!) The problem was that in code like 33254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm this: 33264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 33274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 33284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "something that may fail" 33294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except "some exception": 33304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "do something else first" 33314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "print the exception from sys.exc_ZZZ." 33324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 33334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if "do something else first" invoked something that raised and caught 33344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm an exception, sys.exc_ZZZ were overwritten. That was a frequent 33354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm cause of subtle bugs. I fixed this by changing the semantics as 33364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm follows: 33374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 33384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm - Within one frame, sys.exc_ZZZ will hold the last exception caught 33394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *in that frame*. 33404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 33414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm - But initially, and as long as no exception is caught in a given 33424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm frame, sys.exc_ZZZ will hold the last exception caught in the 33434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm previous frame (or the frame before that, etc.). 33444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 33454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm The first bullet fixed the bug in the above example. The second 33464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm bullet was for backwards compatibility: it was (and is) common to 33474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm have a function that is called when an exception is caught, and to 33484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm have that function access the caught exception via sys.exc_ZZZ. 33494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (Example: traceback.print_exc()). 33504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 33514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm At the same time I fixed the problem that sys.exc_ZZZ weren't 33524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm thread-safe, by introducing sys.exc_info() which gets it from tstate; 33534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm but that's really a separate improvement. 33544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 33554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm The reset_exc_info() function in ceval.c restores the tstate->exc_ZZZ 33564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm variables to what they were before the current frame was called. The 33574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm set_exc_info() function saves them on the frame so that 33584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm reset_exc_info() can restore them. The invariant is that 33594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm frame->f_exc_ZZZ is NULL iff the current frame never caught an 33604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm exception (where "catching" an exception applies only to successful 33614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except clauses); and if the current frame ever caught an exception, 33624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm frame->f_exc_ZZZ is the exception that was stored in tstate->exc_ZZZ 33634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm at the start of the current frame. 33644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 33654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm*/ 33664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 33674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic void 33684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmset_exc_info(PyThreadState *tstate, 33694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *type, PyObject *value, PyObject *tb) 33704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 33714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFrameObject *frame = tstate->frame; 33724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *tmp_type, *tmp_value, *tmp_tb; 33734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 33744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(type != NULL); 33754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(frame != NULL); 33764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (frame->f_exc_type == NULL) { 33774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(frame->f_exc_value == NULL); 33784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(frame->f_exc_traceback == NULL); 33794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* This frame didn't catch an exception before. */ 33804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Save previous exception of this thread in this frame. */ 33814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (tstate->exc_type == NULL) { 33824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* XXX Why is this set to Py_None? */ 33834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(Py_None); 33844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->exc_type = Py_None; 33854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 33864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(tstate->exc_type); 33874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XINCREF(tstate->exc_value); 33884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XINCREF(tstate->exc_traceback); 33894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm frame->f_exc_type = tstate->exc_type; 33904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm frame->f_exc_value = tstate->exc_value; 33914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm frame->f_exc_traceback = tstate->exc_traceback; 33924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 33934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Set new exception for this thread. */ 33944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tmp_type = tstate->exc_type; 33954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tmp_value = tstate->exc_value; 33964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tmp_tb = tstate->exc_traceback; 33974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(type); 33984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XINCREF(value); 33994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XINCREF(tb); 34004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->exc_type = type; 34014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->exc_value = value; 34024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->exc_traceback = tb; 34034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(tmp_type); 34044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(tmp_value); 34054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(tmp_tb); 34064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* For b/w compatibility */ 34074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PySys_SetObject("exc_type", type); 34084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PySys_SetObject("exc_value", value); 34094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PySys_SetObject("exc_traceback", tb); 34104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 34114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 34124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic void 34134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmreset_exc_info(PyThreadState *tstate) 34144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 34154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFrameObject *frame; 34164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *tmp_type, *tmp_value, *tmp_tb; 34174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 34184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* It's a precondition that the thread state's frame caught an 34194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * exception -- verify in a debug build. 34204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 34214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(tstate != NULL); 34224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm frame = tstate->frame; 34234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(frame != NULL); 34244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(frame->f_exc_type != NULL); 34254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 34264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Copy the frame's exception info back to the thread state. */ 34274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tmp_type = tstate->exc_type; 34284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tmp_value = tstate->exc_value; 34294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tmp_tb = tstate->exc_traceback; 34304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(frame->f_exc_type); 34314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XINCREF(frame->f_exc_value); 34324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XINCREF(frame->f_exc_traceback); 34334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->exc_type = frame->f_exc_type; 34344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->exc_value = frame->f_exc_value; 34354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->exc_traceback = frame->f_exc_traceback; 34364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(tmp_type); 34374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(tmp_value); 34384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(tmp_tb); 34394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 34404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* For b/w compatibility */ 34414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PySys_SetObject("exc_type", frame->f_exc_type); 34424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PySys_SetObject("exc_value", frame->f_exc_value); 34434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PySys_SetObject("exc_traceback", frame->f_exc_traceback); 34444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 34454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Clear the frame's exception info. */ 34464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tmp_type = frame->f_exc_type; 34474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tmp_value = frame->f_exc_value; 34484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tmp_tb = frame->f_exc_traceback; 34494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm frame->f_exc_type = NULL; 34504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm frame->f_exc_value = NULL; 34514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm frame->f_exc_traceback = NULL; 34524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(tmp_type); 34534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(tmp_value); 34544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(tmp_tb); 34554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 34564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 34574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Logic for the raise statement (too complicated for inlining). 34584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm This *consumes* a reference count to each of its arguments. */ 34594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic enum why_code 34604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdo_raise(PyObject *type, PyObject *value, PyObject *tb) 34614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 34624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (type == NULL) { 34634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Reraise */ 34644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyThreadState *tstate = PyThreadState_GET(); 34654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm type = tstate->exc_type == NULL ? Py_None : tstate->exc_type; 34664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm value = tstate->exc_value; 34674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tb = tstate->exc_traceback; 34684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XINCREF(type); 34694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XINCREF(value); 34704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XINCREF(tb); 34714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 34724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 34734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* We support the following forms of raise: 34744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise <class>, <classinstance> 34754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise <class>, <argument tuple> 34764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise <class>, None 34774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise <class>, <argument> 34784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise <classinstance>, None 34794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise <string>, <object> 34804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise <string>, None 34814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 34824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm An omitted second argument is the same as None. 34834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 34844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm In addition, raise <tuple>, <anything> is the same as 34854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raising the tuple's first item (and it better have one!); 34864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm this rule is applied recursively. 34874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 34884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Finally, an optional third argument can be supplied, which 34894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm gives the traceback to be substituted (useful when 34904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm re-raising an exception after examining it). */ 34914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 34924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* First, check the traceback argument, replacing None with 34934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm NULL. */ 34944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (tb == Py_None) { 34954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(tb); 34964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tb = NULL; 34974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 34984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (tb != NULL && !PyTraceBack_Check(tb)) { 34994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_TypeError, 35004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "raise: arg 3 must be a traceback or None"); 35014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto raise_error; 35024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 35034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 35044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Next, replace a missing value with None */ 35054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (value == NULL) { 35064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm value = Py_None; 35074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(value); 35084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 35094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 35104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Next, repeatedly, replace a tuple exception with its first item */ 35114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (PyTuple_Check(type) && PyTuple_Size(type) > 0) { 35124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *tmp = type; 35134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm type = PyTuple_GET_ITEM(type, 0); 35144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(type); 35154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(tmp); 35164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 35174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 35184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyExceptionClass_Check(type)) 35194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_NormalizeException(&type, &value, &tb); 35204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 35214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyExceptionInstance_Check(type)) { 35224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Raising an instance. The value should be a dummy. */ 35234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (value != Py_None) { 35244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_TypeError, 35254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "instance exception may not have a separate value"); 35264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto raise_error; 35274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 35284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 35294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Normalize to raise <class>, <instance> */ 35304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(value); 35314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm value = type; 35324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm type = PyExceptionInstance_Class(type); 35334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(type); 35344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 35354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 35364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 35374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Not something you can raise. You get an exception 35384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm anyway, just not what you specified :-) */ 35394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Format(PyExc_TypeError, 35404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "exceptions must be old-style classes or " 35414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "derived from BaseException, not %s", 35424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm type->ob_type->tp_name); 35434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto raise_error; 35444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 35454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 35464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(PyExceptionClass_Check(type)); 35474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (Py_Py3kWarningFlag && PyClass_Check(type)) { 35484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyErr_WarnEx(PyExc_DeprecationWarning, 35494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "exceptions must derive from BaseException " 35504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "in 3.x", 1) < 0) 35514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto raise_error; 35524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 35534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 35544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Restore(type, value, tb); 35554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (tb == NULL) 35564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return WHY_EXCEPTION; 35574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 35584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return WHY_RERAISE; 35594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise_error: 35604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(value); 35614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(type); 35624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(tb); 35634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return WHY_EXCEPTION; 35644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 35654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 35664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Iterate v argcnt times and store the results on the stack (via decreasing 35674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sp). Return 1 for success, 0 if error. */ 35684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 35694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int 35704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmunpack_iterable(PyObject *v, int argcnt, PyObject **sp) 35714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 35724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int i = 0; 35734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *it; /* iter(v) */ 35744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *w; 35754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 35764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(v != NULL); 35774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 35784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm it = PyObject_GetIter(v); 35794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (it == NULL) 35804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto Error; 35814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 35824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (; i < argcnt; i++) { 35834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = PyIter_Next(it); 35844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (w == NULL) { 35854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Iterator done, via error or exhaustion. */ 35864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!PyErr_Occurred()) { 35874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Format(PyExc_ValueError, 35884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "need more than %d value%s to unpack", 35894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i, i == 1 ? "" : "s"); 35904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 35914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto Error; 35924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 35934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *--sp = w; 35944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 35954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 35964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* We better have exhausted the iterator now. */ 35974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = PyIter_Next(it); 35984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (w == NULL) { 35994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyErr_Occurred()) 36004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto Error; 36014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(it); 36024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 1; 36034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 36044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 36054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_ValueError, "too many values to unpack"); 36064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* fall through */ 36074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmError: 36084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (; i > 0; i--, sp++) 36094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(*sp); 36104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(it); 36114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 36124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 36134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 36144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 36154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef LLTRACE 36164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int 36174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmprtrace(PyObject *v, char *str) 36184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 36194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm printf("%s ", str); 36204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyObject_Print(v, stdout, 0) != 0) 36214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Clear(); /* Don't know what else to do */ 36224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm printf("\n"); 36234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 1; 36244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 36254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 36264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 36274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic void 36284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmcall_exc_trace(Py_tracefunc func, PyObject *self, PyFrameObject *f) 36294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 36304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *type, *value, *traceback, *arg; 36314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int err; 36324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Fetch(&type, &value, &traceback); 36334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (value == NULL) { 36344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm value = Py_None; 36354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(value); 36364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 36374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm arg = PyTuple_Pack(3, type, value, traceback); 36384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (arg == NULL) { 36394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Restore(type, value, traceback); 36404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return; 36414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 36424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = call_trace(func, self, f, PyTrace_EXCEPTION, arg); 36434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(arg); 36444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (err == 0) 36454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Restore(type, value, traceback); 36464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 36474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(type); 36484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(value); 36494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(traceback); 36504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 36514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 36524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 36534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int 36544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmcall_trace_protected(Py_tracefunc func, PyObject *obj, PyFrameObject *frame, 36554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int what, PyObject *arg) 36564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 36574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *type, *value, *traceback; 36584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int err; 36594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Fetch(&type, &value, &traceback); 36604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = call_trace(func, obj, frame, what, arg); 36614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (err == 0) 36624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm { 36634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Restore(type, value, traceback); 36644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 36654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 36664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 36674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(type); 36684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(value); 36694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(traceback); 36704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 36714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 36724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 36734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 36744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int 36754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmcall_trace(Py_tracefunc func, PyObject *obj, PyFrameObject *frame, 36764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int what, PyObject *arg) 36774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 36784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm register PyThreadState *tstate = frame->f_tstate; 36794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int result; 36804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (tstate->tracing) 36814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 36824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->tracing++; 36834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->use_tracing = 0; 36844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = func(obj, frame, what, arg); 36854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->use_tracing = ((tstate->c_tracefunc != NULL) 36864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm || (tstate->c_profilefunc != NULL)); 36874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->tracing--; 36884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return result; 36894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 36904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 36914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyObject * 36924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm_PyEval_CallTracing(PyObject *func, PyObject *args) 36934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 36944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFrameObject *frame = PyEval_GetFrame(); 36954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyThreadState *tstate = frame->f_tstate; 36964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int save_tracing = tstate->tracing; 36974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int save_use_tracing = tstate->use_tracing; 36984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *result; 36994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 37004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->tracing = 0; 37014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->use_tracing = ((tstate->c_tracefunc != NULL) 37024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm || (tstate->c_profilefunc != NULL)); 37034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = PyObject_Call(func, args, NULL); 37044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->tracing = save_tracing; 37054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->use_tracing = save_use_tracing; 37064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return result; 37074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 37084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 37094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* See Objects/lnotab_notes.txt for a description of how tracing works. */ 37104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int 37114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmmaybe_call_line_trace(Py_tracefunc func, PyObject *obj, 37124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFrameObject *frame, int *instr_lb, int *instr_ub, 37134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int *instr_prev) 37144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 37154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int result = 0; 37164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int line = frame->f_lineno; 37174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 37184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* If the last instruction executed isn't in the current 37194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm instruction window, reset the window. 37204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 37214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (frame->f_lasti < *instr_lb || frame->f_lasti >= *instr_ub) { 37224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyAddrPair bounds; 37234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm line = _PyCode_CheckLineNumber(frame->f_code, frame->f_lasti, 37244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm &bounds); 37254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *instr_lb = bounds.ap_lower; 37264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *instr_ub = bounds.ap_upper; 37274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 37284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* If the last instruction falls at the start of a line or if 37294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm it represents a jump backwards, update the frame's line 37304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm number and call the trace function. */ 37314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (frame->f_lasti == *instr_lb || frame->f_lasti < *instr_prev) { 37324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm frame->f_lineno = line; 37334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = call_trace(func, obj, frame, PyTrace_LINE, Py_None); 37344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 37354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *instr_prev = frame->f_lasti; 37364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return result; 37374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 37384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 37394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmvoid 37404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyEval_SetProfile(Py_tracefunc func, PyObject *arg) 37414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 37424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyThreadState *tstate = PyThreadState_GET(); 37434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *temp = tstate->c_profileobj; 37444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XINCREF(arg); 37454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->c_profilefunc = NULL; 37464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->c_profileobj = NULL; 37474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Must make sure that tracing is not ignored if 'temp' is freed */ 37484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->use_tracing = tstate->c_tracefunc != NULL; 37494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(temp); 37504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->c_profilefunc = func; 37514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->c_profileobj = arg; 37524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Flag that tracing or profiling is turned on */ 37534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->use_tracing = (func != NULL) || (tstate->c_tracefunc != NULL); 37544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 37554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 37564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmvoid 37574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyEval_SetTrace(Py_tracefunc func, PyObject *arg) 37584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 37594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyThreadState *tstate = PyThreadState_GET(); 37604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *temp = tstate->c_traceobj; 37614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm _Py_TracingPossible += (func != NULL) - (tstate->c_tracefunc != NULL); 37624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XINCREF(arg); 37634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->c_tracefunc = NULL; 37644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->c_traceobj = NULL; 37654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Must make sure that profiling is not ignored if 'temp' is freed */ 37664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->use_tracing = tstate->c_profilefunc != NULL; 37674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(temp); 37684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->c_tracefunc = func; 37694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->c_traceobj = arg; 37704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Flag that tracing or profiling is turned on */ 37714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->use_tracing = ((func != NULL) 37724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm || (tstate->c_profilefunc != NULL)); 37734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 37744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 37754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyObject * 37764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyEval_GetBuiltins(void) 37774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 37784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFrameObject *current_frame = PyEval_GetFrame(); 37794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (current_frame == NULL) 37804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyThreadState_GET()->interp->builtins; 37814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 37824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return current_frame->f_builtins; 37834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 37844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 37854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyObject * 37864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyEval_GetLocals(void) 37874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 37884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFrameObject *current_frame = PyEval_GetFrame(); 37894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (current_frame == NULL) 37904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 37914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFrame_FastToLocals(current_frame); 37924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return current_frame->f_locals; 37934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 37944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 37954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyObject * 37964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyEval_GetGlobals(void) 37974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 37984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFrameObject *current_frame = PyEval_GetFrame(); 37994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (current_frame == NULL) 38004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 38014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 38024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return current_frame->f_globals; 38034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 38044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 38054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyFrameObject * 38064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyEval_GetFrame(void) 38074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 38084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyThreadState *tstate = PyThreadState_GET(); 38094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return _PyThreadState_GetFrame(tstate); 38104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 38114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 38124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmint 38134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyEval_GetRestricted(void) 38144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 38154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFrameObject *current_frame = PyEval_GetFrame(); 38164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return current_frame == NULL ? 0 : PyFrame_IsRestricted(current_frame); 38174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 38184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 38194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmint 38204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyEval_MergeCompilerFlags(PyCompilerFlags *cf) 38214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 38224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFrameObject *current_frame = PyEval_GetFrame(); 38234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int result = cf->cf_flags != 0; 38244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 38254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (current_frame != NULL) { 38264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm const int codeflags = current_frame->f_code->co_flags; 38274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm const int compilerflags = codeflags & PyCF_MASK; 38284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (compilerflags) { 38294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = 1; 38304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm cf->cf_flags |= compilerflags; 38314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 38324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#if 0 /* future keyword */ 38334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (codeflags & CO_GENERATOR_ALLOWED) { 38344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = 1; 38354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm cf->cf_flags |= CO_GENERATOR_ALLOWED; 38364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 38374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 38384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 38394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return result; 38404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 38414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 38424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmint 38434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPy_FlushLine(void) 38444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 38454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *f = PySys_GetObject("stdout"); 38464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f == NULL) 38474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 38484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!PyFile_SoftSpace(f, 0)) 38494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 38504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyFile_WriteString("\n", f); 38514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 38524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 38534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 38544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* External interface to call any callable object. 38554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm The arg must be a tuple or NULL. The kw must be a dict or NULL. */ 38564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 38574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyObject * 38584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyEval_CallObjectWithKeywords(PyObject *func, PyObject *arg, PyObject *kw) 38594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 38604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *result; 38614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 38624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (arg == NULL) { 38634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm arg = PyTuple_New(0); 38644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (arg == NULL) 38654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 38664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 38674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (!PyTuple_Check(arg)) { 38684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_TypeError, 38694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "argument list must be a tuple"); 38704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 38714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 38724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 38734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(arg); 38744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 38754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (kw != NULL && !PyDict_Check(kw)) { 38764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_TypeError, 38774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "keyword list must be a dictionary"); 38784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(arg); 38794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 38804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 38814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 38824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = PyObject_Call(func, arg, kw); 38834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(arg); 38844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return result; 38854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 38864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 38874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmconst char * 38884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyEval_GetFuncName(PyObject *func) 38894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 38904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyMethod_Check(func)) 38914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyEval_GetFuncName(PyMethod_GET_FUNCTION(func)); 38924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyFunction_Check(func)) 38934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyString_AsString(((PyFunctionObject*)func)->func_name); 38944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyCFunction_Check(func)) 38954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return ((PyCFunctionObject*)func)->m_ml->ml_name; 38964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyClass_Check(func)) 38974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyString_AsString(((PyClassObject*)func)->cl_name); 38984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyInstance_Check(func)) { 38994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyString_AsString( 39004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ((PyInstanceObject*)func)->in_class->cl_name); 39014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } else { 39024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return func->ob_type->tp_name; 39034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 39044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 39054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 39064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmconst char * 39074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyEval_GetFuncDesc(PyObject *func) 39084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 39094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyMethod_Check(func)) 39104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return "()"; 39114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyFunction_Check(func)) 39124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return "()"; 39134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyCFunction_Check(func)) 39144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return "()"; 39154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyClass_Check(func)) 39164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return " constructor"; 39174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyInstance_Check(func)) { 39184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return " instance"; 39194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } else { 39204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return " object"; 39214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 39224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 39234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 39244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic void 39254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmerr_args(PyObject *func, int flags, int nargs) 39264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 39274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (flags & METH_NOARGS) 39284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Format(PyExc_TypeError, 39294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "%.200s() takes no arguments (%d given)", 39304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ((PyCFunctionObject *)func)->m_ml->ml_name, 39314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm nargs); 39324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 39334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Format(PyExc_TypeError, 39344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "%.200s() takes exactly one argument (%d given)", 39354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ((PyCFunctionObject *)func)->m_ml->ml_name, 39364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm nargs); 39374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 39384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 39394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define C_TRACE(x, call) \ 39404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmif (tstate->use_tracing && tstate->c_profilefunc) { \ 39414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (call_trace(tstate->c_profilefunc, \ 39424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->c_profileobj, \ 39434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->frame, PyTrace_C_CALL, \ 39444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm func)) { \ 39454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = NULL; \ 39464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } \ 39474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { \ 39484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = call; \ 39494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (tstate->c_profilefunc != NULL) { \ 39504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x == NULL) { \ 39514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm call_trace_protected(tstate->c_profilefunc, \ 39524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->c_profileobj, \ 39534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->frame, PyTrace_C_EXCEPTION, \ 39544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm func); \ 39554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* XXX should pass (type, value, tb) */ \ 39564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } else { \ 39574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (call_trace(tstate->c_profilefunc, \ 39584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->c_profileobj, \ 39594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tstate->frame, PyTrace_C_RETURN, \ 39604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm func)) { \ 39614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(x); \ 39624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = NULL; \ 39634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } \ 39644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } \ 39654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } \ 39664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } \ 39674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} else { \ 39684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = call; \ 39694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 39704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 39714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 39724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmcall_function(PyObject ***pp_stack, int oparg 39734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef WITH_TSC 39744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm , uint64* pintr0, uint64* pintr1 39754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 39764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ) 39774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 39784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int na = oparg & 0xff; 39794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int nk = (oparg>>8) & 0xff; 39804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int n = na + 2 * nk; 39814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject **pfunc = (*pp_stack) - n - 1; 39824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *func = *pfunc; 39834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *x, *w; 39844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 39854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Always dispatch PyCFunction first, because these are 39864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm presumed to be the most frequent callable object. 39874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 39884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyCFunction_Check(func) && nk == 0) { 39894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int flags = PyCFunction_GET_FLAGS(func); 39904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyThreadState *tstate = PyThreadState_GET(); 39914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 39924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PCALL(PCALL_CFUNCTION); 39934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (flags & (METH_NOARGS | METH_O)) { 39944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyCFunction meth = PyCFunction_GET_FUNCTION(func); 39954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *self = PyCFunction_GET_SELF(func); 39964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (flags & METH_NOARGS && na == 0) { 39974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm C_TRACE(x, (*meth)(self,NULL)); 39984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 39994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (flags & METH_O && na == 1) { 40004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *arg = EXT_POP(*pp_stack); 40014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm C_TRACE(x, (*meth)(self,arg)); 40024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(arg); 40034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 40044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 40054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err_args(func, flags, na); 40064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = NULL; 40074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 40084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 40094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 40104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *callargs; 40114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm callargs = load_args(pp_stack, na); 40124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm READ_TIMESTAMP(*pintr0); 40134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm C_TRACE(x, PyCFunction_Call(func,callargs,NULL)); 40144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm READ_TIMESTAMP(*pintr1); 40154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(callargs); 40164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 40174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } else { 40184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyMethod_Check(func) && PyMethod_GET_SELF(func) != NULL) { 40194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* optimize access to bound methods */ 40204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *self = PyMethod_GET_SELF(func); 40214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PCALL(PCALL_METHOD); 40224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PCALL(PCALL_BOUND_METHOD); 40234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(self); 40244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm func = PyMethod_GET_FUNCTION(func); 40254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(func); 40264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(*pfunc); 40274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *pfunc = self; 40284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm na++; 40294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n++; 40304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } else 40314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(func); 40324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm READ_TIMESTAMP(*pintr0); 40334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyFunction_Check(func)) 40344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = fast_function(func, pp_stack, n, na, nk); 40354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 40364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = do_call(func, pp_stack, na, nk); 40374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm READ_TIMESTAMP(*pintr1); 40384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(func); 40394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 40404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 40414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Clear the stack of the function object. Also removes 40424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm the arguments in case they weren't consumed already 40434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (fast_function() and err_args() leave them on the stack). 40444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 40454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while ((*pp_stack) > pfunc) { 40464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = EXT_POP(*pp_stack); 40474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 40484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PCALL(PCALL_POP); 40494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 40504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return x; 40514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 40524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 40534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* The fast_function() function optimize calls for which no argument 40544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tuple is necessary; the objects are passed directly from the stack. 40554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm For the simplest case -- a function that takes only positional 40564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm arguments and is called with only positional arguments -- it 40574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm inlines the most primitive frame setup code from 40584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyEval_EvalCodeEx(), which vastly reduces the checks that must be 40594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm done before evaluating the frame. 40604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm*/ 40614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 40624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 40634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfast_function(PyObject *func, PyObject ***pp_stack, int n, int na, int nk) 40644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 40654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); 40664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *globals = PyFunction_GET_GLOBALS(func); 40674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *argdefs = PyFunction_GET_DEFAULTS(func); 40684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject **d = NULL; 40694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int nd = 0; 40704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 40714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PCALL(PCALL_FUNCTION); 40724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PCALL(PCALL_FAST_FUNCTION); 40734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (argdefs == NULL && co->co_argcount == n && nk==0 && 40744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { 40754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFrameObject *f; 40764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *retval = NULL; 40774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyThreadState *tstate = PyThreadState_GET(); 40784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject **fastlocals, **stack; 40794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int i; 40804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 40814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PCALL(PCALL_FASTER_FUNCTION); 40824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(globals != NULL); 40834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* XXX Perhaps we should create a specialized 40844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFrame_New() that doesn't take locals, but does 40854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm take builtins without sanity checking them. 40864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 40874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(tstate != NULL); 40884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f = PyFrame_New(tstate, co, globals, NULL); 40894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (f == NULL) 40904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 40914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 40924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fastlocals = f->f_localsplus; 40934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm stack = (*pp_stack) - n; 40944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 40954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 0; i < n; i++) { 40964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(*stack); 40974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fastlocals[i] = *stack++; 40984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 40994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm retval = PyEval_EvalFrameEx(f,0); 41004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ++tstate->recursion_depth; 41014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(f); 41024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm --tstate->recursion_depth; 41034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return retval; 41044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 41054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (argdefs != NULL) { 41064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d = &PyTuple_GET_ITEM(argdefs, 0); 41074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm nd = Py_SIZE(argdefs); 41084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 41094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyEval_EvalCodeEx(co, globals, 41104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (PyObject *)NULL, (*pp_stack)-n, na, 41114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (*pp_stack)-2*nk, nk, d, nd, 41124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFunction_GET_CLOSURE(func)); 41134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 41144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 41154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 41164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmupdate_keyword_args(PyObject *orig_kwdict, int nk, PyObject ***pp_stack, 41174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *func) 41184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 41194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *kwdict = NULL; 41204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (orig_kwdict == NULL) 41214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm kwdict = PyDict_New(); 41224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 41234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm kwdict = PyDict_Copy(orig_kwdict); 41244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(orig_kwdict); 41254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 41264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (kwdict == NULL) 41274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 41284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (--nk >= 0) { 41294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int err; 41304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *value = EXT_POP(*pp_stack); 41314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *key = EXT_POP(*pp_stack); 41324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyDict_GetItem(kwdict, key) != NULL) { 41334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Format(PyExc_TypeError, 41344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "%.200s%s got multiple values " 41354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "for keyword argument '%.200s'", 41364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyEval_GetFuncName(func), 41374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyEval_GetFuncDesc(func), 41384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyString_AsString(key)); 41394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(key); 41404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(value); 41414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(kwdict); 41424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 41434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 41444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = PyDict_SetItem(kwdict, key, value); 41454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(key); 41464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(value); 41474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (err) { 41484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(kwdict); 41494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 41504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 41514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 41524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return kwdict; 41534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 41544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 41554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 41564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmupdate_star_args(int nstack, int nstar, PyObject *stararg, 41574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject ***pp_stack) 41584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 41594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *callargs, *w; 41604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 41614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm callargs = PyTuple_New(nstack + nstar); 41624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (callargs == NULL) { 41634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 41644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 41654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (nstar) { 41664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int i; 41674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 0; i < nstar; i++) { 41684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *a = PyTuple_GET_ITEM(stararg, i); 41694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(a); 41704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyTuple_SET_ITEM(callargs, nstack + i, a); 41714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 41724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 41734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (--nstack >= 0) { 41744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = EXT_POP(*pp_stack); 41754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyTuple_SET_ITEM(callargs, nstack, w); 41764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 41774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return callargs; 41784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 41794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 41804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 41814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmload_args(PyObject ***pp_stack, int na) 41824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 41834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *args = PyTuple_New(na); 41844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *w; 41854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 41864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (args == NULL) 41874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 41884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (--na >= 0) { 41894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = EXT_POP(*pp_stack); 41904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyTuple_SET_ITEM(args, na, w); 41914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 41924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return args; 41934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 41944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 41954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 41964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdo_call(PyObject *func, PyObject ***pp_stack, int na, int nk) 41974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 41984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *callargs = NULL; 41994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *kwdict = NULL; 42004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *result = NULL; 42014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 42024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (nk > 0) { 42034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm kwdict = update_keyword_args(NULL, nk, pp_stack, func); 42044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (kwdict == NULL) 42054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto call_fail; 42064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 42074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm callargs = load_args(pp_stack, na); 42084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (callargs == NULL) 42094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto call_fail; 42104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef CALL_PROFILE 42114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* At this point, we have to look at the type of func to 42124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm update the call stats properly. Do it here so as to avoid 42134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm exposing the call stats machinery outside ceval.c 42144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 42154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyFunction_Check(func)) 42164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PCALL(PCALL_FUNCTION); 42174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyMethod_Check(func)) 42184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PCALL(PCALL_METHOD); 42194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyType_Check(func)) 42204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PCALL(PCALL_TYPE); 42214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyCFunction_Check(func)) 42224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PCALL(PCALL_CFUNCTION); 42234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 42244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PCALL(PCALL_OTHER); 42254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 42264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyCFunction_Check(func)) { 42274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyThreadState *tstate = PyThreadState_GET(); 42284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm C_TRACE(result, PyCFunction_Call(func, callargs, kwdict)); 42294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 42304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 42314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = PyObject_Call(func, callargs, kwdict); 42324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm call_fail: 42334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(callargs); 42344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(kwdict); 42354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return result; 42364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 42374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 42384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 42394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmext_do_call(PyObject *func, PyObject ***pp_stack, int flags, int na, int nk) 42404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 42414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int nstar = 0; 42424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *callargs = NULL; 42434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *stararg = NULL; 42444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *kwdict = NULL; 42454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *result = NULL; 42464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 42474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (flags & CALL_FLAG_KW) { 42484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm kwdict = EXT_POP(*pp_stack); 42494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!PyDict_Check(kwdict)) { 42504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *d; 42514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d = PyDict_New(); 42524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (d == NULL) 42534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto ext_call_fail; 42544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyDict_Update(d, kwdict) != 0) { 42554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(d); 42564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* PyDict_Update raises attribute 42574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * error (percolated from an attempt 42584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * to get 'keys' attribute) instead of 42594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * a type error if its second argument 42604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * is not a mapping. 42614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 42624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyErr_ExceptionMatches(PyExc_AttributeError)) { 42634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Format(PyExc_TypeError, 42644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "%.200s%.200s argument after ** " 42654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "must be a mapping, not %.200s", 42664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyEval_GetFuncName(func), 42674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyEval_GetFuncDesc(func), 42684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm kwdict->ob_type->tp_name); 42694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 42704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto ext_call_fail; 42714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 42724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(kwdict); 42734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm kwdict = d; 42744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 42754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 42764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (flags & CALL_FLAG_VAR) { 42774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm stararg = EXT_POP(*pp_stack); 42784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!PyTuple_Check(stararg)) { 42794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *t = NULL; 42804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm t = PySequence_Tuple(stararg); 42814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (t == NULL) { 42824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyErr_ExceptionMatches(PyExc_TypeError)) { 42834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Format(PyExc_TypeError, 42844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "%.200s%.200s argument after * " 42854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "must be a sequence, not %200s", 42864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyEval_GetFuncName(func), 42874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyEval_GetFuncDesc(func), 42884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm stararg->ob_type->tp_name); 42894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 42904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto ext_call_fail; 42914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 42924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(stararg); 42934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm stararg = t; 42944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 42954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm nstar = PyTuple_GET_SIZE(stararg); 42964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 42974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (nk > 0) { 42984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm kwdict = update_keyword_args(kwdict, nk, pp_stack, func); 42994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (kwdict == NULL) 43004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto ext_call_fail; 43014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 43024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm callargs = update_star_args(na, nstar, stararg, pp_stack); 43034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (callargs == NULL) 43044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto ext_call_fail; 43054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef CALL_PROFILE 43064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* At this point, we have to look at the type of func to 43074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm update the call stats properly. Do it here so as to avoid 43084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm exposing the call stats machinery outside ceval.c 43094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 43104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyFunction_Check(func)) 43114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PCALL(PCALL_FUNCTION); 43124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyMethod_Check(func)) 43134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PCALL(PCALL_METHOD); 43144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyType_Check(func)) 43154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PCALL(PCALL_TYPE); 43164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyCFunction_Check(func)) 43174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PCALL(PCALL_CFUNCTION); 43184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 43194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PCALL(PCALL_OTHER); 43204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 43214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyCFunction_Check(func)) { 43224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyThreadState *tstate = PyThreadState_GET(); 43234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm C_TRACE(result, PyCFunction_Call(func, callargs, kwdict)); 43244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 43254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 43264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = PyObject_Call(func, callargs, kwdict); 43274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmext_call_fail: 43284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(callargs); 43294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(kwdict); 43304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(stararg); 43314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return result; 43324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 43334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 43344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Extract a slice index from a PyInt or PyLong or an object with the 43354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm nb_index slot defined, and store in *pi. 43364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Silently reduce values larger than PY_SSIZE_T_MAX to PY_SSIZE_T_MAX, 43374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm and silently boost values less than -PY_SSIZE_T_MAX-1 to -PY_SSIZE_T_MAX-1. 43384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Return 0 on error, 1 on success. 43394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm*/ 43404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Note: If v is NULL, return success without storing into *pi. This 43414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm is because_PyEval_SliceIndex() is called by apply_slice(), which can be 43424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm called by the SLICE opcode with v and/or w equal to NULL. 43434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm*/ 43444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmint 43454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm_PyEval_SliceIndex(PyObject *v, Py_ssize_t *pi) 43464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 43474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (v != NULL) { 43484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t x; 43494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyInt_Check(v)) { 43504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* XXX(nnorwitz): I think PyInt_AS_LONG is correct, 43514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm however, it looks like it should be AsSsize_t. 43524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm There should be a comment here explaining why. 43534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 43544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyInt_AS_LONG(v); 43554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 43564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyIndex_Check(v)) { 43574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyNumber_AsSsize_t(v, NULL); 43584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x == -1 && PyErr_Occurred()) 43594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 43604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 43614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 43624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_TypeError, 43634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "slice indices must be integers or " 43644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "None or have an __index__ method"); 43654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 43664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 43674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *pi = x; 43684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 43694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 1; 43704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 43714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 43724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#undef ISINDEX 43734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define ISINDEX(x) ((x) == NULL || \ 43744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyInt_Check(x) || PyLong_Check(x) || PyIndex_Check(x)) 43754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 43764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 43774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmapply_slice(PyObject *u, PyObject *v, PyObject *w) /* return u[v:w] */ 43784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 43794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyTypeObject *tp = u->ob_type; 43804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PySequenceMethods *sq = tp->tp_as_sequence; 43814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 43824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (sq && sq->sq_slice && ISINDEX(v) && ISINDEX(w)) { 43834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t ilow = 0, ihigh = PY_SSIZE_T_MAX; 43844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!_PyEval_SliceIndex(v, &ilow)) 43854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 43864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!_PyEval_SliceIndex(w, &ihigh)) 43874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 43884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PySequence_GetSlice(u, ilow, ihigh); 43894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 43904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 43914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *slice = PySlice_New(v, w, NULL); 43924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (slice != NULL) { 43934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *res = PyObject_GetItem(u, slice); 43944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(slice); 43954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return res; 43964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 43974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 43984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 43994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 44004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 44014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 44024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int 44034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmassign_slice(PyObject *u, PyObject *v, PyObject *w, PyObject *x) 44044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* u[v:w] = x */ 44054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 44064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyTypeObject *tp = u->ob_type; 44074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PySequenceMethods *sq = tp->tp_as_sequence; 44084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 44094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (sq && sq->sq_ass_slice && ISINDEX(v) && ISINDEX(w)) { 44104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t ilow = 0, ihigh = PY_SSIZE_T_MAX; 44114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!_PyEval_SliceIndex(v, &ilow)) 44124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 44134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!_PyEval_SliceIndex(w, &ihigh)) 44144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 44154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x == NULL) 44164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PySequence_DelSlice(u, ilow, ihigh); 44174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 44184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PySequence_SetSlice(u, ilow, ihigh, x); 44194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 44204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 44214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *slice = PySlice_New(v, w, NULL); 44224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (slice != NULL) { 44234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int res; 44244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x != NULL) 44254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm res = PyObject_SetItem(u, slice, x); 44264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 44274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm res = PyObject_DelItem(u, slice); 44284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(slice); 44294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return res; 44304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 44314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 44324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 44334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 44344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 44354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 44364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define Py3kExceptionClass_Check(x) \ 44374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (PyType_Check((x)) && \ 44384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyType_FastSubclass((PyTypeObject*)(x), Py_TPFLAGS_BASE_EXC_SUBCLASS)) 44394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 44404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define CANNOT_CATCH_MSG "catching classes that don't inherit from " \ 44414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "BaseException is not allowed in 3.x" 44424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 44434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 44444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmcmp_outcome(int op, register PyObject *v, register PyObject *w) 44454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 44464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int res = 0; 44474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm switch (op) { 44484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case PyCmp_IS: 44494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm res = (v == w); 44504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 44514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case PyCmp_IS_NOT: 44524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm res = (v != w); 44534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 44544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case PyCmp_IN: 44554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm res = PySequence_Contains(w, v); 44564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (res < 0) 44574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 44584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 44594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case PyCmp_NOT_IN: 44604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm res = PySequence_Contains(w, v); 44614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (res < 0) 44624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 44634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm res = !res; 44644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 44654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case PyCmp_EXC_MATCH: 44664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyTuple_Check(w)) { 44674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t i, length; 44684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm length = PyTuple_Size(w); 44694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 0; i < length; i += 1) { 44704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *exc = PyTuple_GET_ITEM(w, i); 44714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyString_Check(exc)) { 44724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int ret_val; 44734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ret_val = PyErr_WarnEx( 44744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyExc_DeprecationWarning, 44754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "catching of string " 44764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "exceptions is deprecated", 1); 44774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (ret_val < 0) 44784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 44794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 44804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (Py_Py3kWarningFlag && 44814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm !PyTuple_Check(exc) && 44824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm !Py3kExceptionClass_Check(exc)) 44834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm { 44844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int ret_val; 44854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ret_val = PyErr_WarnEx( 44864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyExc_DeprecationWarning, 44874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm CANNOT_CATCH_MSG, 1); 44884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (ret_val < 0) 44894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 44904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 44914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 44924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 44934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 44944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyString_Check(w)) { 44954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int ret_val; 44964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ret_val = PyErr_WarnEx( 44974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyExc_DeprecationWarning, 44984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "catching of string " 44994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "exceptions is deprecated", 1); 45004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (ret_val < 0) 45014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 45024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 45034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (Py_Py3kWarningFlag && 45044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm !PyTuple_Check(w) && 45054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm !Py3kExceptionClass_Check(w)) 45064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm { 45074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int ret_val; 45084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ret_val = PyErr_WarnEx( 45094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyExc_DeprecationWarning, 45104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm CANNOT_CATCH_MSG, 1); 45114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (ret_val < 0) 45124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 45134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 45144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 45154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm res = PyErr_GivenExceptionMatches(v, w); 45164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 45174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm default: 45184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyObject_RichCompare(v, w, op); 45194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 45204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = res ? Py_True : Py_False; 45214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(v); 45224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return v; 45234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 45244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 45254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 45264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport_from(PyObject *v, PyObject *name) 45274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 45284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *x; 45294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 45304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyObject_GetAttr(v, name); 45314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x == NULL && PyErr_ExceptionMatches(PyExc_AttributeError)) { 45324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Format(PyExc_ImportError, 45334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "cannot import name %.230s", 45344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyString_AsString(name)); 45354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 45364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return x; 45374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 45384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 45394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int 45404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport_all_from(PyObject *locals, PyObject *v) 45414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 45424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *all = PyObject_GetAttrString(v, "__all__"); 45434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *dict, *name, *value; 45444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int skip_leading_underscores = 0; 45454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int pos, err; 45464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 45474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (all == NULL) { 45484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!PyErr_ExceptionMatches(PyExc_AttributeError)) 45494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; /* Unexpected error */ 45504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Clear(); 45514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm dict = PyObject_GetAttrString(v, "__dict__"); 45524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (dict == NULL) { 45534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!PyErr_ExceptionMatches(PyExc_AttributeError)) 45544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 45554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_ImportError, 45564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "from-import-* object has no __dict__ and no __all__"); 45574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 45584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 45594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm all = PyMapping_Keys(dict); 45604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(dict); 45614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (all == NULL) 45624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 45634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm skip_leading_underscores = 1; 45644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 45654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 45664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (pos = 0, err = 0; ; pos++) { 45674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm name = PySequence_GetItem(all, pos); 45684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (name == NULL) { 45694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!PyErr_ExceptionMatches(PyExc_IndexError)) 45704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = -1; 45714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 45724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Clear(); 45734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 45744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 45754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (skip_leading_underscores && 45764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyString_Check(name) && 45774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyString_AS_STRING(name)[0] == '_') 45784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm { 45794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(name); 45804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue; 45814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 45824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm value = PyObject_GetAttr(v, name); 45834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (value == NULL) 45844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = -1; 45854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyDict_CheckExact(locals)) 45864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = PyDict_SetItem(locals, name, value); 45874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 45884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm err = PyObject_SetItem(locals, name, value); 45894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(name); 45904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(value); 45914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (err != 0) 45924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 45934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 45944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(all); 45954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return err; 45964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 45974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 45984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 45994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmbuild_class(PyObject *methods, PyObject *bases, PyObject *name) 46004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 46014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *metaclass = NULL, *result, *base; 46024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 46034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyDict_Check(methods)) 46044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm metaclass = PyDict_GetItemString(methods, "__metaclass__"); 46054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (metaclass != NULL) 46064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(metaclass); 46074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyTuple_Check(bases) && PyTuple_GET_SIZE(bases) > 0) { 46084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm base = PyTuple_GET_ITEM(bases, 0); 46094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm metaclass = PyObject_GetAttrString(base, "__class__"); 46104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (metaclass == NULL) { 46114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Clear(); 46124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm metaclass = (PyObject *)base->ob_type; 46134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(metaclass); 46144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 46154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 46164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 46174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *g = PyEval_GetGlobals(); 46184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (g != NULL && PyDict_Check(g)) 46194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm metaclass = PyDict_GetItemString(g, "__metaclass__"); 46204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (metaclass == NULL) 46214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm metaclass = (PyObject *) &PyClass_Type; 46224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(metaclass); 46234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 46244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = PyObject_CallFunctionObjArgs(metaclass, name, bases, methods, 46254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm NULL); 46264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(metaclass); 46274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (result == NULL && PyErr_ExceptionMatches(PyExc_TypeError)) { 46284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* A type error here likely means that the user passed 46294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm in a base that was not a class (such the random module 46304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm instead of the random.random type). Help them out with 46314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm by augmenting the error message with more information.*/ 46324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 46334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *ptype, *pvalue, *ptraceback; 46344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 46354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Fetch(&ptype, &pvalue, &ptraceback); 46364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyString_Check(pvalue)) { 46374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *newmsg; 46384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm newmsg = PyString_FromFormat( 46394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "Error when calling the metaclass bases\n" 46404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm " %s", 46414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyString_AS_STRING(pvalue)); 46424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (newmsg != NULL) { 46434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(pvalue); 46444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pvalue = newmsg; 46454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 46464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 46474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Restore(ptype, pvalue, ptraceback); 46484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 46494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return result; 46504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 46514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 46524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int 46534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmexec_statement(PyFrameObject *f, PyObject *prog, PyObject *globals, 46544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *locals) 46554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 46564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int n; 46574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *v; 46584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int plain = 0; 46594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 46604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyTuple_Check(prog) && globals == Py_None && locals == Py_None && 46614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ((n = PyTuple_Size(prog)) == 2 || n == 3)) { 46624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Backward compatibility hack */ 46634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm globals = PyTuple_GetItem(prog, 1); 46644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (n == 3) 46654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm locals = PyTuple_GetItem(prog, 2); 46664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm prog = PyTuple_GetItem(prog, 0); 46674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 46684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (globals == Py_None) { 46694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm globals = PyEval_GetGlobals(); 46704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (locals == Py_None) { 46714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm locals = PyEval_GetLocals(); 46724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm plain = 1; 46734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 46744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!globals || !locals) { 46754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_SystemError, 46764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "globals and locals cannot be NULL"); 46774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 46784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 46794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 46804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (locals == Py_None) 46814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm locals = globals; 46824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!PyString_Check(prog) && 46834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef Py_USING_UNICODE 46844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm !PyUnicode_Check(prog) && 46854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 46864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm !PyCode_Check(prog) && 46874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm !PyFile_Check(prog)) { 46884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_TypeError, 46894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "exec: arg 1 must be a string, file, or code object"); 46904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 46914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 46924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!PyDict_Check(globals)) { 46934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_TypeError, 46944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "exec: arg 2 must be a dictionary or None"); 46954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 46964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 46974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!PyMapping_Check(locals)) { 46984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_TypeError, 46994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "exec: arg 3 must be a mapping or None"); 47004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 47014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 47024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyDict_GetItemString(globals, "__builtins__") == NULL) 47034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyDict_SetItemString(globals, "__builtins__", f->f_builtins); 47044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyCode_Check(prog)) { 47054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyCode_GetNumFree((PyCodeObject *)prog) > 0) { 47064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_TypeError, 47074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "code object passed to exec may not contain free variables"); 47084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 47094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 47104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = PyEval_EvalCode((PyCodeObject *) prog, globals, locals); 47114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 47124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyFile_Check(prog)) { 47134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FILE *fp = PyFile_AsFile(prog); 47144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char *name = PyString_AsString(PyFile_Name(prog)); 47154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyCompilerFlags cf; 47164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (name == NULL) 47174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 47184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm cf.cf_flags = 0; 47194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyEval_MergeCompilerFlags(&cf)) 47204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = PyRun_FileFlags(fp, name, Py_file_input, globals, 47214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm locals, &cf); 47224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 47234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = PyRun_File(fp, name, Py_file_input, globals, 47244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm locals); 47254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 47264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 47274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *tmp = NULL; 47284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char *str; 47294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyCompilerFlags cf; 47304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm cf.cf_flags = 0; 47314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef Py_USING_UNICODE 47324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyUnicode_Check(prog)) { 47334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tmp = PyUnicode_AsUTF8String(prog); 47344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (tmp == NULL) 47354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 47364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm prog = tmp; 47374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm cf.cf_flags |= PyCF_SOURCE_IS_UTF8; 47384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 47394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 47404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyString_AsStringAndSize(prog, &str, NULL)) 47414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 47424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyEval_MergeCompilerFlags(&cf)) 47434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = PyRun_StringFlags(str, Py_file_input, globals, 47444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm locals, &cf); 47454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 47464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = PyRun_String(str, Py_file_input, globals, locals); 47474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(tmp); 47484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 47494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (plain) 47504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFrame_LocalsToFast(f, 0); 47514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (v == NULL) 47524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 47534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 47544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 47554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 47564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 47574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic void 47584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmformat_exc_check_arg(PyObject *exc, char *format_str, PyObject *obj) 47594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 47604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char *obj_str; 47614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 47624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!obj) 47634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return; 47644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 47654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm obj_str = PyString_AsString(obj); 47664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!obj_str) 47674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return; 47684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 47694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Format(exc, format_str, obj_str); 47704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 47714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 47724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 47734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstring_concatenate(PyObject *v, PyObject *w, 47744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyFrameObject *f, unsigned char *next_instr) 47754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 47764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* This function implements 'variable += expr' when both arguments 47774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm are strings. */ 47784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t v_len = PyString_GET_SIZE(v); 47794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t w_len = PyString_GET_SIZE(w); 47804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t new_len = v_len + w_len; 47814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (new_len < 0) { 47824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_OverflowError, 47834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "strings are too large to concat"); 47844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 47854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 47864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 47874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (v->ob_refcnt == 2) { 47884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* In the common case, there are 2 references to the value 47894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * stored in 'variable' when the += is performed: one on the 47904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * value stack (in 'v') and one still stored in the 47914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * 'variable'. We try to delete the variable now to reduce 47924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * the refcnt to 1. 47934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 47944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm switch (*next_instr) { 47954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case STORE_FAST: 47964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm { 47974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int oparg = PEEKARG(); 47984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject **fastlocals = f->f_localsplus; 47994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (GETLOCAL(oparg) == v) 48004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SETLOCAL(oparg, NULL); 48014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 48024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 48034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case STORE_DEREF: 48044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm { 48054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject **freevars = (f->f_localsplus + 48064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f->f_code->co_nlocals); 48074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *c = freevars[PEEKARG()]; 48084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyCell_GET(c) == v) 48094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyCell_Set(c, NULL); 48104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 48114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 48124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case STORE_NAME: 48134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm { 48144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *names = f->f_code->co_names; 48154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *name = GETITEM(names, PEEKARG()); 48164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *locals = f->f_locals; 48174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyDict_CheckExact(locals) && 48184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyDict_GetItem(locals, name) == v) { 48194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyDict_DelItem(locals, name) != 0) { 48204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Clear(); 48214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 48224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 48234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 48244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 48254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 48264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 48274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 48284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (v->ob_refcnt == 1 && !PyString_CHECK_INTERNED(v)) { 48294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Now we own the last reference to 'v', so we can resize it 48304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * in-place. 48314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 48324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (_PyString_Resize(&v, new_len) != 0) { 48334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* XXX if _PyString_Resize() fails, 'v' has been 48344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * deallocated so it cannot be put back into 48354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * 'variable'. The MemoryError is raised when there 48364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * is no value in 'variable', which might (very 48374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * remotely) be a cause of incompatibilities. 48384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 48394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 48404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 48414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* copy 'w' into the newly allocated area of 'v' */ 48424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm memcpy(PyString_AS_STRING(v) + v_len, 48434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyString_AS_STRING(w), w_len); 48444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return v; 48454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 48464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 48474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* When in-place resizing is not an option. */ 48484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyString_Concat(&v, w); 48494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return v; 48504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 48514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 48524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 48534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef DYNAMIC_EXECUTION_PROFILE 48544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 48554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 48564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmgetarray(long a[256]) 48574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 48584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int i; 48594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *l = PyList_New(256); 48604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (l == NULL) return NULL; 48614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 0; i < 256; i++) { 48624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *x = PyInt_FromLong(a[i]); 48634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x == NULL) { 48644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(l); 48654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 48664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 48674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyList_SetItem(l, i, x); 48684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 48694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 0; i < 256; i++) 48704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a[i] = 0; 48714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return l; 48724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 48734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 48744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyObject * 48754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm_Py_GetDXProfile(PyObject *self, PyObject *args) 48764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 48774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifndef DXPAIRS 48784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return getarray(dxp); 48794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#else 48804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int i; 48814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *l = PyList_New(257); 48824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (l == NULL) return NULL; 48834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 0; i < 257; i++) { 48844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *x = getarray(dxpairs[i]); 48854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x == NULL) { 48864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(l); 48874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 48884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 48894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyList_SetItem(l, i, x); 48904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 48914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return l; 48924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 48934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 48944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 48954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 4896