#define PY_LOCAL_AGGRESSIVE

#include "Python.h"

#include "code.h"

#include "dictobject.h"

#include "frameobject.h"

#include "opcode.h"

#include "pydtrace.h"

#include "setobject.h"

#include "structmember.h"

#include <ctype.h>

#ifdef Py_DEBUG

#define LLTRACE 1 /* Low-level trace feature */

#define CHECKEXC 1 /* Double-check exception checking */

extern int _PyObject_GetMethod(PyObject *, PyObject *, PyObject **);

typedef PyObject *(*callproc)(PyObject *, PyObject *, PyObject *);

Py_LOCAL_INLINE(PyObject *) call_function(PyObject ***, Py_ssize_t, PyObject *);

static PyObject * do_call_core(PyObject *, PyObject *, PyObject *);

#ifdef LLTRACE

static int lltrace;

static int prtrace(PyObject *, const char *);

static int call_trace(Py_tracefunc, PyObject *,

PyThreadState *, PyFrameObject *,

int, PyObject *);

static int call_trace_protected(Py_tracefunc, PyObject *,

PyThreadState *, PyFrameObject *,

int, PyObject *);

static void call_exc_trace(Py_tracefunc, PyObject *,

PyThreadState *, PyFrameObject *);

static int maybe_call_line_trace(Py_tracefunc, PyObject *,

PyThreadState *, PyFrameObject *, int *, int *, int *);

static void maybe_dtrace_line(PyFrameObject *, int *, int *, int *);

static void dtrace_function_entry(PyFrameObject *);

static void dtrace_function_return(PyFrameObject *);

static PyObject * cmp_outcome(int, PyObject *, PyObject *);

static PyObject * import_name(PyFrameObject *, PyObject *, PyObject *, PyObject *);

static PyObject * import_from(PyObject *, PyObject *);

static int import_all_from(PyObject *, PyObject *);

static void format_exc_check_arg(PyObject *, const char *, PyObject *);

static void format_exc_unbound(PyCodeObject *co, int oparg);

static PyObject * unicode_concatenate(PyObject *, PyObject *,

PyFrameObject *, const _Py_CODEUNIT *);

static PyObject * special_lookup(PyObject *, _Py_Identifier *);

#define NAME_ERROR_MSG \

"name '%.200s' is not defined"

#define UNBOUNDLOCAL_ERROR_MSG \

"local variable '%.200s' referenced before assignment"

#define UNBOUNDFREE_ERROR_MSG \

"free variable '%.200s' referenced before assignment" \

" in enclosing scope"

#ifdef DYNAMIC_EXECUTION_PROFILE

#ifdef DXPAIRS

static long dxpairs[257][256];

#define dxp dxpairs[256]

static long dxp[256];

#ifdef WITH_THREAD

#define GIL_REQUEST _Py_atomic_load_relaxed(&gil_drop_request)

#define GIL_REQUEST 0

#define COMPUTE_EVAL_BREAKER() \

_Py_atomic_store_relaxed( \

&eval_breaker, \

GIL_REQUEST | \

_Py_atomic_load_relaxed(&pendingcalls_to_do) | \

pending_async_exc)

#ifdef WITH_THREAD

#define SET_GIL_DROP_REQUEST() \

do { \

_Py_atomic_store_relaxed(&gil_drop_request, 1); \

_Py_atomic_store_relaxed(&eval_breaker, 1); \

} while (0)

#define RESET_GIL_DROP_REQUEST() \

do { \

_Py_atomic_store_relaxed(&gil_drop_request, 0); \

COMPUTE_EVAL_BREAKER(); \

} while (0)

#define SIGNAL_PENDING_CALLS() \

do { \

_Py_atomic_store_relaxed(&pendingcalls_to_do, 1); \

_Py_atomic_store_relaxed(&eval_breaker, 1); \

} while (0)

#define UNSIGNAL_PENDING_CALLS() \

