wrapper_generator_struct.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include "openFileStream.h"
#include "header_generator.h"
#include "cmakelist_generator.h"
#include "wrapper_generator_module.h"
 
#include "wrapper_generator_struct.h"


void wrapper_generator_enum_header(const PWrapperTraitBackendManager & manager, std::ofstream & fs, const PClassConfig & classConfig, const GeneratorMode & mode){
        PString body, className(wrapper_getClassName(classConfig));
        fs << "//Allocation and deallocation\n";
        fs << "PyObject * "+className+"_newC(PyTypeObject * type, PyObject * args, PyObject * kwds);\n\n";
 
//      fs << "\nextern PyGetSetDef "+className+"_getseters[];\n";
//      fs << "extern PyMemberDef "+className+"_members[];\n";
//      fs << "extern PyMethodDef "+className+"_methods[];\n";
//      fs << "extern PyTypeObject "+className+"Type;\n\n";
}


void wrapper_generator_class_header(const PWrapperTraitBackendManager & manager, std::ofstream & fs, const PClassConfig & classConfig, const GeneratorMode & mode){
        PString body, className(wrapper_getClassName(classConfig));
        fs << classConfig.getClassDocumentation() + "\n";
        fs << "struct "+className+"{\n";
        fs << "\tPyObject_HEAD\n";
        const PVecClassAttribute & vecAttr = classConfig.getListAttribute();
        for(PVecClassAttribute::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                fs << project_wrapper_attributeDef(*it);
        }
        fs << "};\n\n";
//      fs << "//Check function\n";
//      fs << "bool "+className+"_check(std::string & error, const "+className+" & obj);\n";
        
        fs << "//TODO : add new and free for array data\n";
        fs << "//getter and setters\n";
//      for(PVecClassAttribute::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
//              fs << project_wrapper_classGetterSetterDef(className, *it);
//      }
        manager.classMethodDeclaration(fs, classConfig, mode);
        //Check when we defined std::vector
//      fs << "//Allocation and deallocation\n";
        fs << "PyObject * "+className+"_newC(PyTypeObject * type, PyObject * args, PyObject * kwds);\n";
        fs << "void "+className+"_dealloc("+className+" * self);\n\n";
        
        fs << "\nextern PyGetSetDef "+className+"_getseters[];\n";
        fs << "extern PyMemberDef "+className+"_members[];\n";
        fs << "extern PyMethodDef "+className+"_methods[];\n";
        fs << "extern PyTypeObject "+className+"Type;\n\n";
}


