How to get current function name in Python C-API?

I implemented a bunch of functions and they are dispatched from the same C function called by the Python interpreter:

PyObject *
CmdDi开发者_如何学编程spatch(PyObject *self, PyObject *args, PyObject *kwargs)

Unexpectedly, self is NULL, and I need to get the function name currently being called. Is there any way to get this information?

I have dozens of functions which are all going through this routine. This command processes all of the options into a C++ map and passes it along to the implementation of each command.

Update: http://docs.python.org/extending/extending.html#a-simple-example specifically says "The self argument points to the module object for module-level functions; for a method it would point to the object instance.", but I am getting passed null when linking against python 2.6.

I've been trying to solve very similar problem.

The conclusion I've come to suggests there is no way to determine name of current function or caller(s) at the level of Python C API. The reason being, Python interpreter puts on call stack only pure Python functions (implemented in Python itself). Functions implemented in C, regardless if registered in module methods table, are not put on Python stack, thus it's not possible to find them inspecting the stack frames.

Here is a quick example in Python illustrating what I wanted to achieve (I assume Juan asks for similar behaviour):

import sys
def foo():
    print('foo:', sys._getframe(0).f_code.co_name)
def bar():
    print('bar:', sys._getframe(0).f_code.co_name)
    foo()
bar()

Here is close equivalent of this example (based on the Python 3 docs) but implemented using Python C API:

// Based on example from Python 3.2.1 documentation, 5.4. Extending Embedded Python
// http://docs.python.org/release/3.2.1/extending/embedding.html#extending-embedded-python
//
#include <Python.h>
#include <frameobject.h>

static void foo()
{
    PyThreadState * ts = PyThreadState_Get();
    PyFrameObject* frame = ts->frame;
    while (frame != 0)
    {
        char const* filename = _PyUnicode_AsString(frame->f_code->co_filename);
        char const* name = _PyUnicode_AsString(frame->f_code->co_name);
        printf("foo: filename=%s, name=%s\n", filename, name);
        frame = frame->f_back;
    }
}

static void bar()
{
    PyRun_SimpleString(
    "import sys\n"
    "print(\"bar: filename=%s, name=%s\" % (sys._getframe(0).f_code.co_filename, sys._getframe(0).f_code.co_name))"
    );
}

static PyObject* emb_numargs(PyObject *self, PyObject *args)
{
    foo();
    bar();

    PyRun_SimpleString(
    "import sys\n"
    "print(\"emb_numargs: filename=%s, name=%s\" % (sys._getframe(0).f_code.co_filename, sys._getframe(0).f_code.co_name))"
    );

    return PyLong_FromLong(0);
}

static PyMethodDef EmbMethods[] = {
    {"numargs", emb_numargs, METH_VARARGS, "Return number 0"},
    {NULL, NULL, 0, NULL}
};

static PyModuleDef EmbModule = {
    PyModuleDef_HEAD_INIT, "emb", NULL, -1, EmbMethods,
    NULL, NULL, NULL, NULL
};

static PyObject* PyInit_emb(void)
{
    return PyModule_Create(&EmbModule);
}

int main(int argc, char* argv[])
{
    PyImport_AppendInittab("emb", &PyInit_emb);
    Py_Initialize();
    PyRun_SimpleString(
    "import emb\n"
    "print('This is Zero: ', emb.numargs())\n"
    );
    Py_Finalize();
    return 0;
}

I hope this completes Ned's answer too.

The Python api isn't built to tell you what function it is calling. You've created a function, and it is calling it, the API assumes you know what function you've written. You'll need to create a small wrapper function for each of your Python functions. The best way to do this is to register your one C function as one Python function that takes a string as its first argument. Then, in your Python layer, create as many Python functions as you need, each invoking your C function with the proper string argument identifying what function you really want to call.

Another alternative is to rethink the structure of your C code, and have as many functions as you need, each of which invokes your common helper code to process options, etc.

NOTICE error checking for API is not being provided for clarity;

This example insert a new function directly on python __builtin__ module, allowing to call the method without class.method schema. Just change mymodule to any other module as you wish.

PyObject* py_cb(PyObject *self, PyObject *args)
{
    const char *name = (const char *) PyCObject_AsVoidPtr(self);

    printf("%s\n", name);
    Py_RETURN_NONE;
}

int main(int argc, char *argv)
{
    PyObject        *mod, *modname, *dict, *fnc, *usrptr;
    const char      *mymodule = "__builtin__";
    PyMethodDef     *m;
    const char      *method = "hello_python";

    Py_Initialize();
    mod = PyImport_ImportModule(mymodule);
    modname = PyString_FromString(mymodule);
    dict = PyModule_GetDict(mod);
    m = (PyMethodDef *) calloc(1, sizeof(PyMethodDef));
    m->ml_name = strdup(method);
    m->ml_meth = py_cb;
    usrptr = PyCObject_FromVoidPtr("I'm am the hello_python!", NULL);
    fnc = PyCFunction_NewEx(m, usrptr, modname);
    PyDict_SetItemString(dict, method, fnc);
    ...

When python script execute hello_python, the py_cb extension function will show:

I'm am the hello_python!

The self is used to send a real pointer such as the library context instead of this const char * of this example, this is now a matter of changing it to something interesting though.

I don't know if can be done directly from the C-API. At worst, you could call the traceback module from C, to get the name of the caller.