/* Execute compiled code */
/* XXX TO DO:
- XXX how to pass arguments to call_trace?
+ XXX how to pass arguments to profile and trace functions?
XXX speed up searching for keywords by using a dictionary
XXX document it!
*/
#ifdef LLTRACE
static int prtrace(PyObject *, char *);
#endif
-static void call_exc_trace(PyObject **, PyObject**, PyFrameObject *);
-static int call_trace(PyObject **, PyObject **,
- PyFrameObject *, PyObject *, PyObject *);
+static int call_trace(Py_tracefunc, PyObject *, PyFrameObject *,
+ int, PyObject *);
+static void call_exc_trace(Py_tracefunc, PyObject *, PyFrameObject *);
static PyObject *loop_subscript(PyObject *, PyObject *);
static PyObject *apply_slice(PyObject *, PyObject *, PyObject *);
static int assign_slice(PyObject *, PyObject *,
#endif
#endif
-/* Cached interned string objects used for calling the profile and
- * trace functions.
- */
-static PyObject *str_call = NULL;
-static PyObject *str_exception = NULL;
-static PyObject *str_line = NULL;
-static PyObject *str_return = NULL;
-
staticforward PyTypeObject gentype;
printf("--- %s:%d \n", filename, oparg);
#endif
f->f_lineno = oparg;
- if (f->f_trace == NULL)
+ if (tstate->c_tracefunc == NULL || tstate->tracing)
continue;
/* Trace each line of code reached */
f->f_lasti = INSTR_OFFSET();
- err = call_trace(&f->f_trace, &f->f_trace,
- f, str_line, Py_None);
+ /* Inline call_trace() for performance: */
+ tstate->tracing++;
+ err = (tstate->c_tracefunc)(tstate->c_traceobj, f,
+ PyTrace_LINE, Py_None);
+ tstate->tracing--;
break;
case CALL_FUNCTION:
f->f_lasti -= 2;
PyTraceBack_Here(f);
- if (f->f_trace)
- call_exc_trace(&f->f_trace, &f->f_trace, f);
- if (tstate->sys_profilefunc)
- call_exc_trace(&tstate->sys_profilefunc,
- (PyObject**)0, f);
+ if (tstate->c_tracefunc)
+ call_exc_trace(tstate->c_tracefunc,
+ tstate->c_traceobj, f);
+ if (tstate->c_profilefunc)
+ call_exc_trace(tstate->c_profilefunc,
+ tstate->c_profileobj, f);
}
/* For the rest, treat WHY_RERAISE as WHY_EXCEPTION */
if (why != WHY_RETURN && why != WHY_YIELD)
retval = NULL;
- if (f->f_trace) {
+ if (tstate->c_tracefunc && !tstate->tracing) {
if (why == WHY_RETURN || why == WHY_YIELD) {
- if (call_trace(&f->f_trace, &f->f_trace, f,
- str_return, retval)) {
+ if (call_trace(tstate->c_tracefunc, tstate->c_traceobj,
+ f, PyTrace_RETURN, retval)) {
Py_XDECREF(retval);
retval = NULL;
why = WHY_EXCEPTION;
}
}
- if (tstate->sys_profilefunc &&
- (why == WHY_RETURN || why == WHY_YIELD)) {
- if (call_trace(&tstate->sys_profilefunc, (PyObject**)0,
- f, str_return, retval)) {
+ if (tstate->c_profilefunc && !tstate->tracing
+ && (why == WHY_RETURN || why == WHY_YIELD)) {
+ if (call_trace(tstate->c_profilefunc, tstate->c_profileobj,
+ f, PyTrace_RETURN, retval)) {
Py_XDECREF(retval);
retval = NULL;
why = WHY_EXCEPTION;
}
}
- if (tstate->sys_tracefunc != NULL) {
+ if (tstate->c_tracefunc != NULL && !tstate->tracing) {
/* tstate->sys_tracefunc, if defined, is a function that
will be called on *every* entry to a code block.
Its return value, if not None, is a function that
depends on the situation. The global trace function
(sys.trace) is also called whenever an exception
is detected. */
- if (call_trace(&tstate->sys_tracefunc,
- &f->f_trace, f, str_call,
- Py_None/*XXX how to compute arguments now?*/)) {
+ if (call_trace(tstate->c_tracefunc, tstate->c_traceobj,
+ f, PyTrace_CALL, Py_None)) {
+ /* XXX Need way to compute arguments?? */
/* Trace function raised an error */
goto fail;
}
}
- if (tstate->sys_profilefunc != NULL) {
+ if (tstate->c_profilefunc != NULL) {
/* Similar for sys_profilefunc, except it needn't return
itself and isn't called for "line" events */
- if (call_trace(&tstate->sys_profilefunc,
- (PyObject**)0, f, str_call,
- Py_None/*XXX*/)) {
+ if (call_trace(tstate->c_profilefunc, tstate->c_profileobj,
+ f, PyTrace_CALL, Py_None)) {
+ /* XXX Need way to compute arguments?? */
+ /* Profile function raised an error */
goto fail;
}
}
#endif
static void
-call_exc_trace(PyObject **p_trace, PyObject **p_newtrace, PyFrameObject *f)
+call_exc_trace(Py_tracefunc func, PyObject *self, PyFrameObject *f)
{
PyObject *type, *value, *traceback, *arg;
int err;
PyErr_Restore(type, value, traceback);
return;
}
- err = call_trace(p_trace, p_newtrace, f, str_exception, arg);
+ err = call_trace(func, self, f, PyTrace_EXCEPTION, arg);
Py_DECREF(arg);
if (err == 0)
PyErr_Restore(type, value, traceback);
}
}
-/* PyObject **p_trace: in/out; may not be NULL;
- may not point to NULL variable initially
- PyObject **p_newtrace: in/out; may be NULL;
- may point to NULL variable;
- may be same variable as p_newtrace
- PyObject *msg: in; must not be NULL
-*/
-
static int
-call_trace(PyObject **p_trace, PyObject **p_newtrace, PyFrameObject *f,
- PyObject *msg, PyObject *arg)
-{
- PyThreadState *tstate = f->f_tstate;
- PyObject *args;
- PyObject *res = NULL;
-
- if (tstate->tracing) {
- /* Don't do recursive traces */
- if (p_newtrace) {
- Py_XDECREF(*p_newtrace);
- *p_newtrace = NULL;
- }
+call_trace(Py_tracefunc func, PyObject *obj, PyFrameObject *frame,
+ int what, PyObject *arg)
+{
+ register PyThreadState *tstate = frame->f_tstate;
+ int result;
+ if (tstate->tracing)
return 0;
- }
-
- args = PyTuple_New(3);
- if (args == NULL)
- goto cleanup;
- Py_INCREF(msg);
- Py_INCREF(f);
- PyTuple_SET_ITEM(args, 0, (PyObject *)f);
- PyTuple_SET_ITEM(args, 1, msg);
- if (arg == NULL)
- arg = Py_None;
- Py_INCREF(arg);
- PyTuple_SET_ITEM(args, 2, arg);
tstate->tracing++;
- PyFrame_FastToLocals(f);
- res = PyEval_CallObject(*p_trace, args); /* May clear *p_trace! */
- PyFrame_LocalsToFast(f, 1);
+ result = func(obj, frame, what, arg);
tstate->tracing--;
- cleanup:
- Py_XDECREF(args);
- if (res == NULL) {
- /* The trace proc raised an exception */
- PyTraceBack_Here(f);
- Py_XDECREF(*p_trace);
- *p_trace = NULL;
- if (p_newtrace) {
- Py_XDECREF(*p_newtrace);
- *p_newtrace = NULL;
- }
- /* to be extra double plus sure we don't get recursive
- * calls inf either tracefunc or profilefunc gets an
- * exception, zap the global variables.
- */
- Py_XDECREF(tstate->sys_tracefunc);
- tstate->sys_tracefunc = NULL;
- Py_XDECREF(tstate->sys_profilefunc);
- tstate->sys_profilefunc = NULL;
- return -1;
- }
- else {
- if (p_newtrace) {
- Py_XDECREF(*p_newtrace);
- if (res == Py_None)
- *p_newtrace = NULL;
- else {
- Py_INCREF(res);
- *p_newtrace = res;
- }
- }
- Py_DECREF(res);
- return 0;
- }
+ return result;
}
-/* Initialize the strings that get passed to the profile and trace functions;
- * this avoids doing this while we're actually profiling/tracing.
- */
-int
-_PyTrace_Init(void)
+void
+PyEval_SetProfile(Py_tracefunc func, PyObject *arg)
{
- if (str_call == NULL) {
- str_call = PyString_InternFromString("call");
- if (str_call == NULL)
- return -1;
- }
- if (str_exception == NULL) {
- str_exception = PyString_InternFromString("exception");
- if (str_exception == NULL)
- return -1;
- }
- if (str_line == NULL) {
- str_line = PyString_InternFromString("line");
- if (str_line == NULL)
- return -1;
- }
- if (str_return == NULL) {
- str_return = PyString_InternFromString("return");
- if (str_return == NULL)
- return -1;
- }
- return 0;
+ PyThreadState *tstate = PyThreadState_Get();
+ PyObject *temp = tstate->c_profileobj;
+ Py_XINCREF(arg);
+ tstate->c_profilefunc = NULL;
+ tstate->c_profileobj = NULL;
+ Py_XDECREF(temp);
+ tstate->c_profilefunc = func;
+ tstate->c_profileobj = arg;
+}
+
+void
+PyEval_SetTrace(Py_tracefunc func, PyObject *arg)
+{
+ PyThreadState *tstate = PyThreadState_Get();
+ PyObject *temp = tstate->c_traceobj;
+ Py_XINCREF(arg);
+ tstate->c_tracefunc = NULL;
+ tstate->c_traceobj = NULL;
+ Py_XDECREF(temp);
+ tstate->c_tracefunc = func;
+ tstate->c_traceobj = arg;
}
PyObject *
\n\
Set the current default string encoding used by the Unicode implementation.";
-extern int _PyTrace_Init(void);
+/*
+ * Cached interned string objects used for calling the profile and
+ * trace functions. Initialized by trace_init().
+ */
+static PyObject *whatstrings[4] = {NULL, NULL, NULL, NULL};
+
+static int
+trace_init(void)
+{
+ static char *whatnames[4] = {"call", "exception", "line", "return"};
+ PyObject *name;
+ int i;
+ for (i = 0; i < 4; ++i) {
+ if (whatstrings[i] == NULL) {
+ name = PyString_InternFromString(whatnames[i]);
+ if (name == NULL)
+ return -1;
+ whatstrings[i] = name;
+ }
+ }
+ return 0;
+}
+
+
+static PyObject *
+call_trampoline(PyThreadState *tstate, PyObject* callback,
+ PyFrameObject *frame, int what, PyObject *arg)
+{
+ PyObject *args = PyTuple_New(3);
+ PyObject *whatstr;
+ PyObject *result;
+
+ if (args == NULL)
+ return NULL;
+ Py_INCREF(frame);
+ whatstr = whatstrings[what];
+ Py_INCREF(whatstr);
+ if (arg == NULL)
+ arg = Py_None;
+ Py_INCREF(arg);
+ PyTuple_SET_ITEM(args, 0, (PyObject *)frame);
+ PyTuple_SET_ITEM(args, 1, whatstr);
+ PyTuple_SET_ITEM(args, 2, arg);
+
+ /* call the Python-level function */
+ PyFrame_FastToLocals(frame);
+ result = PyEval_CallObject(callback, args);
+ PyFrame_LocalsToFast(frame, 1);
+ if (result == NULL)
+ PyTraceBack_Here(frame);
+
+ /* cleanup */
+ Py_DECREF(args);
+ return result;
+}
+
+static int
+profile_trampoline(PyObject *self, PyFrameObject *frame,
+ int what, PyObject *arg)
+{
+ PyThreadState *tstate = frame->f_tstate;
+ PyObject *result;
+
+ result = call_trampoline(tstate, self, frame, what, arg);
+ if (result == NULL) {
+ PyEval_SetProfile(NULL, NULL);
+ return -1;
+ }
+ Py_DECREF(result);
+ return 0;
+}
+
+static int
+trace_trampoline(PyObject *self, PyFrameObject *frame,
+ int what, PyObject *arg)
+{
+ PyThreadState *tstate = frame->f_tstate;
+ PyObject *callback;
+ PyObject *result;
+
+ if (what == PyTrace_CALL)
+ callback = self;
+ else
+ callback = frame->f_trace;
+ if (callback == NULL)
+ return 0;
+ result = call_trampoline(tstate, callback, frame, what, arg);
+ if (result == NULL) {
+ PyEval_SetTrace(NULL, NULL);
+ Py_XDECREF(frame->f_trace);
+ frame->f_trace = NULL;
+ return -1;
+ }
+ if (result != Py_None) {
+ PyObject *temp = frame->f_trace;
+ frame->f_trace = NULL;
+ Py_XDECREF(temp);
+ frame->f_trace = result;
+ }
+ else {
+ Py_DECREF(result);
+ }
+ return 0;
+}
static PyObject *
sys_settrace(PyObject *self, PyObject *args)
{
- PyThreadState *tstate = PyThreadState_Get();
- if (_PyTrace_Init() == -1)
+ if (trace_init() == -1)
return NULL;
if (args == Py_None)
- args = NULL;
+ PyEval_SetTrace(NULL, NULL);
else
- Py_XINCREF(args);
- Py_XDECREF(tstate->sys_tracefunc);
- tstate->sys_tracefunc = args;
+ PyEval_SetTrace(trace_trampoline, args);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
sys_setprofile(PyObject *self, PyObject *args)
{
- PyThreadState *tstate = PyThreadState_Get();
- if (_PyTrace_Init() == -1)
+ if (trace_init() == -1)
return NULL;
if (args == Py_None)
- args = NULL;
+ PyEval_SetProfile(NULL, NULL);
else
- Py_XINCREF(args);
- Py_XDECREF(tstate->sys_profilefunc);
- tstate->sys_profilefunc = args;
+ PyEval_SetProfile(profile_trampoline, args);
Py_INCREF(Py_None);
return Py_None;
}
projects / thirdparty / Python / cpython.git / commitdiff