void project_wrapper_enumImplNewc(std::ofstream & fs, const PClassConfig & classConfig){
        const std::vector<PClassAttribute> & vecAttr = classConfig.getListAttribute();
        PString pythonClassName(classConfig.getName());
        PString className("WP"+pythonClassName);
        if(vecAttr.size() == 0lu){
                fs << "#error \""+className+" error : Missing enum values as attribute !\"" << std::endl;
                return;
        }
        fs << "///Generic function to create a "+className+" or a variable\n";
        fs << "/**\t@param extraPythonCode : extra python code to be added to the existing one\n";
        fs << " * \t@param objectName : name of the object to get\n";
        fs << " * \t@return pointer to the asked object name or NULL if the object was not found\n";
        fs << "*/\n";
        fs << "PyObject* "+className+"_newGeneric(const std::string & extraPythonCode, const std::string & objectName){\n";
        fs << "\t//First let's write the python code in a string\n";
        fs << "\t//Important note : it there is no default value of the enumerate values, we get a nice segmentation fault because why not\n";
        fs << "\tstd::string pythonStr(\"from enum import Enum\\n\"\n";
        fs << "\t\t\"class "+pythonClassName+"(Enum):\\n\"\n";
        size_t index(0lu);
        for(std::vector<PClassAttribute>::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                fs << "\t\t\"\t"+it->getName();
                fs << " = ";
                if(it->getDefaultValue() != ""){
                        fs << it->getDefaultValue();
                }else{
                        fs << index;
                }
                fs << "\\n\"\n";
                ++index;
        }
        fs << "\t\t\"\tdef getTypeName():\\n\"\n";
        fs << "\t\t\"\t\treturn \\\""+pythonClassName+"\\\"\\n\"\n";
        fs << "\t\t\"\");\n";
        fs << "\tpythonStr += extraPythonCode;\n";
        fs << "\t//Now, we create the global dictionnary of python\n";
        fs << "\tPyObject *global_dict = PyDict_New(), *outputEnum = NULL;\n";
        fs << "\tif(global_dict != NULL){\t//If we can create the global_dict\n";
        fs << "\t\t//Py_single_input\n";
        fs << "\t\tPyObject * runRes = PyRun_String(pythonStr.c_str(), Py_file_input, global_dict, global_dict);\n";
        fs << "\t\tif(runRes != NULL){\t//If Python is happy\n";
        fs << "\t\t\t//We try to get our enum back from the interpretor\n";
        fs << "\t\t\toutputEnum = PyDict_GetItemString(global_dict, objectName.c_str());\n";
        fs << "\t\t\tif(outputEnum == NULL){\n";
        fs << "\t\t\t\tPyErr_SetString(PyExc_KeyError, std::string(\""+className+"_newGeneric : could not get '\"+objectName+\"' with the ugly trick due to the fact that using an enum in a wrapper is even worst than using numpy\").c_str());\n";
        fs << "\t\t\t}else{\n";
        fs << "\t\t\t\tPy_INCREF(outputEnum);\n";
        fs << "\t\t\t}\n";
        fs << "\t\t}else{\n";
        fs << "\t\t\tPyErr_Print();\n";
        fs << "\t\t\tPyErr_SetString(PyExc_KeyError, \""+className+"_newGeneric : error when executing ugly python trick for enum\");\n";
        fs << "\t\t}\n";
        fs << "\t}else{\n";
        fs << "\t\tPyErr_SetString(PyExc_KeyError, std::string(\""+className+"_newGeneric : error when creating dictionnary to get enum '\"+objectName+\"'\").c_str());\n";
        fs << "\t}\n";
        fs << "\tPy_XDECREF(global_dict);\t//Same import error with of without\n";
        fs << "\treturn outputEnum;\n";
        fs << "}\n\n";
        
        fs << "///Allocate the "+className+"\n";
        fs << "/**\t@param type : type variable\n";
        fs << " * \t@param args : args variable\n";
        fs << " * \t@param kwds : kwds variable\n";
        fs << " * \t@return object to be allocated\n";
        fs << "*/\n";
        fs << "PyObject * "+className+"_newC(PyTypeObject * type, PyObject * args, PyObject * kwds){\n";
        fs << "\t//Here, we will use a very ugly trick but since we are doing python nobody will notice\n";
        fs << "\tPyObject* outputEnum = "+className+"_newGeneric(\"\", \""+pythonClassName+"\");\n";
        fs << "\treturn outputEnum;\n";
        fs << "}\n\n";
        
        fs << "///Allocate the "+className+"\n";
        fs << "/**\t@param type : type variable\n";
        fs << " * \t@param args : args variable\n";
        fs << " * \t@param kwds : kwds variable\n";
        fs << " * \t@return object to be allocated\n";
        fs << "*/\n";
        fs << "PyObject * "+className+"_newAttributeC(){\n";
        fs << "\t//Here, we will use a very ugly trick but since we are doing python nobody will notice\n";
        fs << "\tPyObject* outputEnum = "+className+"_newGeneric(\"_var_______ = "+pythonClassName+"."+vecAttr.front().getName()+"\\n\\n\", \"_var_______\");\n";
        fs << "\treturn outputEnum;\n";
        fs << "}\n\n";
}


void wrapper_generator_enum_source(const PWrapperTraitBackendManager & manager, std::ofstream & fs, const PClassConfig & classConfig, const GeneratorMode & mode){
        project_wrapper_enumImplNewc(fs, classConfig);
//      PString className(wrapper_getClassName(classConfig));
//      manager.classMethodImplementation(fs, classConfig, mode);
//      fs << project_wrapper_classImplPythonType(classConfig, mode.moduleName, "NULL");
        
}