do { \

_Py_atomic_store_relaxed(&pendingcalls_to_do, 0); \

COMPUTE_EVAL_BREAKER(); \

} while (0)

#define SIGNAL_ASYNC_EXC() \

do { \

pending_async_exc = 1; \

_Py_atomic_store_relaxed(&eval_breaker, 1); \

} while (0)

#define UNSIGNAL_ASYNC_EXC() \

do { pending_async_exc = 0; COMPUTE_EVAL_BREAKER(); } while (0)

#ifdef WITH_THREAD

#ifdef HAVE_ERRNO_H

#include <errno.h>

#include "pythread.h"

static PyThread_type_lock pending_lock = 0; /* for pending calls */

static unsigned long main_thread = 0;

static _Py_atomic_int eval_breaker = {0};

static _Py_atomic_int gil_drop_request = {0};

static _Py_atomic_int pendingcalls_to_do = {0};

static int pending_async_exc = 0;

#include "ceval_gil.h"

PyEval_ThreadsInitialized(void)

{

return gil_created();

}

PyEval_InitThreads(void)

{

if (gil_created())

return;

create_gil();

take_gil(PyThreadState_GET());

main_thread = PyThread_get_thread_ident();

if (!pending_lock)

pending_lock = PyThread_allocate_lock();

}

_PyEval_FiniThreads(void)

{

if (!gil_created())

return;

destroy_gil();

assert(!gil_created());

}

PyEval_AcquireLock(void)

{

PyThreadState *tstate = PyThreadState_GET();

if (tstate == NULL)

Py_FatalError("PyEval_AcquireLock: current thread state is NULL");

take_gil(tstate);

}

PyEval_ReleaseLock(void)

{

/* This function must succeed when the current thread state is NULL.

drop_gil((PyThreadState*)_Py_atomic_load_relaxed(

&_PyThreadState_Current));

}

PyEval_AcquireThread(PyThreadState *tstate)

{

if (tstate == NULL)

Py_FatalError("PyEval_AcquireThread: NULL new thread state");

/* Check someone has called PyEval_InitThreads() to create the lock */

assert(gil_created());

take_gil(tstate);

if (PyThreadState_Swap(tstate) != NULL)

Py_FatalError(

"PyEval_AcquireThread: non-NULL old thread state");

}

PyEval_ReleaseThread(PyThreadState *tstate)

{

if (tstate == NULL)

Py_FatalError("PyEval_ReleaseThread: NULL thread state");

if (PyThreadState_Swap(NULL) != tstate)

Py_FatalError("PyEval_ReleaseThread: wrong thread state");

drop_gil(tstate);

}

PyEval_ReInitThreads(void)

{

_Py_IDENTIFIER(_after_fork);

PyObject *threading, *result;

PyThreadState *current_tstate = PyThreadState_GET();

if (!gil_created())

return;

recreate_gil();

pending_lock = PyThread_allocate_lock();

take_gil(current_tstate);

main_thread = PyThread_get_thread_ident();

/* Update the threading module with the new state.

threading = PyMapping_GetItemString(current_tstate->interp->modules,

"threading");

if (threading == NULL) {

/* threading not imported */

PyErr_Clear();

return;

}

result = _PyObject_CallMethodId(threading, &PyId__after_fork, NULL);

if (result == NULL)

PyErr_WriteUnraisable(threading);

else

Py_DECREF(result);

Py_DECREF(threading);

/* Destroy all threads except the current one */

_PyThreadState_DeleteExcept(current_tstate);

}

static _Py_atomic_int eval_breaker = {0};

static int pending_async_exc = 0;

#endif /* WITH_THREAD */

_PyEval_SignalAsyncExc(void)

{

SIGNAL_ASYNC_EXC();

}

PyThreadState *

PyEval_SaveThread(void)

