Author: juhliarik Date: Tue Nov 13 15:13:53 2007 New Revision: 42021 URL: http://svn.opensuse.org/viewcvs/yast?rev=42021&view=rev Log: added functionality for calling python function in YCP via reference Modified: trunk/python-bindings/src/YCPDeclarations.cc trunk/python-bindings/src/YCPDeclarations.h trunk/python-bindings/src/YPython.cc trunk/python-bindings/src/YPython.h trunk/python-bindings/src/YPythonNamespace.cc trunk/python-bindings/src/YPythonNamespace.h Modified: trunk/python-bindings/src/YCPDeclarations.cc URL: http://svn.opensuse.org/viewcvs/yast/trunk/python-bindings/src/YCPDeclarations.cc?rev=42021&r1=42020&r2=42021&view=diff ============================================================================== --- trunk/python-bindings/src/YCPDeclarations.cc (original) +++ trunk/python-bindings/src/YCPDeclarations.cc Tue Nov 13 15:13:53 2007 @@ -2,21 +2,27 @@ #include <iostream> using std::string; using std::vector; -#define DBG(str) \ - std::cerr << __FILE__ << ": " << __LINE__ << ": " << str << std::endl; \ - std::cerr.flush() -//#define DBG(str) +//#define DBG(str) \ +// std::cerr << __FILE__ << ": " << __LINE__ << ": " << str << std::endl; \ +// std::cerr.flush() +#define DBG(str) /********** STATIC MEMBERS **********/ +int YCPDeclarations::_initial = 0; + std::auto_ptr<YCPDeclarations> YCPDeclarations::_instance; YCPDeclarations *YCPDeclarations::instance() { + + DBG("Called YCPDeclarations::instance()"); if (_instance.get() == 0){ _instance = std::auto_ptr<YCPDeclarations>(new YCPDeclarations()); } return _instance.get(); } + + /********** STATIC MEMBERS END **********/ @@ -164,6 +170,7 @@ YCPDeclarations::YCPDeclarations() { DBG("YCPDeclarations - constructor"); + YCPDeclarations::_initial = 1; _py_self = PyImport_ImportModule("YCPDeclarations"); if (_py_self == NULL){ DBG("YCPDeclarations::YCPDeclarations() - Failed to import YCPDeclarations module!"); @@ -174,19 +181,26 @@ { DBG("YCPDeclarations - destructor"); - - int cache_len = _cache.size(); - for (int i=0; i < cache_len; i++){ - delete _cache[i]; - } - - if (_py_self != NULL) - Py_DECREF(_py_self); - - //_instance = std::auto_ptr<YCPDeclarations>(NULL); + if (Initialized()) { + int cache_len = _cache.size(); + for (int i=0; i < cache_len; i++){ + delete _cache[i]; + } + + if (_py_self != NULL) + Py_DECREF(_py_self); + } + YCPDeclarations::_initial = 0; } +bool YCPDeclarations::Initialized() { + if (YCPDeclarations::_initial == 1) + return true; + else + return false; +} + int YCPDeclarations::numParams(PyFunctionObject *func) { Modified: trunk/python-bindings/src/YCPDeclarations.h URL: http://svn.opensuse.org/viewcvs/yast/trunk/python-bindings/src/YCPDeclarations.h?rev=42021&r1=42020&r2=42021&view=diff ============================================================================== --- trunk/python-bindings/src/YCPDeclarations.h (original) +++ trunk/python-bindings/src/YCPDeclarations.h Tue Nov 13 15:13:53 2007 @@ -85,10 +85,22 @@ */ const cache_function_t *_getCachedFunction(PyFunctionObject *func) const; + + /** + * The value indicates if YCPDeclarations was initialized + * 1 - initialized 0 - non initialized + */ + static int _initial; + public: ~YCPDeclarations(); /** + * Return true if YCPDeclarations was initialized. + */ + bool Initialized(); + + /** * Return number of parameters in declaration or -1 if function is not registered. */ int numParams(PyFunctionObject *pointer_to_function); Modified: trunk/python-bindings/src/YPython.cc URL: http://svn.opensuse.org/viewcvs/yast/trunk/python-bindings/src/YPython.cc?rev=42021&r1=42020&r2=42021&view=diff ============================================================================== --- trunk/python-bindings/src/YPython.cc (original) +++ trunk/python-bindings/src/YPython.cc Tue Nov 13 15:13:53 2007 @@ -46,9 +46,11 @@ #include #include #include +#include #include "YCPTypes.h" #include "YPythonNamespace.h" +#include "YCPDeclarations.h" #include <iostream> #define DBG(str) \ @@ -134,7 +136,8 @@ if (!Py_IsInitialized()) { setenv("PYTHONPATH", path.c_str(), 1); Py_Initialize(); - YPython::_pMainDicts = PyDict_New(); + if (!YPython::_pMainDicts) + YPython::_pMainDicts = PyDict_New(); } if (!YPython::_pMainDicts) @@ -610,11 +613,11 @@ * @return namespace of YCP */ -static Y2Namespace * getNs (const char * ns_name, const char * func_name) { +static Y2Namespace * getNs (const char * ns_name) { Import import(ns_name); // has a static cache Y2Namespace *ns = import.nameSpace(); if (ns == NULL) { - y2error ("... for a Python call of %s", func_name); + y2error ("... for a Python call of %s", ns_name); } else { ns->initialize (); } @@ -632,40 +635,115 @@ int YPython::findModuleFuncInDict(string module, string function) { - PyObject* pMainDict = NULL; // dictionary of module - PyObject* pFunc = NULL; // function from dictionary + PyObject * pModuleName = PyString_FromString(module.c_str()); + if (_pMainDicts==NULL) + return -1; + if (PyDict_Contains(_pMainDicts, pModuleName)) { - //obtain correct dictionary for module - pMainDict = PyDict_GetItemString(YPython::yPython()->pMainDicts(),module.c_str()); + PyObject * pMainDict = PyDict_GetItemString(_pMainDicts, module.c_str()); + if (PyDict_Contains(pMainDict, PyString_FromString(function.c_str()))) + return 1; + else + return 0; + + } else { - //obtain function from dictionary - if (pMainDict) - pFunc = PyDict_GetItemString(pMainDict, function.c_str()); - else return -1; - - if (pFunc) - return 1; - else - return 0; + } + } +/** + * Adding module name and function into + * global dictionary + * (necessary for calling python function via reference) + **/ +bool YPython::addModuleAndFunction(string module, string fun_name, PyObject* function) { + + + PyObject * pModuleName = PyString_FromString(module.c_str()); + //check if dictionary contain "dictionary" for module + + if (_pMainDicts==NULL) { + _pMainDicts = PyDict_New(); + } + + if (PyDict_Contains(_pMainDicts, pModuleName)) { + PyObject * pMainDict = PyDict_GetItemString(_pMainDicts, module.c_str()); + + if (PyDict_Contains(pMainDict, PyString_FromString(fun_name.c_str()))) { + return true; + + } else { + //PyObject * newDict = PyDict_New(); + if (PyDict_SetItemString(pMainDict, fun_name.c_str(), function) < 0) { + y2error("Adding new function %s to local dictionary", fun_name.c_str()); + return false; + } + + if (PyDict_DelItemString(_pMainDicts, module.c_str()) <0) { + y2error("Deleting local dictionary %s from global dictionary failed", module.c_str()); + return false; + } + + if (PyDict_SetItemString(_pMainDicts, module.c_str(), pMainDict) <0) { + y2error("Adding new local dictionary %s to global dictionary", module.c_str()); + return false; + } + + return true; + } + } else { + PyObject * newDict = PyDict_New(); + + if (PyDict_SetItemString(newDict, fun_name.c_str(), function) < 0) { + y2error("Adding new function %s to local dictionary", fun_name.c_str()); + return false; + } + + if (PyDict_SetItemString(_pMainDicts, module.c_str(), newDict) <0) { + y2error("Adding new local dictionary %s to global dictionary", module.c_str()); + return false; + } + + return true; + } +} + +YCPValue YPython::findSymbolEntry(Y2Namespace *ns, string module, string function) { + + if (ns) { + TableEntry *sym_te = ns->table ()->find (function.c_str()); + + if (sym_te == NULL) { + y2error ("No such symbol %s::%s", module.c_str(), function.c_str()); + return YCPNull(); + } + + SymbolEntryPtr sym_entry = sym_te->sentry(); + //cout << "entry" << sym_entry->toString()<< endl; + return YCPReference(sym_entry); + + } else { + y2error("Creating/Importing namespace for function %s failed", function.c_str()); + return YCPNull(); + } +} /** * Convert Python Function to YCPCode. * * @param pointer to python function - * @return YCPCode - Referecne + * @return YCPReference - Referecne **/ YCPValue YPython::fromPythonFunToReference (PyObject* pyFun) { - PyObject *fun_code = PyFunction_GetCode(pyFun); string fun_name = PyString_AsString(((PyCodeObject *) fun_code)->co_name); string file_path = PyString_AsString(((PyCodeObject *) fun_code)->co_filename); - - + //int no_args = ((PyCodeObject *) fun_code)->co_argcount; + //found last "/" in path size_t found = file_path.find_last_of("/"); //extract module name from path @@ -674,25 +752,49 @@ module_name.erase(module_name.size()-3); int find = findModuleFuncInDict(module_name, fun_name); - - if (find) { - Y2Namespace *ns = getNs (module_name.c_str(),fun_name.c_str()); - - if (ns) { - TableEntry *sym_te = ns->table ()->find (fun_name.c_str()); - if (sym_te == NULL) { - y2error ("No such symbol %s::%s", module_name.c_str(), fun_name.c_str()); - return YCPNull(); + + FunctionTypePtr sym_tp; + Y2Namespace *ns; + + //namespace exist and includes function + if (find == 1) { + ns = getNs (module_name.c_str()); + + return findSymbolEntry(ns, module_name, fun_name); + + //namespace exist but doesn't include function + } else if (find ==0) { + addModuleAndFunction(module_name, fun_name, pyFun); + + ns = getNs (module_name.c_str()); + + if (ns) { + + SymbolEntry *result = ((YPythonNamespace *)ns)->AddFunction(pyFun); + if (result) + return YCPReference(result); + else { + y2error("Adding function %s to namespace %s failed", fun_name.c_str(), module_name.c_str()); + return YCPNull(); + } + + } else { + y2error("Importing namespace %s for function %s failed", + module_name.c_str(), fun_name.c_str()); + return YCPNull(); } - SymbolEntryPtr sym_entry = sym_te->sentry(); - //cout << "entry" << sym_entry->toString()<< endl; - return YCPReference(sym_entry); + //namespace and function don't exist } else { - y2error("Creating namespace for function %s failed", fun_name.c_str()); - return YCPNull(); - } + addModuleAndFunction(module_name, fun_name, pyFun); + ns = new YPythonNamespace(module_name, pyFun); + + //register new namespace + Import import(module_name, ns); + + return findSymbolEntry(ns, module_name, fun_name); + } return YCPNull(); @@ -707,9 +809,9 @@ YCPValue YPythonCode::evaluate(bool cse) { - PyObject * pReturn; + PyObject * pReturn = NULL; YCPValue result = YCPVoid(); - PyObject * pFunction; + PyObject * pFunction = NULL; PyObject * pArgs = NULL; int args_size; Modified: trunk/python-bindings/src/YPython.h URL: http://svn.opensuse.org/viewcvs/yast/trunk/python-bindings/src/YPython.h?rev=42021&r1=42020&r2=42021&view=diff ============================================================================== --- trunk/python-bindings/src/YPython.h (original) +++ trunk/python-bindings/src/YPython.h Tue Nov 13 15:13:53 2007 @@ -127,6 +127,14 @@ int findModuleFuncInDict(string module, string function); + /** + * Adding module name and function into + * global dictionary + * (necessary for calling python function via reference) + **/ + bool addModuleAndFunction(string module, string fun_name, PyObject* function); + + /** * Convert a Python list to a YCPList. **/ @@ -168,8 +176,17 @@ **/ PyObject* fromYCPTermToPythonTerm (YCPValue ycp_Term); + /** + * Prepare YCPReference for calling python function in YCP via reference + **/ YCPValue fromPythonFunToReference (PyObject* pyFun); + + /** + * Function find in namespace function and return symbol entry + **/ + YCPValue findSymbolEntry(Y2Namespace *ns, string module, string function); + protected: /** Modified: trunk/python-bindings/src/YPythonNamespace.cc URL: http://svn.opensuse.org/viewcvs/yast/trunk/python-bindings/src/YPythonNamespace.cc?rev=42021&r1=42020&r2=42021&view=diff ============================================================================== --- trunk/python-bindings/src/YPythonNamespace.cc (original) +++ trunk/python-bindings/src/YPythonNamespace.cc Tue Nov 13 15:13:53 2007 @@ -230,6 +230,111 @@ } + +YPythonNamespace::YPythonNamespace (string name, PyObject* function) + : m_name (name), + m_all_methods (true) { + + + PyObject * fun_code; //code of function + + //Declarations (using YPCDelcarations python module) + YCPDeclarations *decl = YCPDeclarations::instance(); + //YCPDeclarations *decl = new YCPDeclarations(); + + FunctionTypePtr sym_tp; + std::vector<constTypePtr> list_of_types; + int tmp; + + int count = 0; // position. arbitrary numbering + long num = 0; //number of function arguments + + + fun_code = PyFunction_GetCode(function); + num = ((PyCodeObject *) fun_code)->co_argcount; + string fun_name = PyString_AsString(((PyCodeObject *) fun_code)->co_name); + + if (decl->exists((PyFunctionObject *)function) + && decl->numParams((PyFunctionObject *)function) == num){ + + sym_tp = new FunctionType(decl->returnType((PyFunctionObject *)function)); + + list_of_types = decl->params((PyFunctionObject *)function); + tmp = list_of_types.size(); + for (int i=0; i < tmp; i++){ + sym_tp->concat(list_of_types[i]); + } + } else { + sym_tp = new FunctionType(Type::Any); + //y2milestone ("Number of parameters: %d", num); + //add types and number of arguments into SymbolEntry table + for (long j = 0; j < num; j++) { + sym_tp->concat(Type::Any); + } + } + //y2milestone ("Callable function %s", PyString_AsString(item)); + // symbol entry for the function + SymbolEntry *fun_se = new SymbolEntry ( + this, + count++, // position. arbitrary numbering. must stay consistent when? + fun_name.c_str(), // passed to Ustring, no need to strdup + SymbolEntry::c_function, + sym_tp); + fun_se->setGlobal (true); + + // enter it to the symbol table + enterSymbol (fun_se, 0); + + + y2milestone ("(special) YPythonNamespace finish"); + +} + +SymbolEntry * YPythonNamespace::AddFunction (PyObject* function) { + + //Declarations (using YPCDelcarations python module) + YCPDeclarations *decl = YCPDeclarations::instance(); + int tmp; + std::vector<constTypePtr> list_of_types; + FunctionTypePtr sym_tp; + PyObject *fun_code = PyFunction_GetCode(function); + int num = ((PyCodeObject *) fun_code)->co_argcount; + string fun_name = PyString_AsString(((PyCodeObject *) fun_code)->co_name); + + if (decl->exists((PyFunctionObject *)function) + && decl->numParams((PyFunctionObject *)function) == num){ + + sym_tp = new FunctionType(decl->returnType((PyFunctionObject *)function)); + + list_of_types = decl->params((PyFunctionObject *)function); + tmp = list_of_types.size(); + for (int i=0; i < tmp; i++){ + sym_tp->concat(list_of_types[i]); + } + } else { + sym_tp = new FunctionType(Type::Any); + //y2milestone ("Number of parameters: %d", num); + //add types and number of arguments into SymbolEntry table + for (long j = 0; j < num; j++) { + sym_tp->concat(Type::Any); + } + } + // symbol entry for the function + SymbolEntry *fun_se = new SymbolEntry ( + this, + 0, // position. arbitrary numbering. must stay consistent when? + fun_name.c_str(), // passed to Ustring, no need to strdup + SymbolEntry::c_function, + sym_tp); + + fun_se->setGlobal (true); + + enterSymbol (fun_se, 0); + + return fun_se; +} + + YPythonNamespace::~YPythonNamespace () { @@ -261,14 +366,18 @@ return YCPNull (); } + // It seems that this is the standard implementation. why would we // ever want it to be different? Y2Function* YPythonNamespace::createFunctionCall (const string name, constFunctionTypePtr required_type) { y2debug ("Python creating function call for %s", name.c_str ()); - TableEntry *func_te = table ()->find (name.c_str (), SymbolEntry::c_function); + //TableEntry *func_te = table ()->find (name.c_str (), SymbolEntry::c_function); + TableEntry *func_te = table ()->find (name.c_str ()); + if (func_te) { + //cout << "namespace: " << m_name << " function: " << name << endl; constTypePtr t = required_type ? required_type : (constFunctionTypePtr)func_te->sentry()->type (); if (m_all_methods) { @@ -279,6 +388,8 @@ return new Y2PythonSubCall (m_name, name, t); } } + + //cout << "namespace: " << m_name << " function: " << name << endl; y2error ("No such function %s", name.c_str ()); return NULL; } Modified: trunk/python-bindings/src/YPythonNamespace.h URL: http://svn.opensuse.org/viewcvs/yast/trunk/python-bindings/src/YPythonNamespace.h?rev=42021&r1=42020&r2=42021&view=diff ============================================================================== --- trunk/python-bindings/src/YPythonNamespace.h (original) +++ trunk/python-bindings/src/YPythonNamespace.h Tue Nov 13 15:13:53 2007 @@ -13,12 +13,29 @@ string m_name; //! this namespace's name, eg. XML::Writer bool m_all_methods; //! add the class name to all calls public: + /** * Construct an interface. The module must be already loaded * @param name eg "XML::Writer" */ YPythonNamespace (string name); + /** + * Construct an interface. The module must be already loaded + * special contruct for calling python function such as reference + * @param name eg "XML::Writer" + * @param function function defined in python + */ + YPythonNamespace (string name, PyObject* function); + + /** + * Add new function into namespace + * @param Y2Namespace pointer to namespace for adding function + * @param PyObject pointer to function + * @return SymbolEntry pointer to added symbol entry else NULL (if failed) + */ + SymbolEntry * AddFunction (PyObject* function); + virtual ~YPythonNamespace (); //! what namespace do we implement -- To unsubscribe, e-mail: yast-commit+unsubscribe@opensuse.org For additional commands, e-mail: yast-commit+help@opensuse.org