void wrapper_generator_class_implNewc(std::ofstream & fs, const PClassConfig & classConfig){
        PString className("WP"+classConfig.getName());
        
        fs << "///Allocate the "+className+"\n";
        fs << "/**\t@param type : type variable\n";
        fs << " * \t@param args : args variable\n";
        fs << " * \t@param kwds : kwds variable\n";
        fs << " * \t@return object to be allocated\n";
        fs << "*/\n";
        fs << "PyObject * "+className+"_newC(PyTypeObject * type, PyObject * args, PyObject * kwds){\n";
        fs << "\t"+className+" *self;\n";
        fs << "\tself = ("+className+" *)type->tp_alloc(type, 0);\n";
        fs << "\tif(self != NULL){\n";
        const std::vector<PClassAttribute> & vecAttr = classConfig.getListAttribute();
        for(std::vector<PClassAttribute>::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                PString attrType(it->getType());
                if(getIsSimpleType(attrType)){
                        fs << "\t\tself->"+it->getName()+" = 0;\n";
                }else if(attrType == "std::string"){
                        fs << "\t\tself->"+it->getName()+" = Py_BuildValue(\"s\", \"\");\n";
                }else if(attrType == "DataStreamMsg"){
                        fs << "\t\tself->"+it->getName()+" = PyByteArray_FromStringAndSize(\"\", 0lu);\n";
                }else if(generator_typeIsList(attrType)){
                        fs << "\t\tself->"+it->getName()+" = PyList_New(0);\n";
                }else{
                        //TODO : check for complex types, vector, map, and nested types
                        if(it->getIsEnum()){
                                fs << "\t\t//There is not type for enum because of the very ugly trick of Python\n";
                                fs << "\t\tself->"+it->getName()+" = WP"+attrType+"_newAttributeC();\n";
                        }else{
                                fs << "\t\tself->"+it->getName()+" = WP"+attrType+"_newC(&WP"+attrType+"Type, NULL, NULL);\n";
                        }
                }
        }
        fs << "\t}\n";
        fs << "\treturn (PyObject *)self;\n";
        fs << "}\n\n";
}


void wrapper_generator_class_implDealloc(std::ofstream & fs, const PClassConfig & classConfig){
        PString className("WP"+classConfig.getName());
        fs << "///Deallocate the structure "+className+"\n";
        fs << "/**\t@param self : object to be deallocated\n";
        fs << "*/\n";
        fs << "void "+className+"_dealloc("+className+" * self){\n";
        const std::vector<PClassAttribute> & vecAttr = classConfig.getListAttribute();
        for(std::vector<PClassAttribute>::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                if(!getIsSimpleType(it->getType())){
                        PString attrName = it->getName();
                        fs << "\t//Free the "+attrName+" attribute\n";
                        fs << "\tPyObject* "+attrName+"_tmp = self->"+attrName+";\n";
                        fs << "\tself->"+attrName+" = NULL;\n";
                        fs << "\tPy_XDECREF("+attrName+"_tmp);\n";
                }
        }
        fs << "}\n\n";
}
 


void wrapper_generator_class_source(const PWrapperTraitBackendManager & manager, std::ofstream & fs, const PClassConfig & classConfig, const GeneratorMode & mode){
        PString className(wrapper_getClassName(classConfig));
        fs << "///Getters and setters of the class "<<className<<"\n";
        fs << "PyGetSetDef "<<className<<"_getseters[] = {\n";
        //Only for complex types
        manager.registerClassGetterSetter(fs, classConfig, mode);
        fs << "\t{NULL}  /* Sentinel */\n";
        fs << "};\n\n";
        
        //Only for simple types
        fs << "///Members of class "+className+"\n";
        fs << "PyMemberDef "+className+"_members[] = {\n";
        manager.registerClassMember(fs, classConfig, mode);
        fs << "\t{NULL}  /* Sentinel */\n";
        fs << "};\n\n";
//      METH_VARARGS
        fs << "///Methods of class "<<className<<"\n";
        fs << "PyMethodDef "<<className<<"_methods[] = {\n";
        manager.registerClassMethod(fs, classConfig, mode);
        fs << "\t{NULL,  NULL}  /* Sentinel */\n";
        fs << "};\n\n";
        
        wrapper_generator_class_implNewc(fs, classConfig);
        wrapper_generator_class_implDealloc(fs, classConfig);
        
        manager.classMethodImplementation(fs, classConfig, mode);
        
        fs << project_wrapper_classImplPythonType(classConfig, mode.moduleName, "NULL");
//      fs << project_wrapper_classImplCheck(classConfig, moduleName);
        
}