{

PyThreadState *tstate = PyThreadState_Swap(NULL);

if (tstate == NULL)

Py_FatalError("PyEval_SaveThread: NULL tstate");

#ifdef WITH_THREAD

if (gil_created())

drop_gil(tstate);

return tstate;

}

PyEval_RestoreThread(PyThreadState *tstate)

{

if (tstate == NULL)

Py_FatalError("PyEval_RestoreThread: NULL tstate");

#ifdef WITH_THREAD

if (gil_created()) {

int err = errno;

take_gil(tstate);

/* _Py_Finalizing is protected by the GIL */

if (_Py_Finalizing && tstate != _Py_Finalizing) {

drop_gil(tstate);

PyThread_exit_thread();

assert(0); /* unreachable */

}

errno = err;

}

PyThreadState_Swap(tstate);

}

#ifdef WITH_THREAD

#define NPENDINGCALLS 32

static struct {

int (*func)(void *);

void *arg;

} pendingcalls[NPENDINGCALLS];

static int pendingfirst = 0;

static int pendinglast = 0;

Py_AddPendingCall(int (*func)(void *), void *arg)

{

int i, j, result=0;

PyThread_type_lock lock = pending_lock;

/* try a few times for the lock. Since this mechanism is used

if (lock != NULL) {

for (i = 0; i<100; i++) {

if (PyThread_acquire_lock(lock, NOWAIT_LOCK))

break;

}

if (i == 100)

return -1;

}

i = pendinglast;

j = (i + 1) % NPENDINGCALLS;

if (j == pendingfirst) {

result = -1; /* Queue full */

} else {

pendingcalls[i].func = func;

pendingcalls[i].arg = arg;

pendinglast = j;

}

/* signal main loop */

SIGNAL_PENDING_CALLS();

if (lock != NULL)

PyThread_release_lock(lock);

return result;

}

Py_MakePendingCalls(void)

{

static int busy = 0;

int i;

int r = 0;

if (!pending_lock) {

/* initial allocation of the lock */

pending_lock = PyThread_allocate_lock();

if (pending_lock == NULL)

return -1;

}

/* only service pending calls on main thread */

if (main_thread && PyThread_get_thread_ident() != main_thread)

return 0;

/* don't perform recursive pending calls */

if (busy)

return 0;

busy = 1;

/* perform a bounded number of calls, in case of recursion */

for (i=0; i<NPENDINGCALLS; i++) {

int j;

int (*func)(void *);

void *arg = NULL;

/* pop one item off the queue while holding the lock */

PyThread_acquire_lock(pending_lock, WAIT_LOCK);

j = pendingfirst;

if (j == pendinglast) {

func = NULL; /* Queue empty */

} else {

func = pendingcalls[j].func;

arg = pendingcalls[j].arg;

pendingfirst = (j + 1) % NPENDINGCALLS;

}

if (pendingfirst != pendinglast)

SIGNAL_PENDING_CALLS();

else

UNSIGNAL_PENDING_CALLS();

PyThread_release_lock(pending_lock);

/* having released the lock, perform the callback */

if (func == NULL)

break;

r = func(arg);

if (r)

break;

}

busy = 0;

return r;

}

#else /* if ! defined WITH_THREAD */

#define NPENDINGCALLS 32

static struct {

int (*func)(void *);

void *arg;

} pendingcalls[NPENDINGCALLS];

static volatile int pendingfirst = 0;

static volatile int pendinglast = 0;

static _Py_atomic_int pendingcalls_to_do = {0};

Py_AddPendingCall(int (*func)(void *), void *arg)

{

static volatile int busy = 0;

int i, j;

/* XXX Begin critical section */

if (busy)

return -1;

busy = 1;

i = pendinglast;

j = (i + 1) % NPENDINGCALLS;

if (j == pendingfirst) {

busy = 0;

return -1; /* Queue full */

}

pendingcalls[i].func = func;

pendingcalls[i].arg = arg;

pendinglast = j;

SIGNAL_PENDING_CALLS();

busy = 0;

/* XXX End critical section */

return 0;

}

