 |
 |
 |
Extending and Embedding the Python Interpreter |  |
 |
|
|
|
|
Extending and Embedding the Python Interpreter | |
|
|
The first program aims to execute a function in a Python script. Like in the section about the very high level interface, the Python interpreter does not directly interact with the application (but that will change in th next section).
The code to run a function defined in a Python script is:
#include <Python.h>
int
main(int argc, char *argv[])
{
PyObject *pName, *pModule, *pDict, *pFunc;
PyObject *pArgs, *pValue;
int i;
if (argc < 3) {
fprintf(stderr,"Usage: call pythonfile funcname [args]\n");
return 1;
}
Py_Initialize();
pName = PyString_FromString(argv[1]);
/* Error checking of pName left out */
pModule = PyImport_Import(pName);
Py_DECREF(pName);
if (pModule != NULL) {
pDict = PyModule_GetDict(pModule);
/* pDict is a borrowed reference */
pFunc = PyDict_GetItemString(pDict, argv[2]);
/* pFun: Borrowed reference */
if (pFunc && PyCallable_Check(pFunc)) {
pArgs = PyTuple_New(argc - 3);
for (i = 0; i < argc - 3; ++i) {
pValue = PyInt_FromLong(atoi(argv[i + 3]));
if (!pValue) {
Py_DECREF(pArgs);
Py_DECREF(pModule);
fprintf(stderr, "Cannot convert argument\n");
return 1;
}
/* pValue reference stolen here: */
PyTuple_SetItem(pArgs, i, pValue);
}
pValue = PyObject_CallObject(pFunc, pArgs);
Py_DECREF(pArgs);
if (pValue != NULL) {
printf("Result of call: %ld\n", PyInt_AsLong(pValue));
Py_DECREF(pValue);
}
else {
Py_DECREF(pModule);
PyErr_Print();
fprintf(stderr,"Call failed\n");
return 1;
}
/* pDict and pFunc are borrowed and must not be Py_DECREF-ed */
}
else {
if (PyErr_Occurred())
PyErr_Print();
fprintf(stderr, "Cannot find function \"%s\"\n", argv[2]);
}
Py_DECREF(pModule);
}
else {
PyErr_Print();
fprintf(stderr, "Failed to load \"%s\"\n", argv[1]);
return 1;
}
Py_Finalize();
return 0;
}
This code loads a Python script using argv[1], and calls the
function named in argv[2]. Its integer arguments are the other
values of the argv array. If you compile and link this
program (let's call the finished executable call), and use
it to execute a Python script, such as:
def multiply(a,b):
print "Thy shall add", a, "times", b
c = 0
for i in range(0, a):
c = c + b
return c
then the result should be:
$ call multiply multiply 3 2 Thy shall add 3 times 2 Result of call: 6
Although the program is quite large for its functionality, most of the code is for data conversion between Python and C, and for error reporting. The interesting part with respect to embedding Python starts with
Py_Initialize();
pName = PyString_FromString(argv[1]);
/* Error checking of pName left out */
pModule = PyImport_Import(pName);
After initializing the interpreter, the script is loaded using PyImport_Import(). This routine needs a Python string as its argument, which is constructed using the PyString_FromString() data conversion routine.
pDict = PyModule_GetDict(pModule);
/* pDict is a borrowed reference */
pFunc = PyDict_GetItemString(pDict, argv[2]);
/* pFun is a borrowed reference */
if (pFunc && PyCallable_Check(pFunc)) {
...
}
Once the script is loaded, its dictionary is retrieved with PyModule_GetDict(). The dictionary is then searched using the normal dictionary access routines for the function name. If the name exists, and the object returned is callable, you can safely assume that it is a function. The program then proceeds by constructing a tuple of arguments as normal. The call to the python function is then made with:
pValue = PyObject_CallObject(pFunc, pArgs);
Upon return of the function, pValue is either NULL or it
contains a reference to the return value of the function. Be sure to
release the reference after examining the value.
|
|
|
Extending and Embedding the Python Interpreter | |
|
|