bool wrapper_generator_class_headerFile(const PWrapperTraitBackendManager & manager, const PPath & headerFile, const PVecClassConfig & vecClassConfig, const GeneratorMode & mode, const PVecPath & vecInclude){
        if(headerFile == "") return false;
        std::ofstream fs;
        if(!openFileStream(fs, headerFile)){return false;}
        licenceSave(fs);
        PString macroDef(makeMultiIncludeDefineMacro(headerFile.getFileName()));
        fs << "#ifndef " << macroDef << std::endl;
        fs << "#define " << macroDef << std::endl << std::endl;
        fs << "#include <Python.h>\n";
        fs << "#include <structmember.h>\n";
        fs << "#include <iostream>\n\n";
        fs << "#include <string>" << std::endl<< std::endl;
        if(vecInclude.size() != 0lu){
                for(PVecPath::const_iterator it(vecInclude.begin()); it != vecInclude.end(); ++it){
                        fs << "#include " << *it << std::endl;
                }
                fs << std::endl;
        }
        manager.headerExtraInclude(fs, mode);
        fs << std::endl;
        for(std::vector<PClassConfig>::const_iterator it(vecClassConfig.begin()); it != vecClassConfig.end(); ++it){
                if(it->getIsEnum()){
                        wrapper_generator_enum_header(manager, fs, *it, mode);
//                      saveEnumDecl(fs, *it, mode);
                }else{
                        wrapper_generator_class_header(manager, fs, *it, mode);
                }
        }
        fs << std::endl << std::endl << "#endif" << std::endl << std::endl;
        fs.close();
        return true;
}


bool wrapper_generator_class_sourceFile(const PWrapperTraitBackendManager & manager, const PPath & sourceFile, const PPath & headerFile, const std::vector<PClassConfig> & vecClassConfig, const GeneratorMode & mode){
        if(sourceFile == "" || headerFile == "") return false;
        std::ofstream fs;
        if(!openFileStream(fs, sourceFile)){return false;}
        licenceSave(fs);
        fs << std::endl << "#include \"" << headerFile.getFileName() << "\"" << std::endl << std::endl;
        for(std::vector<PClassConfig>::const_iterator it(vecClassConfig.begin()); it != vecClassConfig.end(); ++it){
                if(it->getIsEnum()){
                        wrapper_generator_enum_source(manager, fs, *it, mode);
                }else{
                        wrapper_generator_class_source(manager, fs, *it, mode);
                }
        }
        fs.close();
        return true;
}


bool wrapper_generator_class_cpp(const PWrapperTraitBackendManager & manager, const std::vector<PClassConfig> & vecClassConfig, const PPath & outputSourceDir, const PPath & baseFileName, const GeneratorMode & mode, const PVecPath & vecInclude){
        if(baseFileName == "") return false;
        PPath outputDir = outputSourceDir / PPath(mode.moduleName);
        if(!outputDir.createDirectory()){return false;}
        if(!wrapper_generator_class_headerFile(manager, outputDir / PPath(baseFileName + "_wrapper.h"), vecClassConfig, mode, vecInclude)){return false;}
        if(!wrapper_generator_class_sourceFile(manager, outputDir / PPath(baseFileName + PString("_wrapper.cpp")), PPath(baseFileName + PString("_wrapper.h")), vecClassConfig, mode)){return false;}
        return true;
        
}


