#include "compile.h"

#ifdef macintosh

#include "macglue.h"

#include <ctype.h>

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

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

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

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

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

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

#define CALL_FLAG_VAR 1

#define CALL_FLAG_KW 2

static int call_trace(Py_tracefunc, PyObject *, PyFrameObject *,

int, PyObject *);

static void call_trace_protected(Py_tracefunc, PyObject *,

PyFrameObject *, int);

PyFrameObject *, int *, int *);

static PyObject *apply_slice(PyObject *, PyObject *, PyObject *);

static int assign_slice(PyObject *, PyObject *,

PyObject *, PyObject *);

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

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

static int import_all_from(PyObject *, PyObject *);

static PyObject *build_class(PyObject *, PyObject *, PyObject *);

static int exec_statement(PyFrameObject *,

PyObject *, PyObject *, PyObject *);

static void set_exc_info(PyThreadState *, PyObject *, PyObject *, PyObject *);

static void reset_exc_info(PyThreadState *);

#define GLOBAL_NAME_ERROR_MSG \

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

#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 CALL_PROFILE

#define PCALL_NUM 11

static int pcall[PCALL_NUM];

#define PCALL_ALL 0

#define PCALL_FUNCTION 1

#define PCALL_FAST_FUNCTION 2

#define PCALL_FASTER_FUNCTION 3

#define PCALL_METHOD 4

#define PCALL_BOUND_METHOD 5

#define PCALL_CFUNCTION 6

#define PCALL_TYPE 7

#define PCALL_GENERATOR 8

#define PCALL_OTHER 9

#define PCALL_POP 10

#define PCALL(POS) pcall[POS]++

PyObject *

PyEval_GetCallStats(PyObject *self)

{

return Py_BuildValue("iiiiiiiiii",

pcall[0], pcall[1], pcall[2], pcall[3],

pcall[4], pcall[5], pcall[6], pcall[7],

pcall[8], pcall[9]);

}

#define PCALL(O)

PyObject *

PyEval_GetCallStats(PyObject *self)

{

Py_INCREF(Py_None);

return Py_None;

}

typedef struct {

PyObject_HEAD

/* The gi_ prefix is intended to remind of generator-iterator. */

PyFrameObject *gi_frame;

/* True if generator is being executed. */

int gi_running;

/* List of weak reference. */

PyObject *gi_weakreflist;

} genobject;

static PyObject *

gen_new(PyFrameObject *f)

{

if (gen == NULL) {

Py_DECREF(f);

return NULL;

}

gen->gi_frame = f;

gen->gi_running = 0;

return (PyObject *)gen;

}

static int

gen_traverse(genobject *gen, visitproc visit, void *arg)

{

return visit((PyObject *)gen->gi_frame, arg);

}

static void

gen_dealloc(genobject *gen)

{

if (gen->gi_weakreflist != NULL)

PyObject_ClearWeakRefs((PyObject *) gen);

}

static PyObject *

gen_iternext(genobject *gen)

{

PyObject *result;

PyErr_SetString(PyExc_ValueError,

"generator already executing");

return NULL;

}

/* Generators always return to their most recent caller, not

assert(f->f_back == NULL);

f->f_back = tstate->frame;

/* Don't keep the reference to f_back any longer than necessary. It

/* If the generator just returned (as opposed to yielding), signal

if (result == Py_None && f->f_stacktop == NULL) {

Py_DECREF(result);

result = NULL;

}

}

static PyObject *

gen_getiter(PyObject *gen)

{

Py_INCREF(gen);

return gen;

}

{"gi_frame", T_OBJECT, offsetof(genobject, gi_frame), RO},

{"gi_running", T_INT, offsetof(genobject, gi_running), RO},

{NULL} /* Sentinel */

};

PyObject_HEAD_INIT(&PyType_Type)

0, /* ob_size */

"generator", /* tp_name */

0, /* tp_itemsize */

/* methods */

(destructor)gen_dealloc, /* tp_dealloc */

0, /* tp_print */

0, /* tp_setattr */

0, /* tp_compare */

0, /* tp_repr */

0, /* tp_as_number */

0, /* tp_as_sequence */

0, /* tp_as_mapping */

0, /* tp_hash */

0, /* tp_call */

0, /* tp_str */

0, /* tp_setattro */

0, /* tp_as_buffer */

0, /* tp_clear */

0, /* tp_richcompare */

(getiterfunc)gen_getiter, /* tp_iter */

(iternextfunc)gen_iternext, /* tp_iternext */

gen_memberlist, /* tp_members */

0, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

};

extern int _PyThread_Started; /* Flag for Py_Exit */

{

if (interpreter_lock)

interpreter_lock = PyThread_allocate_lock();

PyThread_acquire_lock(interpreter_lock, 1);

main_thread = PyThread_get_thread_ident();

}

}

{

if (tstate == NULL)

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

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

assert(interpreter_lock);

if (PyThreadState_Swap(tstate) != NULL)

Py_FatalError(

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

}

{

if (tstate == NULL)

Py_FatalError("PyEval_ReleaseThread: NULL thread state");

if (PyThreadState_Swap(NULL) != tstate)

Py_FatalError("PyEval_ReleaseThread: wrong thread state");

PyEval_ReInitThreads(void)

{

if (!interpreter_lock)

return;

/*XXX Can't use PyThread_free_lock here because it does too

interpreter_lock = PyThread_allocate_lock();

PyThread_acquire_lock(interpreter_lock, 1);

main_thread = PyThread_get_thread_ident();

}

PyThreadState *tstate = PyThreadState_Swap(NULL);

if (tstate == NULL)

Py_FatalError("PyEval_SaveThread: NULL tstate");

}

if (tstate == NULL)

Py_FatalError("PyEval_RestoreThread: NULL tstate");

errno = err;

}

}

#define NPENDINGCALLS 32

static struct {