Py_MakePendingCalls(void)

{

static int busy = 0;

if (busy)

return 0;

busy = 1;

UNSIGNAL_PENDING_CALLS();

for (;;) {

int i;

int (*func)(void *);

void *arg;

i = pendingfirst;

if (i == pendinglast)

break; /* Queue empty */

func = pendingcalls[i].func;

arg = pendingcalls[i].arg;

pendingfirst = (i + 1) % NPENDINGCALLS;

if (func(arg) < 0) {

busy = 0;

SIGNAL_PENDING_CALLS(); /* We're not done yet */

return -1;

}

}

busy = 0;

return 0;

}

#endif /* WITH_THREAD */

#ifndef Py_DEFAULT_RECURSION_LIMIT

#define Py_DEFAULT_RECURSION_LIMIT 1000

static int recursion_limit = Py_DEFAULT_RECURSION_LIMIT;

int _Py_CheckRecursionLimit = Py_DEFAULT_RECURSION_LIMIT;

Py_GetRecursionLimit(void)

{

return recursion_limit;

}

Py_SetRecursionLimit(int new_limit)

{

recursion_limit = new_limit;

_Py_CheckRecursionLimit = recursion_limit;

}

_Py_CheckRecursiveCall(const char *where)

{

PyThreadState *tstate = PyThreadState_GET();

#ifdef USE_STACKCHECK

if (PyOS_CheckStack()) {

--tstate->recursion_depth;

PyErr_SetString(PyExc_MemoryError, "Stack overflow");

return -1;

}

_Py_CheckRecursionLimit = recursion_limit;

if (tstate->recursion_critical)

/* Somebody asked that we don't check for recursion. */

return 0;

if (tstate->overflowed) {

if (tstate->recursion_depth > recursion_limit + 50) {

/* Overflowing while handling an overflow. Give up. */

Py_FatalError("Cannot recover from stack overflow.");

}

return 0;

}

if (tstate->recursion_depth > recursion_limit) {

--tstate->recursion_depth;

tstate->overflowed = 1;

PyErr_Format(PyExc_RecursionError,

"maximum recursion depth exceeded%s",

where);

return -1;

}

return 0;

}

enum why_code {

};

static void save_exc_state(PyThreadState *, PyFrameObject *);

static void swap_exc_state(PyThreadState *, PyFrameObject *);

static void restore_and_clear_exc_state(PyThreadState *, PyFrameObject *);

static int do_raise(PyObject *, PyObject *);

static int unpack_iterable(PyObject *, int, int, PyObject **);

static int _Py_TracingPossible = 0;

PyObject *

PyEval_EvalCode(PyObject *co, PyObject *globals, PyObject *locals)

{

return PyEval_EvalCodeEx(co,

globals, locals,

(PyObject **)NULL, 0,

(PyObject **)NULL, 0,

(PyObject **)NULL, 0,

NULL, NULL);

}

PyObject *