bool project_wrapper_generator_setuppy(const PWrapperTraitBackendManager & manager, const ProjectParam & projectParam, const PPath & fileNameSetup, const PString & projectVersion){
        std::ofstream fs;
        if(!openFileStream(fs, fileNameSetup)){return false;}
        PString moduleName = projectParam.mode.moduleName;
        fs << getCMakeListsHeader();
        fs << "from setuptools import setup\n";
        fs << "from setuptools import Extension\n";
        fs << "import sys\n";
        fs << "#import numpy as np\n";
        fs << "import subprocess\n";
        fs << "\n\n";
        fs << "def getConfigInfo(commandName, option):" << std::endl;
        fs << "\t\"\"\"" << std::endl;
        fs << "\tGet information of a dependency from a command" << std::endl;
        fs << "\t# Parameters" << std::endl;
        fs << "\t- `commandName` : command to be executed" << std::endl;
        fs << "\t- `option` : option to be used" << std::endl;
        fs << "\t# Returns" << std::endl;
        fs << "\tCorresponding dependency info" << std::endl;
        fs << "\t\"\"\"" << std::endl;
        fs << "\treturn subprocess.run([commandName, option], capture_output = True, text = True).stdout.strip(\"\\n\")" << std::endl;
        fs << "\n\n";
        fs << "def addWrapperDependency(listIncludeDir, listLibDir, listLib, dependencyConfigProgram, listLibDep):" << std::endl;
        fs << "\t\"\"\"" << std::endl;
        fs << "\tAdd a dependency to the list of existing ones" << std::endl;
        fs << "\t# Parameters" << std::endl;
        fs << "\t- `listIncludeDir` : list of include directories" << std::endl;
        fs << "\t- `listLibDir` : list of libraries directories" << std::endl;
        fs << "\t- `listLib` : list of libraries" << std::endl;
        fs << "\t- `dependencyConfigProgram` : executable to be called to get include and lib dir of the dependency" << std::endl;
        fs << "\t- `listLibDep` : list of libraries to be appended to the listLib" << std::endl;
        fs << "\t\"\"\"" << std::endl;
        fs << "\tlistIncludeDir.append(getConfigInfo(dependencyConfigProgram, \"--include\"))" << std::endl;
        fs << "\tlistLibDir.append(getConfigInfo(dependencyConfigProgram, \"--lib\"))" << std::endl;
        fs << "\tlistLib.extend(listLibDep)" << std::endl;
        fs << "\n\n";
        fs << "listIncludeDir = []" << std::endl;
        fs << "listLibDir = []" << std::endl;
        fs << "listLib = []" << std::endl;
        
        fs << "#listIncludeDir.append(np.get_include())" << std::endl;
        fs << "#Here we call all trait wrapper such as" << std::endl;
        fs << "#addWrapperDependency(listIncludeDir, listLibDir, listLib, \"phoenixdatastream-config\", [\"phoenix_data_stream\"])" << std::endl;
        manager.setupAddDependency(fs, projectParam.mode);
        fs << "#The rest of the includes" << std::endl;
        fs << "listIncludeDir.append(\"./\")" << std::endl;
        fs << "listIncludeDir.append(\""<<moduleName<<"/\")" << std::endl;
        
        fs << "ext_modules = [\n";
        fs << "\tExtension(\""+moduleName+"\", sources=([\n";
        for(const PDataConfig & config : projectParam.vecDataConfig){
                fs << "\t\t\"src/"+moduleName+"/"+config.getFileName().getFileName().eraseExtension()+"_wrapper.cpp\",\n";
        }
        fs << "\t\t\"src/"+moduleName+"/"+projectParam.name.toLower()+"_module.cpp\"\n";
        fs << "\t]),\n";
        fs << "\textra_compile_args = [\"-O3\", \"-Werror\", \"-g\"],\n";
        
        fs << "\tinclude_dirs = listIncludeDir,\n";
        fs << "\tlibraries=listLib,\n";
        fs << "\tlibrary_dirs=listLibDir,\n";
        fs << "\t)\n";
        fs << "]\n\n";
        
        fs << "try:\n";
        fs << "\tsetup(\n";
        fs << "\t\tname=\""+moduleName+"\",\n";
        fs << "\t\tversion=\""+projectVersion+"\",\n";
        fs << "\t\text_modules=ext_modules,\n";
        fs << "\t)\n";
        fs << "except Exception as e:\n";
        fs << "\tprint(str(e))\n";
        fs << "\tsys.exit(-1)\n";
        fs << "\n";
        fs.close();
        return true;
}


