Python a C/C++

Keď sa navrhuje aplikácia, často sa kladie doraz na to, aby bola modulárna, ľahko rozšíriteľná, aby sa dala ľahko upravovať podla potrieb. Pri takýchto myšlienkach si programátor nie raz povie, žeby nebolo zle ak by jeho aplikácia mala skriptovací jazyk.

Vyvinúť vlastný skriptovací jazyk v C nieje malé sústo a taktiež prináša viac nevýhod ako výhod. To však nemusí platiť ak sa človek rozhodne implementovať už existujúci interpreter. Práve v tomto ja osobne vidím jednu z najväčších výhod Perlu a Pythona. Totižto ich interpreter sa dá ľahko implementovať do C aplikácie a sú doslova predurčene na takéto využitie. Jedným z mnoho príkladov je napríklad 3D modelovacia aplikácia Blender, ktorej funkcionalitu môže užívateľ vylepšiť práve modulmi napísanými v Pythone. V tomto článku vám ukážem, ako môžete vykonávať vo vašej C aplikácii Python skript, ako môžete volať funkcie Pythonu, taktiež ako môžete volať C funkcie z Python skriptu. Tieto poznatky by vám mali umožniť obojstrannú interakciu medzi skriptom a C aplikáciou.

Počiatočné strasti a priepasti

main.c:

#include <Python.h>

int main()
{
   Py_Initialize();
   PyRun_SimpleString("print 'Hello World'");
   Py_Finalize();
   return 0;
}

sn3d@laptop$ g++ -I/cesta_k_python_h -L/cesta_k_python2.4_so -lpython2.4 -o out main.c
sn3d@laptop$ ./out
Hello World

warning: "_POSIX_C_SOURCE" redefined

Pár slov ohľadom PyObject

Volanie Python funkcie

script.py:

def compute(a, b, text):
   print 'message is:', text
   c = a + b
   return c

print 'script.py loaded \n'

main.c:

#include <stdio.h>
#include <Python.h>

int main()
{
   //Deklaracia premenných.
   PyObject* pMain;
   PyObject* pMainDict;
   PyObject* pFunc;
   PyObject* pArgs;
   PyObject* pArgA;
   PyObject* pArgB;
   PyObject* pArgText;
   PyObject* pReturn;
   FILE*     file;
   long      retuned;

   //Inicializácia python interpretera.
   Py_Initialize();
   pMain = PyImport_AddModule("__main__");
   pMainDict = PyModule_GetDict(pMain);

   //Otvorenie súboru a jeho vykonanie v main module.
   file = fopen("script.py", "r");
   if (file) {
      PyRun_SimpleFile(file, "script.py");
   }

   //Vyhladanie existencie funkcie.
   pFunc = PyDict_GetItemString(pMainDict, "compute");
   if (PyCallable_Check(pFunc)) {

      //Prírava argumentov funkcie.
      pArgA    = PyInt_FromLong(1);
      pArgB    = PyInt_FromLong(3);
      pArgText = PyString_FromString("Hello Python");

      //Vytvorenie objektu argumentov.
      pArgs = PyTuple_New(3);
      PyTuple_SetItem(pArgs, 0, pArgA);
      PyTuple_SetItem(pArgs, 1, pArgB);
      PyTuple_SetItem(pArgs, 2, pArgText);

      //Volanie funkcie a spracovanie result hodnoty.
      pReturn = PyObject_CallObject(pFunc, pArgs);
      Py_DECREF(pArgs);

      //Spracovanie návratovej hodnoty.
      if (pReturn) {
         returned = PyInt_AsLong(pReturn);
         Py_DECREF(pReturn);
         printf("function return: %d\n", returned);
      }
   }

   Py_Finalize();
   return 0;
}

Python funkcia, ktorú chceme volať, sa nachádza v súbore script.py. Potrebujeme teda otvoriť tento súbor a nechať vykonať jeho kód, aby sa v __main__ module nachádzala tato funkcia. Súbor otvoríme pomocou bežnej funkcie fopen() a následne file descriptor predáme funkcii PyRun_SimpleFile(), ktorá skript vykoná.