PyEval_EvalFrame(PyFrameObject *f) {

/* This is for backward compatibility with extension modules that

return PyEval_EvalFrameEx(f, 0);

}

PyObject *

PyEval_EvalFrameEx(PyFrameObject *f, int throwflag)

{

PyThreadState *tstate = PyThreadState_GET();

return tstate->interp->eval_frame(f, throwflag);

}

PyObject* _Py_HOT_FUNCTION

_PyEval_EvalFrameDefault(PyFrameObject *f, int throwflag)

{

#ifdef DXPAIRS

int lastopcode = 0;

PyObject **stack_pointer; /* Next free slot in value stack */

const _Py_CODEUNIT *next_instr;

int opcode; /* Current opcode */

int oparg; /* Current opcode argument, if any */

enum why_code why; /* Reason for block stack unwind */

PyObject **fastlocals, **freevars;

PyObject *retval = NULL; /* Return value */

PyThreadState *tstate = PyThreadState_GET();

PyCodeObject *co;

/* when tracing we set things up so that

int instr_ub = -1, instr_lb = 0, instr_prev = -1;

const _Py_CODEUNIT *first_instr;

PyObject *names;

PyObject *consts;

#ifdef LLTRACE

_Py_IDENTIFIER(__ltrace__);

#ifdef DYNAMIC_EXECUTION_PROFILE

#undef USE_COMPUTED_GOTOS

#define USE_COMPUTED_GOTOS 0

#ifdef HAVE_COMPUTED_GOTOS

#ifndef USE_COMPUTED_GOTOS

#define USE_COMPUTED_GOTOS 1

#endif

#if defined(USE_COMPUTED_GOTOS) && USE_COMPUTED_GOTOS

#error "Computed gotos are not supported on this compiler."

#endif

#undef USE_COMPUTED_GOTOS

#define USE_COMPUTED_GOTOS 0

#if USE_COMPUTED_GOTOS

#include "opcode_targets.h"

#define TARGET(op) \

TARGET_##op: \

case op:

#define DISPATCH() \

{ \

if (!_Py_atomic_load_relaxed(&eval_breaker)) { \

FAST_DISPATCH(); \

} \

continue; \

}

#ifdef LLTRACE

#define FAST_DISPATCH() \

{ \

if (!lltrace && !_Py_TracingPossible && !PyDTrace_LINE_ENABLED()) { \

f->f_lasti = INSTR_OFFSET(); \

NEXTOPARG(); \

goto *opcode_targets[opcode]; \

} \

goto fast_next_opcode; \

}

#define FAST_DISPATCH() \

{ \

if (!_Py_TracingPossible && !PyDTrace_LINE_ENABLED()) { \

f->f_lasti = INSTR_OFFSET(); \

NEXTOPARG(); \

goto *opcode_targets[opcode]; \

} \

goto fast_next_opcode; \

}

#define TARGET(op) \

case op:

#define DISPATCH() continue

#define FAST_DISPATCH() goto fast_next_opcode

#ifndef Py_DEBUG

#define GETITEM(v, i) PyTuple_GET_ITEM((PyTupleObject *)(v), (i))

#define GETITEM(v, i) PyTuple_GetItem((v), (i))

#define INSTR_OFFSET() (sizeof(_Py_CODEUNIT) * (int)(next_instr - first_instr))

#define NEXTOPARG() do { \

_Py_CODEUNIT word = *next_instr; \

opcode = _Py_OPCODE(word); \

oparg = _Py_OPARG(word); \

next_instr++; \

} while (0)

#define JUMPTO(x) (next_instr = first_instr + (x) / sizeof(_Py_CODEUNIT))

#define JUMPBY(x) (next_instr += (x) / sizeof(_Py_CODEUNIT))

#if defined(DYNAMIC_EXECUTION_PROFILE) || USE_COMPUTED_GOTOS

#define PREDICT(op) if (0) goto PRED_##op

#define PREDICT(op) \

do{ \

_Py_CODEUNIT word = *next_instr; \

opcode = _Py_OPCODE(word); \

if (opcode == op){ \

oparg = _Py_OPARG(word); \

next_instr++; \

goto PRED_##op; \

} \

} while(0)

#define PREDICTED(op) PRED_##op:

#define STACK_LEVEL() ((int)(stack_pointer - f->f_valuestack))

#define EMPTY() (STACK_LEVEL() == 0)

#define TOP() (stack_pointer[-1])

#define SECOND() (stack_pointer[-2])

#define THIRD() (stack_pointer[-3])

#define FOURTH() (stack_pointer[-4])

#define PEEK(n) (stack_pointer[-(n)])

#define SET_TOP(v) (stack_pointer[-1] = (v))

#define SET_SECOND(v) (stack_pointer[-2] = (v))

#define SET_THIRD(v) (stack_pointer[-3] = (v))

#define SET_FOURTH(v) (stack_pointer[-4] = (v))

#define SET_VALUE(n, v) (stack_pointer[-(n)] = (v))

#define BASIC_STACKADJ(n) (stack_pointer += n)

#define BASIC_PUSH(v) (*stack_pointer++ = (v))

#define BASIC_POP() (*--stack_pointer)

#ifdef LLTRACE

#define PUSH(v) { (void)(BASIC_PUSH(v), \

lltrace && prtrace(TOP(), "push")); \

assert(STACK_LEVEL() <= co->co_stacksize); }

#define POP() ((void)(lltrace && prtrace(TOP(), "pop")), \

BASIC_POP())

#define STACKADJ(n) { (void)(BASIC_STACKADJ(n), \

lltrace && prtrace(TOP(), "stackadj")); \

assert(STACK_LEVEL() <= co->co_stacksize); }

#define EXT_POP(STACK_POINTER) ((void)(lltrace && \

prtrace((STACK_POINTER)[-1], "ext_pop")), \

*--(STACK_POINTER))

#define PUSH(v) BASIC_PUSH(v)

#define POP() BASIC_POP()

#define STACKADJ(n) BASIC_STACKADJ(n)

#define EXT_POP(STACK_POINTER) (*--(STACK_POINTER))

#define GETLOCAL(i) (fastlocals[i])

#define SETLOCAL(i, value) do { PyObject *tmp = GETLOCAL(i); \

GETLOCAL(i) = value; \

Py_XDECREF(tmp); } while (0)

#define UNWIND_BLOCK(b) \

while (STACK_LEVEL() > (b)->b_level) { \

PyObject *v = POP(); \

Py_XDECREF(v); \

}

#define UNWIND_EXCEPT_HANDLER(b) \

do { \

PyObject *type, *value, *traceback; \

assert(STACK_LEVEL() >= (b)->b_level + 3); \

while (STACK_LEVEL() > (b)->b_level + 3) { \

value = POP(); \

Py_XDECREF(value); \

} \

type = tstate->exc_type; \

value = tstate->exc_value; \

traceback = tstate->exc_traceback; \

tstate->exc_type = POP(); \

tstate->exc_value = POP(); \

tstate->exc_traceback = POP(); \

Py_XDECREF(type); \

Py_XDECREF(value); \

Py_XDECREF(traceback); \

} while(0)

/* push frame */

if (Py_EnterRecursiveCall(""))

return NULL;

tstate->frame = f;

if (tstate->use_tracing) {

if (tstate->c_tracefunc != NULL) {

/* tstate->c_tracefunc, if defined, is a

if (call_trace_protected(tstate->c_tracefunc,

tstate->c_traceobj,

tstate, f, PyTrace_CALL, Py_None)) {

/* Trace function raised an error */

goto exit_eval_frame;

}

}

if (tstate->c_profilefunc != NULL) {

/* Similar for c_profilefunc, except it needn't

if (call_trace_protected(tstate->c_profilefunc,

tstate->c_profileobj,

tstate, f, PyTrace_CALL, Py_None)) {

/* Profile function raised an error */

goto exit_eval_frame;

}

}

}

if (PyDTrace_FUNCTION_ENTRY_ENABLED())

dtrace_function_entry(f);

co = f->f_code;

names = co->co_names;

consts = co->co_consts;

fastlocals = f->f_localsplus;

freevars = f->f_localsplus + co->co_nlocals;

assert(PyBytes_Check(co->co_code));

assert(PyBytes_GET_SIZE(co->co_code) <= INT_MAX);

assert(PyBytes_GET_SIZE(co->co_code) % sizeof(_Py_CODEUNIT) == 0);

assert(_Py_IS_ALIGNED(PyBytes_AS_STRING(co->co_code), sizeof(_Py_CODEUNIT)));

first_instr = (_Py_CODEUNIT *) PyBytes_AS_STRING(co->co_code);

/*