bool project_wrapper_classTest(const PWrapperTraitBackendManager & manager, const PPath & testDirectory, const PString & moduleName,
                const PClassConfig & classConfig, const GeneratorMode & mode)
{
        PString className(classConfig.getName());
        PPath fileNameTest(testDirectory / PPath("test_" + className + ".py"));
        std::ofstream fs;
        if(!openFileStream(fs, fileNameTest)){return false;}
        
        fs << "\n";
        fs << getCMakeListsHeader();
        fs << "\n";
        if(!classConfig.getIsEnum()){
                fs << "import "+moduleName+"\n";
        }
        fs << "from "+moduleName+" import "+className+"\n";
        fs << "\n";
        
        manager.testFunction(fs, classConfig, mode);
        
//      fs << "#Unit Test of the " + className + "\n";
//      fs << "def test_"+className+"():\n";
//      
//      fs << "\tassert "+className+".getTypeName() == \"" + className + "\"\n";
//      if(!classConfig.getIsEnum()){
//              fs << "\t#Let's test the stream now\n";
//              fs << "\tshadok = "+moduleName+"."+className+"()\n";
//              const std::vector<PClassAttribute> & vecAttr = classConfig.getListAttribute();
//              for(std::vector<PClassAttribute>::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
//                      fs << pythonDefaultTestValue("shadok", *it, moduleName, "\t", mapClass);
//              }
//              fs << "\tstream = shadok.toBytes()\n";
//              fs << "\tassert len(stream) != 0\n";
//              fs << "\t\n";
//              fs << "\tother = "+moduleName+"."+className+"()\n";
//              fs << "\tother.fromBytes(stream)\n";
//              for(std::vector<PClassAttribute>::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
//                      fs << pythonAssertTestValue("other", *it, moduleName, "\t", mapClass);
//              }
//              fs << "\t\n";
//              fs << "\t\n";
//              fs << "\t\n";
//              fs << "\t\n";
//              fs << "\t\n";
//      }
        fs.close();
        return true;
}


bool wrapper_generator_class_cpp_test(const PWrapperTraitBackendManager & manager, const PPath & testDirectory, const PString & moduleName, const std::vector<PClassConfig> & vecClassConfig, const GeneratorMode & mode){
        if(!testDirectory.createDirectory()){return false;}
        bool b(true);
        GeneratorMode updateMode(mode);
        for(std::vector<PClassConfig>::const_iterator it(vecClassConfig.begin()); it != vecClassConfig.end() && b; ++it){
                updateMode.mapClass[it->getName()] = *it;
        }
        for(std::vector<PClassConfig>::const_iterator it(vecClassConfig.begin()); it != vecClassConfig.end() && b; ++it){
                b &= project_wrapper_classTest(manager, testDirectory, moduleName, *it, updateMode);
        }
        return b;
}


bool wrapper_generator_class_full(const PWrapperTraitBackendManager & manager, const ProjectParam & projectParam){
        bool b(true);
        b &= projectParam.outputSourceDir.createDirectory();
        b &= projectParam.outputTestDir.createDirectory();
        ProjectParam updatedParam(projectParam);
        updatedParam.mode.moduleName = "py"+updatedParam.name.toLower();
        for(const PDataConfig & config : updatedParam.vecDataConfig){
                PPath baseFileName = config.getFileName().getFileName().eraseExtension();
                b &= wrapper_generator_class_cpp(manager, config.getVecClassConfig(), updatedParam.outputSourceDir, baseFileName, updatedParam.mode,     config.getVecInclude());
                b &= wrapper_generator_class_cpp_test(manager, updatedParam.outputTestDir, updatedParam.mode.moduleName, config.getVecClassConfig(),  updatedParam.mode);
        }
        PPath outputModuleSrc = updatedParam.outputSourceDir / PPath(updatedParam.mode.moduleName) / PPath(updatedParam.name.toLower() + "_module.cpp");
        b &= project_wrapper_moduleGeneratorMain(outputModuleSrc, updatedParam);
        b &= project_wrapper_generator_setuppy(manager, updatedParam, updatedParam.outputProjectDir / PPath("setup.py"), updatedParam.version);
        return b;
}