Teraz nám už len stačí získať ukazovateľ na compute funkciu, predať jej argumenty a zavolať ju. Znie to celkom jednoducho. Ukazovateľ na funkciu získame nasledujúcim kódom.

   ...
   pFunc = PyDict_GetItemString(pMainDict, "compute");
   if (PyCallable_Check(pFunc)) {
   ...

   pArgA    = PyInt_FromLong(1);
   pArgB    = PyInt_FromLong(3);
   pArgText = PyString_FromString("Hello Python");
   ...

   ...
   //Vytvorenie objektu argumentov.
   pArgs = PyTuple_New(3);
   PyTuple_SetItem(pArgs, 0, pArgA);
   PyTuple_SetItem(pArgs, 1, pArgB);
   PyTuple_SetItem(pArgs, 2, pArgText);
   ...

   ...
   pReturn = PyObject_CallObject(pFunc, pArgs);
   Py_DECREF(pArgs);

   //Spracovanie návratovej hodnoty.
   if (pReturn) {
      returned = PyInt_AsLong(pReturn);
      Py_DECREF(pReturn);
      printf("function return: %d\n", returned);

   }

script.py loaded
message is:Hello Python
function return: 4

Volanie C funkcie

main.c:

#include <stdio.h>
#include <Python.h>

#define SCRIPT_FILE "script.py"

int computeEx(int a, const char* text)
{
   printf("C SAY: computeEx write:%s\n", text);
   return (a+a);
}


PyObject* computeExWrap(PyObject* self, PyObject* args)
{
   //Deklaracia premenných.
   PyObject* pResult;
   int       result;
   int       arg_a;
   char*     arg_text;

   //Konvertovanie python argumentov na C hodnoty.
   PyArg_ParseTuple(args, "is", &arg_a, &arg_text);

   //Zavolanie computeEx a spracovanie return hodnoty.
   result = computeEx(arg_a, arg_text);
   pResult = Py_BuildValue("i", result);

   return pResult;
}


static PyMethodDef methods[] = {
   {"computeEx", computeExWrap, METH_VARARGS, "my own C-function"},
   {NULL, NULL, 0, NULL}
};


int main()
{
   //Deklaracia premenných.
   PyObject* pMain;
   PyObject* pMainDict;
   FILE*     file;

   //Inicializácia.
   Py_Initialize();
   Py_InitModule("c_module", methods);

   //Otvorenie súboru a jeho vykonanie v main module.
   file = fopen(SCRIPT_FILE, "r");
   if (file) {
      PyRun_SimpleFile(file, SCRIPT_FILE);
   }

   Py_Finalize();
   return 0;
}

script.py:

import c_module

print 'PYTHON SAY: calling c_module.computeEx()'
ret = c_module.computeEx(2, "Hello Python")
print 'PYTHON SAY:c_module.computeEx() return is:', ret

PyObject* computeExWrap(PyObject* self, PyObject* args)
{
   //Deklaracia premenných.
   PyObject* pResult;
   int       result;
   int       arg_a;
   char*     arg_text;

   //Konvertovanie python argumentov na C hodnoty.
   PyArg_ParseTuple(args, "is", &arg_a, &arg_text);

   //Zavolanie computeEx a spracovanie return hodnoty.
   result = computeEx(arg_a, arg_text);
   pResult = Py_BuildValue("i", result);

   return pResult;
}

Akonáhle už mame skonvertované hodnoty do Céčka, môžeme zavolať funkciu computeEx(), ktorej tieto hodnoty predáme. Výsledok funkcie si uložíme a ďalšou funkciou Py_BuildValue() ju naopak konvertujeme z Céčka do Pythonu. Funkcia používa rovnaký konverzný reťazec, v tomto prípade len „i“, nakoľko výstup funkcie je len číslo. Návratovú hodnotu použijeme aj ako návratovú hodnotu funkcie computeExWrap(). Ďalej nasleduje akési prepojenie medzi pythonom a Céčkom. Ide o pole prvkov PyMethodDef.

static PyMethodDef methods[] = {
   {"computeEx", computeExWrap, METH_VARARGS, "my own C-function"},
   {NULL, NULL, 0, NULL}
};

V tejto chvíli už mame všetko potrebne, aby sme zavolali computeEx() funkciu a dostávame sa pomaličky ku koncu a k funkcii main(). Funkcia nieje zložitá a už by vám mala byt jasná.

int main()
{
   //Deklaracia premenných.
   PyObject* pMain;
   PyObject* pMainDict;
   FILE*     file;
   //inicializácia
   Py_Initialize();
   Py_InitModule("c_module", methods);

   //Otvorenie súboru a jeho vykonanie v main module.
   file = fopen(SCRIPT_FILE, "r");
   if (file) {
      PyRun_SimpleFile(file, SCRIPT_FILE);
   }

   Py_Finalize();
   return 0;
}

PYTHON SAY: calling c_module.computeEx()
C SAY: computeEx write:Hello Python
PYTHON SAY:c_module.computeEx() return is: 4